@powerhousedao/reactor-api 1.2.0

package/dist/schema-2TGHGOBQ.graphql

@@ -0,0 +1,18 @@
+type Query {
+  drives: [String!]!
+  driveIdBySlug(slug: String!): String
+}
+
+type Mutation {
+  addDrive(global: DocumentDriveStateInput!): DocumentDriveState
+  deleteDrive(id: ID!): Boolean
+  setDriveIcon(id: String!, icon: String!): Boolean
+  setDriveName(id: String!, name: String!): Boolean
+}
+
+input DocumentDriveStateInput {
+  name: String
+  id: String
+  slug: String
+  icon: String
+}

package/dist/schema-GBN2TKQG.graphql

@@ -0,0 +1,142 @@
+type Query {
+  system: System
+  drive: DocumentDriveState
+  document(id: ID!): IDocument
+  documents: [String!]!
+}
+
+type Mutation {
+  registerPullResponderListener(filter: InputListenerFilter!): Listener
+  pushUpdates(strands: [InputStrandUpdate!]): [ListenerRevision!]!
+  acknowledge(listenerId: String!, revisions: [ListenerRevisionInput]): Boolean
+}
+
+input InputOperationSignerUser {
+  address: String!
+  networkId: String!
+  chainId: Int!
+}
+
+type OperationSignerUser {
+  address: String!
+  networkId: String!
+  chainId: Int!
+}
+
+input InputOperationSignerApp {
+  name: String!
+  key: String!
+}
+
+type OperationSignerApp {
+  name: String!
+  key: String!
+}
+
+input InputListenerFilter {
+  documentType: [String!]
+  documentId: [String!]
+  scope: [String!]
+  branch: [String!]
+}
+
+type OperationSigner {
+  app: OperationSignerApp
+  user: OperationSignerUser
+  signatures: [String!]!
+}
+
+input InputOperationSigner {
+  app: InputOperationSignerApp
+  user: InputOperationSignerUser
+  signatures: [String!]!
+}
+
+type OperationContext {
+  signer: OperationSigner
+}
+
+input InputOperationContext {
+  signer: InputOperationSigner
+}
+
+input InputOperationUpdate {
+  index: Int!
+  skip: Int
+  type: String!
+  id: String!
+  input: String!
+  hash: String!
+  timestamp: String!
+  error: String
+  context: InputOperationContext
+}
+
+type OperationUpdate {
+  index: Int!
+  skip: Int
+  type: String!
+  id: String!
+  input: String!
+  hash: String!
+  timestamp: String!
+  error: String
+  context: OperationContext
+}
+
+type StrandUpdate {
+  driveId: String!
+  documentId: String!
+  scope: String!
+  branch: String!
+  operations: [OperationUpdate!]!
+}
+
+input InputStrandUpdate {
+  driveId: String!
+  documentId: String!
+  scope: String!
+  branch: String!
+  operations: [InputOperationUpdate!]!
+}
+
+input ListenerFilterInput {
+  documentType: [String!]
+  documentId: [String!]
+  scope: [String!]
+  branch: [String!]
+}
+
+enum UpdateStatus {
+  SUCCESS
+  MISSING
+  CONFLICT
+  ERROR
+}
+
+input ListenerRevisionInput {
+  driveId: String!
+  documentId: String!
+  scope: String!
+  branch: String!
+  status: UpdateStatus!
+  revision: Int!
+}
+
+type ListenerRevision {
+  driveId: String!
+  documentId: String!
+  scope: String!
+  branch: String!
+  status: UpdateStatus!
+  revision: Int!
+  error: String
+}
+
+type System {
+  sync: Sync
+}
+
+type Sync {
+  strands(listenerId: ID!, since: String): [StrandUpdate!]!
+}

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@powerhousedao/reactor-api",
+  "version": "1.2.0",
+  "description": "",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "type": "module",
+  "sideEffects": false,
+  "publishConfig": {
+    "access": "public"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "AGPL-3.0-only",
+  "devDependencies": {
+    "@types/body-parser": "^1.19.5",
+    "@types/cors": "^2.8.17",
+    "@types/express": "^5.0.0",
+    "document-drive": "1.2.0",
+    "esbuild": "^0.24.0",
+    "graphql": "^16.9.0",
+    "graphql-tag": "^2.12.6",
+    "tsup": "^8.3.0",
+    "document-model": "2.3.1"
+  },
+  "peerDependencies": {
+    "document-drive": "^1.0.1",
+    "document-model": "^2.2.0"
+  },
+  "dependencies": {
+    "@apollo/server": "^4.11.0",
+    "@apollo/subgraph": "^2.9.2",
+    "body-parser": "^1.20.3",
+    "cors": "^2.8.5",
+    "document-model-libs": "1.93.2",
+    "express": "^4.21.1"
+  },
+  "scripts": {
+    "build": "tsup",
+    "test": "vitest"
+  }
+}

