@powerhousedao/reactor-api 1.7.0 → 1.8.1

package/src/router.ts

@@ -1,122 +1,170 @@
 import { ApolloServer } from "@apollo/server";
 import { expressMiddleware } from "@apollo/server/express4";
 import { ApolloServerPluginInlineTraceDisabled } from "@apollo/server/plugin/disabled";
+import { PGlite } from "@electric-sql/pglite";
 import bodyParser from "body-parser";
 import cors from "cors";
 import { IDocumentDriveServer } from "document-drive";
+import { drizzle as drizzlePg } from "drizzle-orm/node-postgres";
+import { PgDatabase } from "drizzle-orm/pg-core";
+import { drizzle as drizzlePglite } from "drizzle-orm/pglite";
 import express, { IRouter, Router } from "express";
+import pg from "pg";
+const { Pool } = pg;
 import {
   InternalListenerManager,
   InternalListenerModule,
 } from "./internal-listener-manager";
-import { SUBGRAPH_REGISTRY } from "./subgraphs";
-import { Context } from "./types";
-export let reactorRouter: IRouter = Router();
+import { driveSubgraph, systemSubgraph } from "./subgraphs";
+import { Context, Processor } from "./types";
+import { createSchema } from "./utils/create-schema";
+import { GraphQLSchema } from "graphql";
+
+export class ReactorRouterManager {
+  private database: PgDatabase<any, any, any> | undefined;
+  private reactorRouter: IRouter = Router();
+  private contextFields: Record<string, any> = {};
+
+  // @todo: need to persist somewhere
+  private registry: Processor[] = [
+    {
+      name: "system",
+      resolvers: systemSubgraph.resolvers,
+      typeDefs: systemSubgraph.typeDefs,
+    },
+    {
+      name: "d/:drive",
+      resolvers: driveSubgraph.resolvers,
+      typeDefs: driveSubgraph.typeDefs,
+    },
+  ];
+  constructor(
+    private readonly path: string,
+    private readonly app: express.Express,
+    private readonly driveServer: IDocumentDriveServer,
+    private readonly client: PGlite | typeof Pool = new PGlite(),
+    private listenerManager: InternalListenerManager = new InternalListenerManager(
+      driveServer
+    )
+  ) {}
+
+  async init() {
+    if (this.client instanceof Pool) {
+      this.database = drizzlePg(this.client);
+    } else {
+      this.database = drizzlePglite(this.client as PGlite);
+    }
+    await this.listenerManager.init();
+    const models = this.driveServer.getDocumentModels();
+    const driveModel = models.find(
+      (it) => it.documentModel.name === "DocumentDrive"
+    );
+    if (!driveModel) {
+      throw new Error("DocumentDrive model required");
+    }
 
-const getLocalSubgraphConfig = (subgraphName: string) =>
-  SUBGRAPH_REGISTRY.find((it) => it.name === subgraphName);
+    this.driveServer.on("documentModels", () => {
+      this.updateRouter().catch((error: unknown) => console.error(error));
+    });
 
-let listenerManager: InternalListenerManager | undefined;
+    this.app.use(this.path, (req, res, next) =>
+      this.reactorRouter(req, res, next)
+    );
 
-export const getListenerManager = async (driveServer: IDocumentDriveServer) => {
-  if (!listenerManager) {
-    listenerManager = new InternalListenerManager(driveServer);
-    await listenerManager.init();
+    await this.updateRouter();
   }
-  return listenerManager;
-};
-
-export const updateRouter = async (driveServer: IDocumentDriveServer) => {
-  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,
-      // @ts-ignore
-      expressMiddleware(server, {
-        context: ({ req }): Promise<Context> =>
-          Promise.resolve({
+  async updateRouter() {
+    if (!this.database) {
+      await this.init();
+    }
+
+    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 this.registry) {
+      if (subgraph.options && subgraph.transmit) {
+        await this.#registerInternalListener({
+          name: subgraph.name,
+          options: subgraph.options,
+          transmit: subgraph.transmit,
+        });
+      }
+
+      const subgraphConfig = this.#getLocalSubgraphConfig(subgraph.name);
+      if (!subgraphConfig) continue;
+      console.log(`Setting up subgraph ${subgraphConfig.name}`);
+      // get schema
+      const schema = createSchema(
+        this.driveServer,
+        subgraphConfig.resolvers,
+        subgraphConfig.typeDefs
+      );
+      // 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,
+        // @ts-ignore
+        expressMiddleware(server, {
+          context: ({ req }): Context => ({
             headers: req.headers,
             driveId: req.params.drive ?? undefined,
-            driveServer,
-            ...getAdditionalContextFields(),
+            driveServer: this.driveServer,
+            db: this.database!,
+            // analyticStore: undefined, // TODO: add analytic store
+            ...this.getAdditionalContextFields(),
           }),
-      }),
-    );
-    console.log(`Setting up [${subgraphConfig.name}] subgraph at ${path}`);
-  }
+        })
+      );
+    }
 
