wip: adding gestalts handlers

[ci skip]
MatrixAI · Mar 1, 2023 · 9258456 · 9258456
1 parent b45b98c
commit 9258456
Show file tree

Hide file tree

Showing 15 changed files with 854 additions and 37 deletions.
diff --git a/src/clientRPC/handlers/agentLockAll.ts b/src/clientRPC/handlers/agentLockAll.ts
@@ -1,4 +1,3 @@
-import type Logger from '@matrixai/logger';
 import type { RPCRequestParams, RPCResponseResult } from '../types';
 import type { DB } from '@matrixai/db';
 import type SessionManager from '../../sessions/SessionManager';
@@ -14,15 +13,13 @@ class AgentLockAllHandler extends UnaryHandler<
   {
     sessionManager: SessionManager;
     db: DB;
-    logger: Logger;
   },
   RPCRequestParams,
   RPCResponseResult
 > {
   public async handle(): Promise<RPCResponseResult> {
-    await this.container.db.withTransactionF((tran) =>
-      this.container.sessionManager.resetKey(tran),
-    );
+    const { db, sessionManager } = this.container;
+    await db.withTransactionF((tran) => sessionManager.resetKey(tran));
     return {};
   }
 }

diff --git a/src/clientRPC/handlers/agentStatus.ts b/src/clientRPC/handlers/agentStatus.ts
@@ -1,6 +1,4 @@
 import type KeyRing from '../../keys/KeyRing';
-import type CertManager from '../../keys/CertManager';
-import type Logger from '@matrixai/logger';
 import type { NodeIdEncoded } from '../../ids';
 import type { RPCRequestParams, RPCResponseResult } from '../types';
 import * as nodesUtils from '../../nodes/utils';