package/src/index.ts

@@ -0,0 +1,3 @@
+export * from "./server";
+export * from "./router";
+export * from "./utils/create-schema";

package/src/internal-listener-manager.ts

@@ -0,0 +1,111 @@
+import {
+  BaseDocumentDriveServer,
+  InternalTransmitter,
+  InternalTransmitterUpdate,
+  Listener,
+} from "document-drive";
+import { DocumentDriveDocument } from "document-model-libs/document-drive";
+
+export type InternalListenerModule = {
+  name: string;
+  options: Omit<Listener, "driveId">;
+  transmit: (strands: InternalTransmitterUpdate[]) => Promise<void>;
+};
+
+export class InternalListenerManager {
+  private driveServer: BaseDocumentDriveServer;
+  private modules: InternalListenerModule[] = [];
+
+  constructor(driveServer: BaseDocumentDriveServer) {
+    this.driveServer = driveServer;
+    driveServer.on("driveAdded", this.#onDriveAdded.bind(this));
+  }
+
+  async #onDriveAdded(drive: DocumentDriveDocument) {
+    await Promise.all(
+      this.modules.map((module) =>
+        this.driveServer.addInternalListener(
+          drive.state.global.id,
+          {
+            transmit: (strands) => module.transmit(strands),
+            disconnect: async () => {
+              return Promise.resolve();
+            },
+          },
+          { ...module.options, label: module.options.label ?? "" }
+        )
+      )
+    );
+  }
+
+  async init() {
+    const drives = await this.driveServer.getDrives();
+
+    // eslint-disable-next-line no-restricted-syntax
+    for (const { options, transmit } of this.modules) {
+      console.log(options, transmit);
+      if (!options || !transmit) {
+        continue;
+      }
+
+      // eslint-disable-next-line no-restricted-syntax
+      for (const driveId of drives) {
+        try {
+          const { listenerId } = options;
+          const drive = await this.driveServer.getDrive(driveId);
+          const moduleRegistered =
+            drive.state.local.listeners.filter(
+              (l) => l.listenerId === listenerId
+            ).length > 0;
+          if (!moduleRegistered) {
+            await this.driveServer.addInternalListener(
+              driveId,
+              {
+                transmit: async (strands) => transmit(strands),
+                disconnect: async () => Promise.resolve(),
+              },
+              {
+                block: false,
+                filter: options.filter,
+                label: options.label!,
+                listenerId,
+              }
+            );
+
+            return;
+          }
+
+          const transmitter = await this.driveServer.getTransmitter(
+            driveId,
+            listenerId
+          );
+          if (transmitter instanceof InternalTransmitter) {
+            transmitter.setReceiver({
+              transmit: async (strands: InternalTransmitterUpdate[]) => {
+                await transmit(strands);
+                return Promise.resolve();
+              },
+              disconnect: () => {
+                console.log(`Disconnecting listener ${options.listenerId}`);
+                return Promise.resolve();
+              },
+            });
+          }
+        } catch (e) {
+          console.error(
+            `Error while initializing listener ${options.listenerId} for drive ${driveId}`,
+            e
+          );
+        }
+      }
+    }
+  }
+
+  async registerInternalListener(module: InternalListenerModule) {
+    if (this.modules.find((m) => m.name === module.name)) {
+      return;
+    }
+    this.modules.push(module);
+    await this.init();
+  }
+}

package/src/router.ts