-  listenerManager = await getListenerManager(driveServer);
-  reactorRouter = newRouter;
-  console.log("All subgraphs started.");
-};
-
-let docDriveServer: IDocumentDriveServer;
-export const initReactorRouter = async (
-  path: string,
-  app: express.Express,
-  driveServer: IDocumentDriveServer,
-) => {
-  docDriveServer = driveServer;
-  const models = driveServer.getDocumentModels();
-  const driveModel = models.find(
-    (it) => it.documentModel.name === "DocumentDrive",
-  );
-
-  if (!driveModel) {
-    throw new Error("DocumentDrive model required");
+    this.reactorRouter = newRouter;
+    console.log("Router updated.");
   }
 
-  await updateRouter(driveServer);
+  async registerProcessor(processor: Processor) {
+    const schema = createSchema(
+      this.driveServer,
+      processor.resolvers,
+      processor.typeDefs
+    );
 
-  driveServer.on("documentModels", () => {
-    updateRouter(driveServer).catch((error: unknown) => console.error(error));
-  });
+    this.registry.unshift({
+      ...processor,
+    });
 
-  app.use(path, (req, res, next) => reactorRouter(req, res, next));
-};
+    // update router
+    console.log(`Registering [${processor.name}] processor.`);
+    await this.updateRouter();
+  }
 
-export const addSubgraph = async (
-  subgraph: (typeof SUBGRAPH_REGISTRY)[number],
-) => {
-  SUBGRAPH_REGISTRY.unshift(subgraph);
-  await updateRouter(docDriveServer);
-};
+  #getLocalSubgraphConfig(subgraphName: string) {
+    return this.registry.find((it) => it.name === subgraphName);
+  }
 
-export const registerInternalListener = async (
-  module: InternalListenerModule,
-) => {
-  if (!listenerManager) {
-    throw new Error("Listener manager not initialized");
+  async #registerInternalListener(module: InternalListenerModule) {
+    if (!this.listenerManager) {
+      throw new Error("Listener manager not initialized");
+    }
+    await this.listenerManager.registerInternalListener(module);
   }
-  await listenerManager.registerInternalListener(module);
-};
 
-let contextFields = {};
-export const getAdditionalContextFields = () => {
-  return contextFields;
-};
+  getAdditionalContextFields = () => {
+    return this.contextFields;
+  };
 
-export const setAdditionalContextFields = (fields: Record<string, any>) => {
-  contextFields = { ...contextFields, ...fields };
-};
+  setAdditionalContextFields(fields: Record<string, any>) {
+    this.contextFields = { ...this.contextFields, ...fields };
+  }
+}

package/src/server.ts

@@ -1,23 +1,34 @@
+import { PGlite } from "@electric-sql/pglite";
 import { IDocumentDriveServer } from "document-drive";
 import express, { Express } from "express";
-import { initReactorRouter } from "./router";
+import pg from "pg";
+const { Pool } = pg;
+import { ReactorRouterManager } from "./router";
+
 type Options = {
   express?: Express;
   port?: number;
+  client?: PGlite | typeof Pool | undefined;
 };
 
 const DEFAULT_PORT = 4000;
 
 export async function startAPI(
   reactor: IDocumentDriveServer,
-  options: Options,
+  options: Options
 ) {
   const port = options.port ?? DEFAULT_PORT;
   const app = options.express ?? express();
 
-  await initReactorRouter("/", app, reactor);
+  const reactorRouterManager = new ReactorRouterManager(
+    "/",
+    app,
+    reactor,
+    options.client
+  );
+  await reactorRouterManager.init();
 
   app.listen(port);
 
-  return app;
+  return { app, reactorRouterManager };
 }

package/src/subgraphs/drive/index.ts

@@ -0,0 +1,4 @@
+import { typeDefs } from "./type-defs";
+import { resolvers } from "./resolvers";
+
+export { typeDefs, resolvers };

