@powerhousedao/reactor-api 1.20.2 → 1.21.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@powerhousedao/reactor-api",
-  "version": "1.20.2",
+  "version": "1.21.0",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -14,6 +14,7 @@
   "license": "AGPL-3.0-only",
   "devDependencies": {
     "@powerhousedao/analytics-engine-graphql": "^0.2.2",
+    "@sky-ph/atlas": "^1.0.14",
     "@types/body-parser": "^1.19.5",
     "@types/cors": "^2.8.17",
     "@types/express": "^5.0.0",
@@ -23,9 +24,10 @@
     "@types/pg": "^8.11.10",
     "esbuild": "^0.24.0",
     "graphql-tag": "^2.12.6",
-    "@powerhousedao/scalars": "1.22.0",
-    "document-drive": "1.17.2",
-    "document-model": "2.19.0"
+    "tinybench": "^3.1.1",
+    "@powerhousedao/scalars": "1.23.0",
+    "document-drive": "1.18.0",
+    "document-model": "2.20.0"
   },
   "dependencies": {
     "@apollo/server": "^4.11.0",
@@ -52,11 +54,12 @@
     "uuid": "^9.0.1",
     "wildcard-match": "^5.1.3",
     "zod": "^3.24.1",
-    "document-model-libs": "1.131.2"
+    "document-model-libs": "1.132.0"
   },
   "scripts": {
     "build": "tsup",
     "test": "vitest run",
-    "lint": "eslint"
+    "lint": "eslint",
+    "bench": "vitest bench"
   }
 }

package/src/subgraphs/drive/index.ts

@@ -3,23 +3,27 @@ import { pascalCase } from "change-case";
 import {
   generateUUID,
   ListenerRevision,
-  PullResponderTransmitter,
   StrandUpdateGraphQL,
 } from "document-drive";
 import {
   actions,
-  DocumentDriveAction,
   FileNode,
   Listener,
   ListenerFilter,
   TransmitterType,
 } from "document-model-libs/document-drive";
-import { BaseAction, Document, Operation } from "document-model/document";
+import { Document, Operation } from "document-model/document";
 import {
   DocumentModelInput,
   DocumentModelState,
 } from "document-model/document-model";
 import { gql } from "graphql-tag";
+import {
+  InternalStrandUpdate,
+  processAcknowledge,
+  processGetStrands,
+  processPushUpdate,
+} from "src/sync/utils";
 import { Subgraph } from "../base";
 import { Context } from "../types";
 import { Asset } from "./temp-hack-rwa-type-defs";
