@powerhousedao/reactor-api 1.2.0

package/src/subgraphs/drive/schema.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/src/subgraphs/drive/subgraph.ts

@@ -0,0 +1,16 @@
+import { GraphQLResolverMap } from "@apollo/subgraph/dist/schema-helper";
+import { BaseDocumentDriveServer } from "document-drive";
+import { readFileSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { createSchema } from "src/utils/create-schema";
+import { resolvers } from "./resolvers";
+import schemaPath from "./schema.graphql";
+
+const __dirname =
+  import.meta.dirname ?? dirname(fileURLToPath(import.meta.url));
+
+const typeDefs = readFileSync(resolve(__dirname, schemaPath), "utf8");
+
+export const getSchema = (driveServer: BaseDocumentDriveServer) =>
+  createSchema(driveServer, resolvers as GraphQLResolverMap, typeDefs);

package/src/subgraphs/index.ts

@@ -0,0 +1,13 @@
+import { getSchema as getSystemSchema } from "./system/subgraph";
+import { getSchema as getDriveSchema } from "./drive/subgraph";
+
+export const SUBGRAPH_REGISTRY = [
+  {
+    name: "system",
+    getSchema: getSystemSchema,
+  },
+  {
+    name: "d/:drive",
+    getSchema: getDriveSchema,
+  },
+];

package/src/subgraphs/system/resolvers.ts

@@ -0,0 +1,22 @@
+import { DriveInput } from "document-drive";
+import { Context } from "../../../../../../apps/switchboard/types";
+
+export const resolvers = {
+  Query: {
+    drives: async (parent: unknown, args: unknown, ctx: Context) => {
+      const drives = await ctx.driveServer.getDrives();
+      return drives;
+    },
+  },
+  Mutation: {
+    addDrive: async (parent: unknown, args: DriveInput, ctx: Context) => {
+      try {
+        const drive = await ctx.driveServer.addDrive(args);
+        return drive.state.global;
+      } catch (e) {
+        console.error(e);
+        throw new Error(e as string);
+      }
+    },
+  },
+};

package/src/subgraphs/system/schema.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/src/subgraphs/system/subgraph.ts

@@ -0,0 +1,16 @@
+import { GraphQLResolverMap } from "@apollo/subgraph/dist/schema-helper";
+import { BaseDocumentDriveServer } from "document-drive";
+import { readFileSync } from "fs";
+import { dirname, resolve } from "path";
+import { fileURLToPath } from "url";
+import { createSchema } from "src/utils/create-schema";
+import { resolvers } from "./resolvers";
+import schemaPath from "./schema.graphql";
+
+const __dirname =
+  import.meta.dirname ?? dirname(fileURLToPath(import.meta.url));
+
+const typeDefs = readFileSync(resolve(__dirname, schemaPath), "utf8");
+
+export const getSchema = (driveServer: BaseDocumentDriveServer) =>
+  createSchema(driveServer, resolvers as GraphQLResolverMap, typeDefs);

package/src/types.ts

@@ -0,0 +1,8 @@
+import { BaseDocumentDriveServer } from "document-drive";
+import { IncomingHttpHeaders } from "http";
+
+export interface Context {
+  headers: IncomingHttpHeaders;
+  driveId: string | undefined;
+  driveServer: BaseDocumentDriveServer;
+}

package/src/utils/create-schema.ts

@@ -0,0 +1,81 @@
+import { buildSubgraphSchema } from "@apollo/subgraph";
+import { BaseDocumentDriveServer } from "document-drive";
+import { readFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { GraphQLResolverMap } from "@apollo/subgraph/dist/schema-helper";
+import { parse } from "graphql";
+
+export const createSchema = (
+  documentDriveServer: BaseDocumentDriveServer,
+  resolvers: GraphQLResolverMap,
+  typeDefs: string
+) =>
+  buildSubgraphSchema([
+    {
+      typeDefs: getDocumentModelTypeDefs(documentDriveServer, typeDefs),
+      resolvers,
+    },
+  ]);
+
+export const getDocumentModelTypeDefs = (
+  documentDriveServer: BaseDocumentDriveServer,
+  typeDefs: string
+) => {
+  const documentModels = documentDriveServer.getDocumentModels();
+  let dmSchema = "";
+  documentModels.forEach(({ documentModel }) => {
+    dmSchema += `
+          ${documentModel.specifications
+            .map((specification) =>
+              specification.state.global.schema
+                .replaceAll(" Account ", ` ${documentModel.name}Account `)
+                .replaceAll(`: Account`, `: ${documentModel.name}Account`)
+                .replaceAll(`[Account!]!`, `[${documentModel.name}Account!]!`)
+                .replaceAll("scalar DateTime", "")
+                .replaceAll(/input (.*?) {[\s\S]*?}/g, "")
+            )
+            .join("\n")};
+  
+          ${documentModel.specifications
+            .map((specification) =>
+              specification.state.local.schema
+                .replaceAll(" Account ", ` ${documentModel.name}Account `)
+                .replaceAll(`: Account`, `: ${documentModel.name}Account`)
+                .replaceAll(`[Account!]!`, `[${documentModel.name}Account!]!`)
+                .replaceAll("scalar DateTime", "")
+                .replaceAll(/input (.*?) {[\s\S]*?}/g, "")
+                .replaceAll("type AccountSnapshotLocalState", "")
+                .replaceAll("type BudgetStatementLocalState", "")
+                .replaceAll("type ScopeFrameworkLocalState", "")
+            )
+            .join("\n")};
+  
+          type ${documentModel.name} implements IDocument {
+              id: ID!
+              name: String!
+              documentType: String!
+              revision: Int!
+              created: DateTime!
+              lastModified: DateTime!
+              ${documentModel.name !== "DocumentModel" ? `state: ${documentModel.name}State!` : ""}
+          }\n`;
+  });
+
+  // add the mutation and query types
+  const schema = `
+      scalar DateTime
+      interface IDocument {
+          name: String!
+          documentType: String!
+          revision: Int!
+          created: DateTime!
+          lastModified: DateTime!
+          
+      }
+      ${dmSchema}
+  
+      ${typeDefs}
+      `;
+
+  return parse(schema.replaceAll(";", ""));
+};

package/test/router.test.ts

@@ -0,0 +1,55 @@
+import { buildSubgraphSchema } from "@apollo/subgraph";
+import * as DocumentModelsLibs from "document-model-libs/document-models";
+import { DocumentModel } from "document-model/document";
+import { module as DocumentModelLib } from "document-model/document-model";
+import { describe, expect, it } from "vitest";
+import {
+  BaseDocumentDriveServer,
+  DocumentDriveServer,
+} from "../../document-drive/src/server";
+import { addSubgraph } from "../src/index";
+import { initReactorRouter, reactorRouter, updateRouter } from "../src/router";
+import { getDocumentModelTypeDefs } from "../src/utils/gen-doc-model-type-defs";
+import express from "express";
+
+const documentModels = [
+  DocumentModelLib,
+  ...Object.values(DocumentModelsLibs),
+] as DocumentModel[];
+
+describe("Reactor Router", () => {
+  it("should be initialized", async () => {
+    const app = express();
+    await initReactorRouter("/", app, new DocumentDriveServer(documentModels));
+    const [system, drive] = reactorRouter.stack;
+    expect(system).toBeDefined();
+    expect(drive).toBeDefined();
+    expect("/system").toMatch(system.regexp);
+    expect("/drive").toMatch(drive.regexp);
+  });
+
+  it("should be able to add a new subgraph", async () => {
+    const driveServer = new DocumentDriveServer(documentModels);
+    await driveServer.initialize();
+    const newSubgraph = {
+      name: "newSubgraph",
+      getSchema: (documentDriveServer: BaseDocumentDriveServer) =>
+        buildSubgraphSchema([
+          {
+            typeDefs: getDocumentModelTypeDefs(
+              documentDriveServer,
+              `
+              type Query {
+                hello: String
+              }
+            `
+            ),
+            resolvers: { Query: { hello: () => "world" } },
+          },
+        ]),
+    };
+
+    await addSubgraph(newSubgraph);
+    expect(reactorRouter.stack.length).gte(3);
+  });
+});

package/tsconfig.json

@@ -0,0 +1,18 @@
+{
+  "compilerOptions": {
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    "target": "esnext",
+    "types": ["node", "./types.d.ts"],
+    "declaration": true,
+    "outDir": "./dist",
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,
+    "strict": true,
+    "noImplicitAny": true,
+    "skipLibCheck": true,
+    "emitDeclarationOnly": true,
+    "baseUrl": "."
+  },
+  "include": ["src/**/*", "*.config.ts"]
+}

package/tsdoc.json

@@ -0,0 +1,3 @@
+{
+    "$schema": "https://developer.microsoft.com/json-schemas/tsdoc/v0/tsdoc.schema.json"
+}

package/tsup.config.ts

@@ -0,0 +1,16 @@
+import { defineConfig } from "tsup";
+
+export default defineConfig({
+  entry: ["src/index.ts"],
+  splitting: true,
+  sourcemap: true,
+  clean: true,
+  format: "esm",
+  treeshake: true,
+  noExternal: ["document-drive"],
+  target: "node20",
+  loader: {
+    ".graphql": "file",
+  },
+  dts: true,
+});

package/types.d.ts

@@ -0,0 +1,5 @@
+declare module "*.graphql" {
+  const value: string;
+
+  export default value;
+}

package/vitest.config.ts

@@ -0,0 +1,28 @@
+import { dirname, resolve } from "node:path";
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+  plugins: [
+    {
+      name: "graphql-path-resolver",
+      resolveId(source, importer) {
+        if (source.endsWith(".graphql")) {
+          // Resolve the path relative to the the file that imports the .graphql file
+          return resolve(
+            dirname(importer || ""),
+            `${source.startsWith("/") ? `.${source}` : source}.graphql`
+          );
+        }
+        return null; // Let other resolvers handle other imports
+      },
+      load(id) {
+        if (id.endsWith(".graphql")) {
+          // Return the file path as a string, which Vite will use as the resolved module
+          return `export default ${JSON.stringify(id)}`;
+        }
+        return null; // Let other loaders handle other files
+      },
+    },
+  ],
+  test: {},
+});