feat: added cancellation for most polykey vaults commands

MatrixAI · Dec 12, 2024 · d518114 · d518114
1 parent 7b14e96
commit d518114
Show file tree

Hide file tree

Showing 17 changed files with 278 additions and 199 deletions.
diff --git a/src/client/handlers/AgentStatus.ts b/src/client/handlers/AgentStatus.ts
@@ -5,8 +5,8 @@ import type {
 } from '../types';
 import type PolykeyAgent from '../../PolykeyAgent';
 import { UnaryHandler } from '@matrixai/rpc';
-import * as nodesUtils from '../../nodes/utils';
 import config from '../../config';
+import * as nodesUtils from '../../nodes/utils';
 
 class AgentStatus extends UnaryHandler<
   {

diff --git a/src/client/handlers/AuditEventsGet.ts b/src/client/handlers/AuditEventsGet.ts
@@ -1,4 +1,5 @@
 import type { ContextTimed } from '@matrixai/contexts';
+import type { JSONValue } from '@matrixai/rpc';
 import type { ClientRPCRequestParams, ClientRPCResponseResult } from '../types';
 import type {
   AuditEvent,
@@ -42,8 +43,8 @@ class AuditEventsGet extends ServerHandler<
     }> & {
       paths: Array<TopicSubPath>;
     },
-    _cancel,
-    _meta,
+    _cancel: (reason?: any) => void,
+    _meta: Record<string, JSONValue>,
     ctx: ContextTimed,
   ): AsyncGenerator<ClientRPCResponseResult<AuditEventSerialized>> {
     const { audit }: { audit: Audit } = this.container;

diff --git a/src/client/handlers/GestaltsActionsGetByIdentity.ts b/src/client/handlers/GestaltsActionsGetByIdentity.ts
@@ -8,9 +8,9 @@ import type GestaltGraph from '../../gestalts/GestaltGraph';
 import type { GestaltAction } from '../../gestalts/types';
 import type { IdentityId, ProviderId } from '../../ids';
 import { UnaryHandler } from '@matrixai/rpc';
-import * as ids from '../../ids';
 import { validateSync } from '../../validation';
 import { matchSync } from '../../utils';
+import * as ids from '../../ids';
 
 class GestaltsActionsGetByIdentity extends UnaryHandler<
   {

diff --git a/src/client/handlers/VaultsClone.ts b/src/client/handlers/VaultsClone.ts
@@ -1,16 +1,15 @@
+import type { ContextTimed } from '@matrixai/contexts';
 import type { DB } from '@matrixai/db';
+import type { JSONValue } from '@matrixai/rpc';
 import type {
   ClientRPCRequestParams,
   ClientRPCResponseResult,
   CloneMessage,
   SuccessMessage,
 } from '../types';
 import type VaultManager from '../../vaults/VaultManager';
-import type { NodeId } from '../../ids';
 import { UnaryHandler } from '@matrixai/rpc';
 import * as ids from '../../ids';
-import { validateSync } from '../../validation';
-import { matchSync } from '../../utils';
 
 class VaultsClone extends UnaryHandler<
   {
@@ -22,27 +21,15 @@ class VaultsClone extends UnaryHandler<
 > {
   public handle = async (
     input: ClientRPCRequestParams<CloneMessage>,
+    _cancel: (reason?: any) => void,
+    _meta: Record<string, JSONValue>,
+    ctx: ContextTimed,
   ): Promise<ClientRPCResponseResult<SuccessMessage>> => {
     const { db, vaultManager }: { db: DB; vaultManager: VaultManager } =
       this.container;
-    const {
-      nodeId,
-    }: {
-      nodeId: NodeId;
-    } = validateSync(
-      (keyPath, value) => {
-        return matchSync(keyPath)(
-          [['nodeId'], () => ids.parseNodeId(value)],
-          () => value,
-        );
-      },
-      {
-        nodeId: input.nodeIdEncoded,
-      },
-    );
-    // Vault id
+    const nodeId = ids.parseNodeId(input.nodeIdEncoded);
     await db.withTransactionF(async (tran) => {
-      await vaultManager.cloneVault(nodeId, input.nameOrId, tran);
+      await vaultManager.cloneVault(nodeId, input.nameOrId, ctx, tran);
     });
     return { type: 'success', success: true };
   };

diff --git a/src/client/handlers/VaultsCreate.ts b/src/client/handlers/VaultsCreate.ts
@@ -1,4 +1,6 @@
+import type { ContextTimed } from '@matrixai/contexts';
 import type { DB } from '@matrixai/db';
+import type { JSONValue } from '@matrixai/rpc';
 import type {
   ClientRPCRequestParams,
   ClientRPCResponseResult,
@@ -19,17 +21,16 @@ class VaultsCreate extends UnaryHandler<
 > {
   public handle = async (
     input: ClientRPCRequestParams<VaultNameMessage>,
+    _cancel: (reason?: any) => void,
+    _meta: Record<string, JSONValue>,
+    ctx: ContextTimed,
   ): Promise<ClientRPCResponseResult<VaultIdMessage>> => {
     const { db, vaultManager }: { db: DB; vaultManager: VaultManager } =
       this.container;
-
     const vaultId = await db.withTransactionF((tran) =>
-      vaultManager.createVault(input.vaultName, tran),
+      vaultManager.createVault(input.vaultName, ctx, tran),
     );
-
-    return {
-      vaultIdEncoded: vaultsUtils.encodeVaultId(vaultId),
-    };
+    return { vaultIdEncoded: vaultsUtils.encodeVaultId(vaultId) };
   };
 }
 

diff --git a/src/client/handlers/VaultsDelete.ts b/src/client/handlers/VaultsDelete.ts
@@ -1,15 +1,16 @@
+import type { ContextTimed } from '@matrixai/contexts';
 import type { DB } from '@matrixai/db';
+import type { JSONValue } from '@matrixai/rpc';
 import type {
   ClientRPCRequestParams,
   ClientRPCResponseResult,
   SuccessMessage,
   VaultIdentifierMessage,
 } from '../types';
 import type VaultManager from '../../vaults/VaultManager';
-import type { VaultName } from '../../vaults/types';
 import { UnaryHandler } from '@matrixai/rpc';
-import * as vaultsUtils from '../../vaults/utils';
 import * as vaultsErrors from '../../vaults/errors';
+import * as vaultsUtils from '../../vaults/utils';
 
 class VaultsDelete extends UnaryHandler<
   {
@@ -21,20 +22,25 @@ class VaultsDelete extends UnaryHandler<
 > {
   public handle = async (
     input: ClientRPCRequestParams<VaultIdentifierMessage>,
+    _cancel: (reason?: any) => void,
+    _meta: Record<string, JSONValue>,
+    ctx: ContextTimed,
   ): Promise<ClientRPCResponseResult<SuccessMessage>> => {
     const { db, vaultManager }: { db: DB; vaultManager: VaultManager } =
       this.container;
     await db.withTransactionF(async (tran) => {
       const vaultIdFromName = await vaultManager.getVaultId(
-        input.nameOrId as VaultName,
+        input.nameOrId,
         tran,
       );
       const vaultId =
         vaultIdFromName ?? vaultsUtils.decodeVaultId(input.nameOrId);
       if (vaultId == null) {
-        throw new vaultsErrors.ErrorVaultsVaultUndefined();
+        throw new vaultsErrors.ErrorVaultsVaultUndefined(
+          `Vault "${input.nameOrId}" does not exist`,
+        );
       }
-      await vaultManager.destroyVault(vaultId, tran);
+      await vaultManager.destroyVault(vaultId, ctx, tran);
     });
     return { type: 'success', success: true };
   };

diff --git a/src/client/handlers/VaultsList.ts b/src/client/handlers/VaultsList.ts
@@ -1,10 +1,12 @@
+import type { ContextTimed } from '@matrixai/contexts';
 import type { DB } from '@matrixai/db';
 import type {
   ClientRPCRequestParams,
   ClientRPCResponseResult,
   VaultListMessage,
 } from '../types';
 import type VaultManager from '../../vaults/VaultManager';
+import type { JSONValue } from '@matrixai/rpc';
 import { ServerHandler } from '@matrixai/rpc';
 import * as vaultsUtils from '../../vaults/utils';
 
@@ -17,21 +19,21 @@ class VaultsList extends ServerHandler<
   ClientRPCResponseResult<VaultListMessage>
 > {
   public handle = async function* (
-    _input,
-    _cancel,
-    _meta,
-    ctx,
+    _input: ClientRPCRequestParams,
+    _cancel: (reason?: any) => void,
+    _meta: Record<string, JSONValue>,
+    ctx: ContextTimed,
   ): AsyncGenerator<ClientRPCResponseResult<VaultListMessage>> {
     if (ctx.signal.aborted) throw ctx.signal.reason;
     const { db, vaultManager }: { db: DB; vaultManager: VaultManager } =
       this.container;
     const vaults = await db.withTransactionF((tran) =>
-      vaultManager.listVaults(tran),
+      vaultManager.listVaults(ctx, tran),
     );
     for await (const [vaultName, vaultId] of vaults) {
       if (ctx.signal.aborted) throw ctx.signal.reason;
       yield {
-        vaultName,
+        vaultName: vaultName,
         vaultIdEncoded: vaultsUtils.encodeVaultId(vaultId),
       };
     }

diff --git a/src/client/handlers/VaultsLog.ts b/src/client/handlers/VaultsLog.ts
@@ -1,12 +1,13 @@
+import type { ContextTimed } from '@matrixai/contexts';
 import type { DB } from '@matrixai/db';
+import type { JSONValue } from '@matrixai/rpc';
 import type {
   ClientRPCRequestParams,
   ClientRPCResponseResult,
   LogEntryMessage,
   VaultsLogMessage,
 } from '../types';
 import type VaultManager from '../../vaults/VaultManager';
-import type { VaultName } from '../../vaults/types';
 import { ServerHandler } from '@matrixai/rpc';
 import * as vaultsUtils from '../../vaults/utils';
 import * as vaultsErrors from '../../vaults/errors';
@@ -21,29 +22,32 @@ class VaultsLog extends ServerHandler<
 > {
   public handle = async function* (
     input: ClientRPCRequestParams<VaultsLogMessage>,
-    _cancel,
-    _meta,
-    ctx,
+    _cancel: (reason?: any) => void,
+    _meta: Record<string, JSONValue>,
+    ctx: ContextTimed,
   ): AsyncGenerator<ClientRPCResponseResult<LogEntryMessage>> {
     if (ctx.signal.aborted) throw ctx.signal.reason;
     const { db, vaultManager }: { db: DB; vaultManager: VaultManager } =
       this.container;
     const log = await db.withTransactionF(async (tran) => {
       const vaultIdFromName = await vaultManager.getVaultId(
-        input.nameOrId as VaultName,
+        input.nameOrId,
         tran,
       );
       const vaultId =
         vaultIdFromName ?? vaultsUtils.decodeVaultId(input.nameOrId);
       if (vaultId == null) {
-        throw new vaultsErrors.ErrorVaultsVaultUndefined();
+        throw new vaultsErrors.ErrorVaultsVaultUndefined(
+          `Vault "${input.nameOrId}" does not exist`,
+        );
       }
       // Getting the log
       return await vaultManager.withVaults(
         [vaultId],
         async (vault) => {
           return await vault.log(input.commitId, input.depth);
         },
+        ctx,
         tran,
       );
     });

diff --git a/src/client/handlers/VaultsPermissionGet.ts b/src/client/handlers/VaultsPermissionGet.ts
@@ -1,4 +1,6 @@
+import type { ContextTimed } from '@matrixai/contexts';
 import type { DB } from '@matrixai/db';
+import type { JSONValue } from '@matrixai/rpc';
 import type {
   ClientRPCRequestParams,
   ClientRPCResponseResult,
@@ -26,9 +28,9 @@ class VaultsPermissionGet extends ServerHandler<
 > {
   public handle = async function* (
     input: ClientRPCRequestParams<VaultIdentifierMessage>,
-    _cancel,
-    _meta,
-    ctx,
+    _cancel: (reason?: any) => void,
+    _meta: Record<string, JSONValue>,
+    ctx: ContextTimed,
   ): AsyncGenerator<ClientRPCResponseResult<VaultPermissionMessage>> {
     if (ctx.signal.aborted) throw ctx.signal.reason;
     const {
@@ -45,7 +47,9 @@ class VaultsPermissionGet extends ServerHandler<
         const vaultId =
           vaultIdFromName ?? vaultsUtils.decodeVaultId(input.nameOrId);
         if (vaultId == null) {
-          throw new vaultsErrors.ErrorVaultsVaultUndefined();
+          throw new vaultsErrors.ErrorVaultsVaultUndefined(
+            `Vault "${input.nameOrId}" does not exist`,
+          );
         }
         // Getting permissions
         return [await acl.getVaultPerm(vaultId, tran), vaultId];

diff --git a/src/client/handlers/VaultsPermissionSet.ts b/src/client/handlers/VaultsPermissionSet.ts
@@ -6,17 +6,14 @@ import type {
   SuccessMessage,
 } from '../types';
 import type ACL from '../../acl/ACL';
-import type { VaultAction, VaultActions } from '../../vaults/types';
-import type { NodeId } from '../../ids';
+import type { VaultActions } from '../../vaults/types';
 import type VaultManager from '../../vaults/VaultManager';
 import type NotificationsManager from '../../notifications/NotificationsManager';
 import type GestaltGraph from '../../gestalts/GestaltGraph';
 import { UnaryHandler } from '@matrixai/rpc';
 import * as ids from '../../ids';
 import * as vaultsUtils from '../../vaults/utils';
 import * as vaultsErrors from '../../vaults/errors';
-import { validateSync } from '../../validation';
-import { matchSync } from '../../utils';
 
 class VaultsPermissionSet extends UnaryHandler<
   {
@@ -53,30 +50,21 @@ class VaultsPermissionSet extends UnaryHandler<
       const vaultId =
         vaultIdFromName ?? vaultsUtils.decodeVaultId(input.nameOrId);
       if (vaultId == null) {
-        throw new vaultsErrors.ErrorVaultsVaultUndefined();
+        throw new vaultsErrors.ErrorVaultsVaultUndefined(
+          `Vault "${input.nameOrId}" does not exist`,
+        );
       }
-      const {
-        nodeId,
-        actions,
-      }: {
-        nodeId: NodeId;
-        actions: Array<VaultAction>;
-      } = validateSync(
-        (keyPath, value) => {
-          return matchSync(keyPath)(
-            [['nodeId'], () => ids.parseNodeId(value)],
-            [['actions'], () => value.map(vaultsUtils.parseVaultAction)],
-            () => value,
-          );
-        },
-        {
-          nodeId: input.nodeIdEncoded,
-          actions: input.vaultPermissionList,
-        },
+      const nodeId = ids.parseNodeId(input.nodeIdEncoded);
+      const actions = input.vaultPermissionList.map(
+        vaultsUtils.parseVaultAction,
       );
       // Checking if vault exists
       const vaultMeta = await vaultManager.getVaultMeta(vaultId, tran);
-      if (!vaultMeta) throw new vaultsErrors.ErrorVaultsVaultUndefined();
+      if (!vaultMeta) {
+        throw new vaultsErrors.ErrorVaultsVaultUndefined(
+          `Vault "${input.nameOrId}" does not exist`,
+        );
+      }
       // Setting permissions
       const actionsSet: VaultActions = {};
       await gestaltGraph.setGestaltAction(['node', nodeId], 'scan', tran);