@@ -22,18 +20,17 @@ const agentStatusCaller = new UnaryCaller<
 class AgentStatusHandler extends UnaryHandler<
   {
     keyRing: KeyRing;
-    certManager: CertManager;
-    logger: Logger;
   },
   RPCRequestParams,
   RPCResponseResult<StatusResult>
 > {
   public async handle(): Promise<RPCResponseResult<StatusResult>> {
+    const { keyRing } = this.container;
     return {
       pid: process.pid,
-      nodeId: nodesUtils.encodeNodeId(this.container.keyRing.getNodeId()),
+      nodeId: nodesUtils.encodeNodeId(keyRing.getNodeId()),
       publicJwk: JSON.stringify(
-        keysUtils.publicKeyToJWK(this.container.keyRing.keyPair.publicKey),
+        keysUtils.publicKeyToJWK(keyRing.keyPair.publicKey),
       ),
     };
   }

diff --git a/src/clientRPC/handlers/agentStop.ts b/src/clientRPC/handlers/agentStop.ts
@@ -16,7 +16,7 @@ class AgentStopHandler extends UnaryHandler<
   RPCResponseResult
 > {
   public async handle(): Promise<RPCResponseResult> {
-    const pkAgent = this.container.pkAgent;
+    const { pkAgent } = this.container;
     // If not running or in stopping status, then respond successfully
     if (!pkAgent[running] || pkAgent[status] === 'stopping') {
       return {};

diff --git a/src/clientRPC/handlers/agentUnlock.ts b/src/clientRPC/handlers/agentUnlock.ts
@@ -1,5 +1,5 @@
-import type Logger from '@matrixai/logger';
 import type { RPCRequestParams, RPCResponseResult } from '../types';
+import type { ContainerType } from 'RPC/types';
 import { UnaryHandler } from '../../RPC/handlers';
 import { UnaryCaller } from '../../RPC/callers';
 
@@ -9,7 +9,7 @@ const agentUnlockCaller = new UnaryCaller<
 >();
 
 class AgentUnlockHandler extends UnaryHandler<
-  { logger: Logger },
+  ContainerType,
   RPCRequestParams,
   RPCResponseResult
 > {

diff --git a/src/clientRPC/handlers/gestaltsActionsGetByIdentity.ts b/src/clientRPC/handlers/gestaltsActionsGetByIdentity.ts
@@ -0,0 +1,78 @@
+import type { RPCRequestParams, RPCResponseResult } from '../types';
+import type GestaltGraph from 'gestalts/GestaltGraph';
+import type { DB } from '@matrixai/db';
+import type { IdentityId, ProviderId } from 'ids/index';
+import type { GestaltAction } from 'gestalts/types';
+import { UnaryCaller } from '../../RPC/callers';
+import { UnaryHandler } from '../../RPC/handlers';
+import { validateSync } from '../../validation/index';
+import { matchSync } from '../../utils/index';
+import * as validationUtils from '../../validation/utils';
+
+const gestaltsActionsGetByIdentityCaller = new UnaryCaller<
+  RPCRequestParams<{
+    providerId: string;
+    identityId: string;
+  }>,
+  RPCResponseResult<{
+    actionsList: Array<string>;
+  }>
+>();
+
+class GestaltsActionsGetByIdentityHandler extends UnaryHandler<
+  {
+    gestaltGraph: GestaltGraph;
+    db: DB;
+  },
+  RPCRequestParams<{
+    providerId: string;
+    identityId: string;
+  }>,
+  RPCResponseResult<{
+    actionsList: Array<GestaltAction>;
+  }>
+> {
+  public async handle(
+    input: RPCRequestParams<{
+      providerId: string;
+      identityId: string;
+    }>,
+  ): Promise<
+    RPCResponseResult<{
+      actionsList: Array<GestaltAction>;
+    }>
+  > {
+    const { db, gestaltGraph } = this.container;
+    const {
+      providerId,
+      identityId,
+    }: { providerId: ProviderId; identityId: IdentityId } = validateSync(
+      (keyPath, value) => {
+        return matchSync(keyPath)(
+          [['providerId'], () => validationUtils.parseProviderId(value)],
+          [['identityId'], () => validationUtils.parseIdentityId(value)],
+          () => value,
+        );
+      },
+      {
+        providerId: input.providerId,
+        identityId: input.identityId,
+      },
+    );
+    const result = await db.withTransactionF((tran) =>
+      gestaltGraph.getGestaltActions(
+        ['identity', [providerId, identityId]],
+        tran,
+      ),
+    );
+
+    return {
+      actionsList: Object.keys(result) as Array<GestaltAction>,
+    };
+  }
+}
+
+export {
+  gestaltsActionsGetByIdentityCaller,
+  GestaltsActionsGetByIdentityHandler,
+};
diff --git a/src/clientRPC/handlers/gestaltsActionsGetByNode.ts b/src/clientRPC/handlers/gestaltsActionsGetByNode.ts
@@ -0,0 +1,64 @@
+import type { RPCRequestParams, RPCResponseResult } from '../types';
+import type GestaltGraph from 'gestalts/GestaltGraph';
+import type { DB } from '@matrixai/db';
+import type { GestaltAction } from 'gestalts/types';
+import type { NodeId, NodeIdEncoded } from 'ids/index';
+import { UnaryCaller } from '../../RPC/callers';
+import { UnaryHandler } from '../../RPC/handlers';
+import { validateSync } from '../../validation/index';
+import { matchSync } from '../../utils/index';
+import * as validationUtils from '../../validation/utils';
+
+const gestaltsActionsGetByNodeCaller = new UnaryCaller<
+  RPCRequestParams<{
+    nodeIdEncoded: NodeIdEncoded;
+  }>,
+  RPCResponseResult<{
+    actionsList: Array<GestaltAction>;
+  }>
+>();
+
+class GestaltsActionsGetByNodeHandler extends UnaryHandler<
+  {
+    gestaltGraph: GestaltGraph;
+    db: DB;
+  },
+  RPCRequestParams<{
+    nodeIdEncoded: NodeIdEncoded;
+  }>,
+  RPCResponseResult<{
+    actionsList: Array<GestaltAction>;
+  }>
+> {
+  public async handle(
+    input: RPCRequestParams<{
+      nodeIdEncoded: NodeIdEncoded;
+    }>,
+  ): Promise<
+    RPCResponseResult<{
+      actionsList: Array<GestaltAction>;
+    }>
+  > {
+    const { db, gestaltGraph } = this.container;
+    const { nodeId }: { nodeId: NodeId } = validateSync(
+      (keyPath, value) => {
+        return matchSync(keyPath)(
+          [['nodeId'], () => validationUtils.parseNodeId(value)],
+          () => value,
+        );
+      },
+      {
+        nodeId: input.nodeIdEncoded,
+      },
+    );
+    const result = await db.withTransactionF((tran) =>
+      gestaltGraph.getGestaltActions(['node', nodeId], tran),
+    );
+
+    return {
+      actionsList: Object.keys(result) as Array<GestaltAction>,
+    };
+  }
+}
+
+export { gestaltsActionsGetByNodeCaller, GestaltsActionsGetByNodeHandler };
diff --git a/src/clientRPC/handlers/gestaltsActionsSetByIdentity.ts b/src/clientRPC/handlers/gestaltsActionsSetByIdentity.ts
@@ -0,0 +1,78 @@
+import type { RPCRequestParams, RPCResponseResult } from '../types';
+import type { DB } from '@matrixai/db';
+import type { IdentityId, ProviderId } from 'ids/index';
+import type { GestaltAction } from '../../gestalts/types';
+import type GestaltGraph from 'gestalts/GestaltGraph';
+import { UnaryCaller } from '../../RPC/callers';
+import { UnaryHandler } from '../../RPC/handlers';
+import { validateSync } from '../../validation/index';
+import { matchSync } from '../../utils/index';
+import * as validationUtils from '../../validation/utils';
+
+const gestaltsActionsSetByIdentityCaller = new UnaryCaller<
+  RPCRequestParams<{
+    action: GestaltAction;
+    providerId: string;
+    identityId: string;
+  }>,
+  RPCResponseResult
+>();
+
+class GestaltsActionsSetByIdentityHandler extends UnaryHandler<
+  {
+    gestaltGraph: GestaltGraph;
+    db: DB;
+  },
+  RPCRequestParams<{
+    action: GestaltAction;
+    providerId: string;
+    identityId: string;
+  }>,
+  RPCResponseResult
+> {
+  public async handle(
+    input: RPCRequestParams<{
+      action: GestaltAction;
+      providerId: string;
+      identityId: string;
+    }>,
+  ): Promise<RPCResponseResult> {
+    const { db, gestaltGraph } = this.container;
+    const {
+      action,
+      providerId,
+      identityId,
+    }: {
+      action: GestaltAction;
+      providerId: ProviderId;
+      identityId: IdentityId;
+    } = validateSync(
+      (keyPath, value) => {
+        return matchSync(keyPath)(
+          [['action'], () => validationUtils.parseGestaltAction(value)],
+          [['providerId'], () => validationUtils.parseProviderId(value)],
+          [['identityId'], () => validationUtils.parseIdentityId(value)],
+          () => value,
+        );
+      },
+      {
+        action: input.action,
+        providerId: input.providerId,
+        identityId: input.identityId,
+      },
+    );
+    await db.withTransactionF((tran) =>
+      gestaltGraph.setGestaltAction(
+        ['identity', [providerId, identityId]],
+        action,
+        tran,
+      ),
+    );
+    return {};
+  }
+}
+
+export {
+  gestaltsActionsSetByIdentityCaller,
+  GestaltsActionsSetByIdentityHandler,
+};
diff --git a/src/clientRPC/handlers/gestaltsActionsSetByNode.ts b/src/clientRPC/handlers/gestaltsActionsSetByNode.ts
@@ -0,0 +1,59 @@
+import type { RPCRequestParams, RPCResponseResult } from '../types';
+import type { DB } from '@matrixai/db';
+import type { GestaltAction } from '../../gestalts/types';
+import type GestaltGraph from 'gestalts/GestaltGraph';
+import type { NodeId } from 'ids/index';
+import { UnaryCaller } from '../../RPC/callers';
+import { UnaryHandler } from '../../RPC/handlers';
+import { validateSync } from '../../validation/index';
+import { matchSync } from '../../utils/index';
+import * as validationUtils from '../../validation/utils';
+
+const gestaltsActionsSetByNodeCaller = new UnaryCaller<
+  RPCRequestParams<{
+    action: GestaltAction;
+    nodeIdEncoded: string;
+  }>,
+  RPCResponseResult
+>();
+
+class GestaltsActionsSetByNodeHandler extends UnaryHandler<
+  {
+    gestaltGraph: GestaltGraph;
+    db: DB;
+  },
+  RPCRequestParams<{
+    action: GestaltAction;
+    nodeIdEncoded: string;
+  }>,
+  RPCResponseResult
+> {
+  public async handle(
+    input: RPCRequestParams<{
+      action: GestaltAction;
+      nodeIdEncoded: string;
+    }>,
+  ): Promise<RPCResponseResult> {
+    const { db, gestaltGraph } = this.container;
+    const { nodeId, action }: { nodeId: NodeId; action: GestaltAction } =
+      validateSync(
+        (keyPath, value) => {
+          return matchSync(keyPath)(
+            [['nodeId'], () => validationUtils.parseNodeId(value)],
+            [['action'], () => validationUtils.parseGestaltAction(value)],
+            () => value,
+          );
+        },
+        {
+          nodeId: input.nodeIdEncoded,
+          action: input.action,
+        },
+      );
+    await db.withTransactionF((tran) =>
+      gestaltGraph.setGestaltAction(['node', nodeId], action, tran),
+    );
+    return {};
+  }
+}
+
+export { gestaltsActionsSetByNodeCaller, GestaltsActionsSetByNodeHandler };