@@ -0,0 +1,122 @@
+import { ApolloServer } from "@apollo/server";
+import { expressMiddleware } from "@apollo/server/express4";
+import { ApolloServerPluginInlineTraceDisabled } from "@apollo/server/plugin/disabled";
+import bodyParser from "body-parser";
+import cors from "cors";
+import { BaseDocumentDriveServer } from "document-drive";
+import express, { IRouter, Router } from "express";
+import {
+  InternalListenerManager,
+  InternalListenerModule,
+} from "./internal-listener-manager";
+import { SUBGRAPH_REGISTRY } from "./subgraphs";
+import { Context } from "./types";
+export let reactorRouter: IRouter = Router();
+
+const getLocalSubgraphConfig = (subgraphName: string) =>
+  SUBGRAPH_REGISTRY.find((it) => it.name === subgraphName);
+
+let listenerManager: InternalListenerManager | undefined;
+
+export const getListenerManager = async (
+  driveServer: BaseDocumentDriveServer
+) => {
+  if (!listenerManager) {
+    listenerManager = new InternalListenerManager(driveServer);
+    await listenerManager.init();
+  }
+  return listenerManager;
+};
+
+export const updateRouter = async (driveServer: BaseDocumentDriveServer) => {
+  const newRouter = Router();
+  newRouter.use(cors());
+  newRouter.use(bodyParser.json());
+  // Run each subgraph on the same http server, but at different paths
+  for (const subgraph of SUBGRAPH_REGISTRY) {
+    const subgraphConfig = getLocalSubgraphConfig(subgraph.name);
+    if (!subgraphConfig) continue;
+
+    // get schema
+    const schema = subgraphConfig.getSchema(driveServer);
+
+    // create apollo server
+    const server = new ApolloServer({
+      schema,
+      introspection: true,
+      plugins: [ApolloServerPluginInlineTraceDisabled()],
+    });
+
+    // start apollo server
+    await server.start();
+
+    // setup path
+    const path = `/${subgraphConfig.name}`;
+    newRouter.use(
+      path,
+      expressMiddleware(server, {
+        context: ({ req }): Promise<Context> =>
+          Promise.resolve({
+            headers: req.headers,
+            driveId: req.params.drive ?? undefined,
+            driveServer,
+            ...getAdditionalContextFields(),
+          }),
+      })
+    );
+    console.log(`Setting up [${subgraphConfig.name}] subgraph at ${path}`);
+  }
+
+  listenerManager = await getListenerManager(driveServer);
+  reactorRouter = newRouter;
+  console.log("All subgraphs started.");
+};
+
+let docDriveServer: BaseDocumentDriveServer;
+export const initReactorRouter = async (
+  path: string,
+  app: express.Express,
+  driveServer: BaseDocumentDriveServer
+) => {
+  docDriveServer = driveServer;
+  const models = driveServer.getDocumentModels();
+  const driveModel = models.find(
+    (it) => it.documentModel.name === "DocumentDrive"
+  );
+
+  if (!driveModel) {
+    throw new Error("DocumentDrive model required");
+  }
+
+  await updateRouter(driveServer);
+  driveServer.on("documentModels", () => {
+    updateRouter(driveServer);
+  });
+
+  app.use(path, (req, res, next) => reactorRouter(req, res, next));
+};
+
+export const addSubgraph = async (
+  subgraph: (typeof SUBGRAPH_REGISTRY)[number]
+) => {
+  SUBGRAPH_REGISTRY.unshift(subgraph);
+  await updateRouter(docDriveServer);
+};
+
+export const registerInternalListener = async (
+  module: InternalListenerModule
+) => {
+  if (!listenerManager) {
+    throw new Error("Listener manager not initialized");
+  }
+  await listenerManager.registerInternalListener(module);
+};
+
+let contextFields = {};
+export const getAdditionalContextFields = () => {
+  return contextFields;
+};
+
+export const setAdditionalContextFields = (fields: Record<string, any>) => {
+  contextFields = { ...contextFields, ...fields };
+};

package/src/server.ts

@@ -0,0 +1,21 @@
+import { BaseDocumentDriveServer } from "document-drive";
+import express, { Express } from "express";
+import { initReactorRouter } from "./router";
+type Options = {
+  express?: Express;
+  port?: number;
+};
+
+const DEFAULT_PORT = 4000;
+
+export async function startAPI(
+  reactor: BaseDocumentDriveServer,
+  options: Options
+) {
+  const port = options.port ?? DEFAULT_PORT;
+  const app = options.express ?? express();
+
+  await initReactorRouter("/", app, reactor);
+
+  app.listen(port);
+}

package/src/subgraphs/drive/resolvers.ts