package/src/subgraphs/drive/resolvers.ts

@@ -17,8 +17,9 @@ import {
   DocumentModelState,
 } from "document-model/document-model";
 import { Context } from "../types";
+import { GraphQLResolverMap } from "@apollo/subgraph/dist/schema-helper";
 
-export const resolvers = {
+export const resolvers: GraphQLResolverMap<Context> = {
   Query: {
     drive: async (_: unknown, args: unknown, ctx: Context) => {
       if (!ctx.driveId) throw new Error("Drive ID is required");
@@ -37,7 +38,7 @@ export const resolvers = {
       const dms = ctx.driveServer.getDocumentModels();
       const dm = dms.find(
         ({ documentModel }: { documentModel: DocumentModelState }) =>
-          documentModel.id === document.documentType,
+          documentModel.id === document.documentType
       );
       const globalState = document.state.global;
       if (!globalState) throw new Error("Document not found");
@@ -62,7 +63,7 @@ export const resolvers = {
     registerPullResponderListener: async (
       _: unknown,
       { filter }: { filter: ListenerFilter },
-      ctx: Context,
+      ctx: Context
     ) => {
       if (!ctx.driveId) throw new Error("Drive ID is required");
       const uuid = generateUUID();
@@ -86,12 +87,12 @@ export const resolvers = {
 
       const result = await ctx.driveServer.queueDriveAction(
         ctx.driveId,
-        actions.addListener({ listener }),
+        actions.addListener({ listener })
       );
 
       if (result.status !== "SUCCESS" && result.error) {
         throw new Error(
-          `Listener couldn't be registered: ${result.error.message}`,
+          `Listener couldn't be registered: ${result.error.message}`
         );
       }
 
@@ -100,7 +101,7 @@ export const resolvers = {
     pushUpdates: async (
       _: unknown,
       { strands }: { strands: StrandUpdateGraphQL[] },
-      ctx: Context,
+      ctx: Context
     ) => {
       if (!ctx.driveId) throw new Error("Drive ID is required");
       const listenerRevisions: ListenerRevision[] = await Promise.all(
@@ -118,11 +119,11 @@ export const resolvers = {
             ? ctx.driveServer.queueOperations(
                 s.driveId,
                 s.documentId,
-                operations,
+                operations
               )
             : ctx.driveServer.queueDriveOperations(
                 s.driveId,
-                operations as Operation<DocumentDriveAction | BaseAction>[],
+                operations as Operation<DocumentDriveAction | BaseAction>[]
               ));
 
           const scopeOperations = result.document?.operations[s.scope] ?? [];
@@ -147,7 +148,7 @@ export const resolvers = {
             status: result.status,
             error: result.error?.message || undefined,
           };
-        }),
+        })
       );
 
       return listenerRevisions;
@@ -158,7 +159,7 @@ export const resolvers = {
         listenerId,
         revisions,
       }: { listenerId: string; revisions: ListenerRevision[] },
-      ctx: Context,
+      ctx: Context
     ) => {
       if (!listenerId || !revisions) return false;
       if (!ctx.driveId) throw new Error("Drive ID is required");
@@ -175,12 +176,12 @@ export const resolvers = {
 
       const transmitter = (await ctx.driveServer.getTransmitter(
         ctx.driveId,
-        listenerId,
+        listenerId
       )) as PullResponderTransmitter;
       const result = await transmitter.processAcknowledge(
         ctx.driveId ?? "1",
         listenerId,
-        validEntries,
+        validEntries
       );
 
       return result;
@@ -191,12 +192,12 @@ export const resolvers = {
     strands: async (
       _: unknown,
       { listenerId, since }: { listenerId: string; since: string | undefined },
-      ctx: Context,
+      ctx: Context
     ) => {
       if (!ctx.driveId) throw new Error("Drive ID is required");
       const listener = (await ctx.driveServer.getTransmitter(
         ctx.driveId,
-        listenerId,
+        listenerId
       )) as PullResponderTransmitter;
       const strands = await listener.getStrands({ since });
       return strands.map((e) => ({

package/{dist/schema-2U4EFPTT.graphql → src/subgraphs/drive/type-defs.ts}

@@ -1,4 +1,4 @@
-type Query {
+export const typeDefs = `type Query {
   system: System
   drive: DocumentDriveState
   document(id: ID!): IDocument
@@ -133,3 +133,4 @@ type System {
 type Sync {
   strands(listenerId: ID!, since: String): [StrandUpdate!]!
 }
+`;

package/src/subgraphs/index.ts

@@ -1,15 +1,3 @@
-import { getSchema as getSystemSchema } from "./system/subgraph";
-import { getSchema as getDriveSchema } from "./drive/subgraph";
-
+export * as systemSubgraph from "./system";
+export * as driveSubgraph from "./drive";
 export * from "./types";
-
-export const SUBGRAPH_REGISTRY = [
-  {
-    name: "system",
-    getSchema: getSystemSchema,
-  },
-  {
-    name: "d/:drive",
-    getSchema: getDriveSchema,
-  },
-];

package/src/subgraphs/system/index.ts

@@ -0,0 +1,4 @@
+import { typeDefs } from "./type-defs";
+import { resolvers } from "./resolvers";
+
+export { typeDefs, resolvers };

package/src/subgraphs/system/resolvers.ts

@@ -1,7 +1,8 @@
 import { DriveInput } from "document-drive";
 import { Context } from "../types";
+import { GraphQLResolverMap } from "@apollo/subgraph/dist/schema-helper";
 
-export const resolvers = {
+export const resolvers: GraphQLResolverMap<Context> = {
   Query: {
     drives: async (parent: unknown, args: unknown, ctx: Context) => {
       const drives = await ctx.driveServer.getDrives();

package/src/subgraphs/system/type-defs.ts

@@ -0,0 +1,18 @@
+export const typeDefs = `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/types.ts

@@ -1,8 +1,22 @@
-import { IDocumentDriveServer } from "document-drive";
+import {
+  IDocumentDriveServer,
+  InternalTransmitterUpdate,
+  Listener,
+} from "document-drive";
+import { PgDatabase } from "drizzle-orm/pg-core";
 import { IncomingHttpHeaders } from "http";
 
 export interface Context {
   headers: IncomingHttpHeaders;
   driveId: string | undefined;
   driveServer: IDocumentDriveServer;
+  db: PgDatabase<any, any, any>;
 }
+
+export type Processor = {
+  name: string;
+  resolvers: any;
+  typeDefs: string;
+  options?: Omit<Listener, "driveId">;
+  transmit?: (strands: InternalTransmitterUpdate[]) => Promise<void>;
+};

package/src/utils/create-schema.ts

@@ -3,11 +3,12 @@ import { IDocumentDriveServer } from "document-drive";
 import { GraphQLResolverMap } from "@apollo/subgraph/dist/schema-helper";
 import { typeDefs as scalarsTypeDefs } from "@powerhousedao/scalars";
 import { parse } from "graphql";
+import { Context } from "src/types";
 
 export const createSchema = (
   documentDriveServer: IDocumentDriveServer,
-  resolvers: GraphQLResolverMap,
-  typeDefs: string,
+  resolvers: GraphQLResolverMap<Context>,
+  typeDefs: string
 ) =>
   buildSubgraphSchema([
     {
@@ -18,7 +19,7 @@ export const createSchema = (
 
 export const getDocumentModelTypeDefs = (
   documentDriveServer: IDocumentDriveServer,
-  typeDefs: string,
+  typeDefs: string
 ) => {
   const documentModels = documentDriveServer.getDocumentModels();
   let dmSchema = "";
@@ -31,7 +32,7 @@ export const getDocumentModelTypeDefs = (
                 .replaceAll(`: Account`, `: ${documentModel.name}Account`)
                 .replaceAll(`[Account!]!`, `[${documentModel.name}Account!]!`)
                 .replaceAll("scalar DateTime", "")
-                .replaceAll(/input (.*?) {[\s\S]*?}/g, ""),
+                .replaceAll(/input (.*?) {[\s\S]*?}/g, "")
             )
             .join("\n")};
   
@@ -45,7 +46,7 @@ export const getDocumentModelTypeDefs = (
                 .replaceAll(/input (.*?) {[\s\S]*?}/g, "")
                 .replaceAll("type AccountSnapshotLocalState", "")
                 .replaceAll("type BudgetStatementLocalState", "")
-                .replaceAll("type ScopeFrameworkLocalState", ""),
+                .replaceAll("type ScopeFrameworkLocalState", "")
             )
             .join("\n")};
   

package/dist/schema-2TGHGOBQ.graphql

@@ -1,18 +0,0 @@
-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
-}