@@ -276,58 +280,32 @@ export class DriveSubgraph extends Subgraph {
       },
       pushUpdates: async (
         _: unknown,
-        { strands }: { strands: StrandUpdateGraphQL[] },
+        { strands: strandsGql }: { strands: StrandUpdateGraphQL[] },
         ctx: Context,
       ) => {
         if (!ctx.driveId) throw new Error("Drive ID is required");
-        const listenerRevisions: ListenerRevision[] = await Promise.all(
-          strands.map(async (s) => {
-            const operations =
-              s.operations.map((o) => ({
-                ...o,
-                input: JSON.parse(o.input) as DocumentModelInput,
-                skip: o.skip ?? 0,
-                scope: s.scope,
-                branch: "main",
-              })) ?? [];
-
-            const result = await (s.documentId !== undefined
-              ? this.reactor.queueOperations(
-                  s.driveId,
-                  s.documentId,
-                  operations,
-                )
-              : this.reactor.queueDriveOperations(
-                  s.driveId,
-                  operations as Operation<DocumentDriveAction | BaseAction>[],
-                ));
 
-            const scopeOperations = result.document?.operations[s.scope] ?? [];
-            if (scopeOperations.length === 0) {
-              return {
-                revision: -1,
-                branch: s.branch,
-                documentId: s.documentId ?? "",
-                driveId: s.driveId,
-                scope: s.scope,
-                status: result.status,
-              };
-            }
+        // translate data types
+        const strands: InternalStrandUpdate[] = strandsGql.map((strandGql) => {
+          return {
+            operations: strandGql.operations.map((op) => ({
+              ...op,
+              input: JSON.parse(op.input) as DocumentModelInput,
+              skip: op.skip ?? 0,
+              scope: strandGql.scope,
+              branch: "main",
+            })) as Operation[],
+            documentId: strandGql.documentId,
+            driveId: strandGql.driveId,
+            scope: strandGql.scope,
+            branch: strandGql.branch,
+          };
+        });
 
-            const revision = scopeOperations.slice().pop()?.index ?? -1;
-            return {
-              revision,
-              branch: s.branch,
-              documentId: s.documentId ?? "",
-              driveId: s.driveId,
-              scope: s.scope,
-              status: result.status,
-              error: result.error?.message || undefined,
-            };
-          }),
+        // return a list of listener revisions
+        return await Promise.all(
+          strands.map((strand) => processPushUpdate(this.reactor, strand)),
         );
-
-        return listenerRevisions;
       },
       acknowledge: async (
         _: unknown,
@@ -339,6 +317,8 @@ export class DriveSubgraph extends Subgraph {
       ) => {
         if (!listenerId || !revisions) return false;
         if (!ctx.driveId) throw new Error("Drive ID is required");
+
+        // translate data types
         const validEntries = revisions
           .filter((r) => r !== null)
           .map((e) => ({
@@ -350,17 +330,13 @@ export class DriveSubgraph extends Subgraph {
             status: e.status,
           }));
 
-        const transmitter = (await this.reactor.getTransmitter(
+        // return a boolean indicating if the acknowledge was successful
+        return await processAcknowledge(
+          this.reactor,
           ctx.driveId,
           listenerId,
-        )) as PullResponderTransmitter;
-        const result = await transmitter.processAcknowledge(
-          ctx.driveId ?? "1",
-          listenerId,
           validEntries,
         );
-
-        return result;
       },
     },
     System: {},
@@ -374,26 +350,31 @@ export class DriveSubgraph extends Subgraph {
         ctx: Context,
       ) => {
         if (!ctx.driveId) throw new Error("Drive ID is required");
-        const listener = (await this.reactor.getTransmitter(
+
+        // get the requested strand updates
+        const strands = await processGetStrands(
+          this.reactor,
           ctx.driveId,
           listenerId,
-        )) as PullResponderTransmitter;
-        const strands = await listener.getStrands({ since });
-        return strands.map((e) => ({
-          driveId: e.driveId,
-          documentId: e.documentId,
-          scope: e.scope,
-          branch: e.branch,
-          operations: e.operations.map((o) => ({
-            index: o.index,
-            skip: o.skip,
-            name: o.type,
-            input: JSON.stringify(o.input),
-            hash: o.hash,
-            timestamp: o.timestamp,
-            type: o.type,
-            context: o.context,
-            id: o.id,
+          since,
+        );
+
+        // translate data types
+        return strands.map((update) => ({
+          driveId: update.driveId,
+          documentId: update.documentId,
+          scope: update.scope,
+          branch: update.branch,
+          operations: update.operations.map((op) => ({
+            index: op.index,
+            skip: op.skip,
+            name: op.type,
+            input: JSON.stringify(op.input),
+            hash: op.hash,
+            timestamp: op.timestamp,
+            type: op.type,
+            context: op.context,
+            id: op.id,
           })),
         }));
       },

package/src/sync/utils.ts

@@ -0,0 +1,85 @@
+import {
+  IDocumentDriveServer,
+  ListenerRevision,
+  PullResponderTransmitter,
+  StrandUpdate,
+} from "document-drive";
+import { DocumentDriveAction } from "document-model-libs/document-drive";
+import { BaseAction, Operation, OperationScope } from "document-model/document";
+
+// define types
+export type InternalStrandUpdate = {
+  operations: Operation[];
+  documentId: string;
+  driveId: string;
+  scope: OperationScope;
+  branch: string;
+};
+
+// processes a strand update and returns a listener revision
+export const processPushUpdate = async (
+  reactor: IDocumentDriveServer,
+  strand: InternalStrandUpdate
+): Promise<ListenerRevision> => {
+  const result = await (strand.documentId !== undefined
+    ? reactor.queueOperations(
+        strand.driveId,
+        strand.documentId,
+        strand.operations
+      )
+    : reactor.queueDriveOperations(
+        strand.driveId,
+        strand.operations as Operation<DocumentDriveAction | BaseAction>[]
+      ));
+
+  const scopeOperations = result.document?.operations[strand.scope] ?? [];
+  if (scopeOperations.length === 0) {
+    return {
+      revision: -1,
+      branch: strand.branch,
+      documentId: strand.documentId ?? "",
+      driveId: strand.driveId,
+      scope: strand.scope,
+      status: result.status,
+    };
+  }
+
+  const revision = scopeOperations.slice().pop()?.index ?? -1;
+  return {
+    revision,
+    branch: strand.branch,
+    documentId: strand.documentId ?? "",
+    driveId: strand.driveId,
+    scope: strand.scope,
+    status: result.status,
+    error: result.error?.message || undefined,
+  };
+};
+
+// processes an acknowledge request and returns a boolean
+export const processAcknowledge = async (
+  reactor: IDocumentDriveServer,
+  driveId: string,
+  listenerId: string,
+  revisions: ListenerRevision[]
+): Promise<boolean> => {
+  const transmitter = (await reactor.getTransmitter(
+    driveId,
+    listenerId
+  )) as PullResponderTransmitter;
+  return transmitter.processAcknowledge(driveId, listenerId, revisions);
+};
+
+// processes a get strands request and returns a list of strand updates
+export const processGetStrands = async (
+  reactor: IDocumentDriveServer,
+  driveId: string,
+  listenerId: string,
+  since: string | undefined
+): Promise<StrandUpdate[]> => {
+  const transmitter = (await reactor.getTransmitter(
+    driveId,
+    listenerId
+  )) as PullResponderTransmitter;
+  return transmitter.getStrands({ since });
+};

package/test/benchmarks/load.bench.ts

@@ -0,0 +1,78 @@
+import { RealWorldAssets } from "@sky-ph/atlas/document-models";
+import { DocumentDriveServer, generateUUID } from "document-drive";
+import { MemoryStorage } from "document-drive/storage/memory";
+import {
+  module as DocumentDrive,
+  generateAddNodeAction,
+} from "document-model-libs/document-drive";
+import { DocumentModel } from "document-model/document";
+
+import { bench, describe } from "vitest";
+
+describe("Document Drive", async () => {
+  const documentModels = [DocumentDrive, RealWorldAssets] as DocumentModel[];
+  const document = await RealWorldAssets.utils.loadFromFile(
+    "test/data/BlocktowerAndromeda.zip",
+  );
+
+  bench(
+    "Load PHDM into Document Drive",
+    async () => {
+      const server = new DocumentDriveServer(
+        documentModels,
+        new MemoryStorage(),
+      );
+      await server.initialize();
+
+      const driveId = generateUUID();
+      const documentId = generateUUID();
+
+      const drive = await server.addDrive({
+        global: {
+          id: driveId,
+          name: "Test Drive",
+          icon: null,
+          slug: null,
+        },
+        local: {
+          availableOffline: false,
+          sharingType: "PRIVATE",
+          listeners: [],
+          triggers: [],
+        },
+      });
+
+      // adds file node for document
+      const addFileAction = generateAddNodeAction(
+        drive.state.global,
+        {
+          documentType: document.documentType,
+          id: documentId,
+          name: "BlocktowerAndromeda",
+        },
+        ["global"],
+      );
+      await server.addDriveAction(driveId, addFileAction);
+
+      // adds document operations
+      const result = await server.addOperations(
+        driveId,
+        documentId,
+        document.operations.global,
+      );
+
+      if (result.error) {
+        throw result.error;
+      }
+
+      const lastOperation = document.operations.global.at(-1);
+      const lastLoadedOperation = result.operations.at(-1);
+      if (
+        JSON.stringify(lastOperation) !== JSON.stringify(lastLoadedOperation)
+      ) {
+        throw new Error("Document operations  mismatch");
+      }
+    },
+    { throws: true },
+  );
+});

package/test/benchmarks/sync.bench.ts

@@ -0,0 +1,151 @@
+import { RealWorldAssets } from "@sky-ph/atlas/document-models";
+import {
+  DocumentDriveServer,
+  generateUUID,
+  InternalTransmitterUpdate,
+  IReceiver,
+} from "document-drive";
+import { MemoryStorage } from "document-drive/storage/memory";
+import {
+  module as DocumentDrive,
+  generateAddNodeAction,
+  ListenerFilter,
+} from "document-model-libs/document-drive";
+import {
+  Document,
+  DocumentModel,
+  OperationScope,
+} from "document-model/document";
+
+import { beforeAll, bench, describe } from "vitest";
+
+class TestReceiver<
+  T extends Document = Document,
+  S extends OperationScope = OperationScope,
+> implements IReceiver<T, S>
+{
+  async onStrands(strands: InternalTransmitterUpdate<T, S>[]) {
+    return Promise.resolve();
+  }
+
+  async onDisconnect() {
+    return Promise.resolve();
+  }
+}
+
+beforeAll(async () => {});
+
+describe("Document Drive", async () => {
+  const documentModels = Object.values([
+    DocumentDrive,
+    RealWorldAssets,
+  ]) as DocumentModel[];
+  const document = await RealWorldAssets.utils.loadFromFile(
+    "test/data/BlocktowerAndromeda.zip",
+  );
+
+  bench(
+    "Load PHDM into Document Drive",
+    async () => {
+      const serverA = new DocumentDriveServer(
+        documentModels,
+        new MemoryStorage(),
+      );
+      await serverA.initialize();
+
+      const serverB = new DocumentDriveServer(
+        documentModels,
+        new MemoryStorage(),
+      );
+      await serverB.initialize();
+
+      const driveAId = generateUUID();
+      const documentId = generateUUID();
+
+      const driveA = await serverA.addDrive({
+        global: {
+          id: driveAId,
+          name: "Test Drive",
+          icon: null,
+          slug: null,
+        },
+        local: {
+          availableOffline: false,
+          sharingType: "PRIVATE",
+          listeners: [],
+          triggers: [],
+        },
+      });
+
+      const driveBId = generateUUID();
+      const driveB = await serverB.addDrive({
+        global: {
+          id: driveBId,
+          name: "Test Drive",
+          icon: null,
+          slug: null,
+        },
+        local: {
+          availableOffline: false,
+          sharingType: "PRIVATE",
+          listeners: [],
+          triggers: [],
+        },
+      });
+
+      // listener!
+      const filter: ListenerFilter = {
+        branch: ["*"],
+        documentId: ["*"],
+        documentType: ["*"],
+        scope: ["*"],
+      };
+
+      const receiver = new TestReceiver();
+      await serverA.addInternalListener(driveAId, receiver, {
+        listenerId: generateUUID(),
+        label: "Test Listener",
+        block: false,
+        filter,
+      });
+
+      await serverB.addInternalListener(driveBId, receiver, {
+        listenerId: generateUUID(),
+        label: "Test Listener",
+        block: false,
+        filter,
+      });
+
+      // loads document in drive A
+      const addFileAction = generateAddNodeAction(
+        driveA.state.global,
+        {
+          documentType: document.documentType,
+          id: documentId,
+          name: "BlocktowerAndromeda",
+        },
+        ["global"],
+      );
+      await serverA.addDriveAction(driveAId, addFileAction);
+
+      const result = await serverA.addOperations(
+        driveAId,
+        documentId,
+        document.operations.global,
+      );
+
+      if (result.error) {
+        throw result.error;
+      }
+
+      const lastOperation = document.operations.global.at(-1);
+      const lastLoadedOperation = result.operations.at(-1);
+      if (
+        JSON.stringify(lastOperation) !== JSON.stringify(lastLoadedOperation)
+      ) {
+        throw new Error("Document operations  mismatch");
+      }
+    },
+    { throws: true },
+  );
+});