@@ -0,0 +1,223 @@
+import {
+  generateUUID,
+  ListenerRevision,
+  PullResponderTransmitter,
+  StrandUpdateGraphQL,
+} from "document-drive";
+import {
+  actions,
+  DocumentDriveAction,
+  Listener,
+  ListenerFilter,
+  TransmitterType,
+} from "document-model-libs/document-drive";
+import { BaseAction, Operation } from "document-model/document";
+import {
+  DocumentModelInput,
+  DocumentModelState,
+} from "document-model/document-model";
+import { Context } from "../../../../../../apps/switchboard/types";
+
+export const resolvers = {
+  Query: {
+    drive: async (_: unknown, args: unknown, ctx: Context) => {
+      if (!ctx.driveId) throw new Error("Drive ID is required");
+      const drive = await ctx.driveServer.getDrive(ctx.driveId);
+      return drive.state.global;
+    },
+    documents: async (_: unknown, args: unknown, ctx: Context) => {
+      if (!ctx.driveId) throw new Error("Drive ID is required");
+      const documents = await ctx.driveServer.getDocuments(ctx.driveId);
+      return documents;
+    },
+    document: async (_: unknown, { id }: { id: string }, ctx: Context) => {
+      if (!ctx.driveId) throw new Error("Drive ID is required");
+      const document = await ctx.driveServer.getDocument(ctx.driveId, id);
+
+      const dms = ctx.driveServer.getDocumentModels();
+      const dm = dms.find(
+        ({ documentModel }: { documentModel: DocumentModelState }) =>
+          documentModel.id === document.documentType
+      );
+      const globalState = document.state.global;
+      if (!globalState) throw new Error("Document not found");
+      const response = {
+        ...document,
+        id,
+        revision: document.revision.global,
+        state: document.state.global,
+        operations: document.operations.global.map((op: Operation) => ({
+          ...op,
+          inputText:
+            typeof op.input === "string" ? op.input : JSON.stringify(op.input),
+        })),
+        initialState: document.initialState.state.global,
+        __typename: dm?.documentModel.name,
+      };
+      console.log(response);
+      return response;
+    },
+    system: () => ({ sync: {} }),
+  },
+  Mutation: {
+    registerPullResponderListener: async (
+      _: unknown,
+      { filter }: { filter: ListenerFilter },
+      ctx: Context
+    ) => {
+      if (!ctx.driveId) throw new Error("Drive ID is required");
+      const uuid = generateUUID();
+      const listener: Listener = {
+        block: false,
+        callInfo: {
+          data: "",
+          name: "PullResponder",
+          transmitterType: "PullResponder" as TransmitterType,
+        },
+        filter: {
+          branch: filter.branch ?? [],
+          documentId: filter.documentId ?? [],
+          documentType: filter.documentType ?? [],
+          scope: filter.scope ?? [],
+        },
+        label: `Pullresponder #${uuid}`,
+        listenerId: uuid,
+        system: false,
+      };
+
+      const result = await ctx.driveServer.queueDriveAction(
+        ctx.driveId,
+        actions.addListener({ listener })
+      );
+
+      console.log(result);
+      if (result.status !== "SUCCESS" && result.error) {
+        throw new Error(
+          `Listener couldn't be registered: ${result.error.message}`
+        );
+      }
+
+      return listener;
+    },
+    pushUpdates: async (
+      _: unknown,
+      { strands }: { 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
+            ? ctx.driveServer.queueOperations(
+                s.driveId,
+                s.documentId,
+                operations
+              )
+            : ctx.driveServer.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,
+            };
+          }
+
+          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 listenerRevisions;
+    },
+    acknowledge: async (
+      _: unknown,
+      {
+        listenerId,
+        revisions,
+      }: { listenerId: string; revisions: ListenerRevision[] },
+      ctx: Context
+    ) => {
+      if (!listenerId || !revisions) return false;
+      if (!ctx.driveId) throw new Error("Drive ID is required");
+      const validEntries = revisions
+        .filter((r) => r !== null)
+        .map((e) => ({
+          driveId: e.driveId,
+          documentId: e.documentId,
+          scope: e.scope,
+          branch: e.branch,
+          revision: e.revision,
+          status: e.status,
+        }));
+
+      const transmitter = (await ctx.driveServer.getTransmitter(
+        ctx.driveId,
+        listenerId
+      )) as PullResponderTransmitter;
+      const result = await transmitter.processAcknowledge(
+        ctx.driveId ?? "1",
+        listenerId,
+        validEntries
+      );
+
+      return result;
+    },
+  },
+  System: {},
+  Sync: {
+    strands: async (
+      _: unknown,
+      { listenerId, since }: { listenerId: string; since: string | undefined },
+      ctx: Context
+    ) => {
+      if (!ctx.driveId) throw new Error("Drive ID is required");
+      const listener = (await ctx.driveServer.getTransmitter(
+        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,
+        })),
+      }));
+    },
+  },
+};