@powerhousedao/reactor-api 1.9.4 → 1.10.0

package/src/types.ts

@@ -1,22 +1,64 @@
 import {
   IDocumentDriveServer,
   InternalTransmitterUpdate,
+  IReceiver,
   Listener,
+  ListenerRevision,
 } from "document-drive";
-import { PgDatabase } from "drizzle-orm/pg-core";
+import { Document, OperationScope } from "document-model/document";
 import { IncomingHttpHeaders } from "http";
+import { Express } from "express";
+import { IAnalyticsStore } from "@powerhousedao/analytics-engine-core";
+import { ReactorRouterManager } from "./router";
+import { ProcessorClass } from "./processors/processor";
+
+export type IProcessorManager = {
+  registerProcessor(module: IProcessor | ProcessorClass): Promise<IProcessor>;
+};
+
+export type API = {
+  app: Express;
+  reactorRouterManager: ReactorRouterManager;
+  processorManager: IProcessorManager;
+};
 
 export interface Context {
   headers: IncomingHttpHeaders;
   driveId: string | undefined;
   driveServer: IDocumentDriveServer;
-  db: PgDatabase<any, any, any>;
 }
 
-export type Processor = {
+export type Subgraph = {
   name: string;
   resolvers: any;
   typeDefs: string;
   options?: Omit<Listener, "driveId">;
-  transmit?: (strands: InternalTransmitterUpdate[]) => Promise<void>;
+  transmit?: (
+    strands: InternalTransmitterUpdate[],
+  ) => Promise<ListenerRevision[]>;
 };
+
+export type ProcessorType = "analytics" | "operational";
+
+export type ProcessorSetupArgs = {
+  reactor: IDocumentDriveServer;
+  dataSources: {
+    analyticsStore: IAnalyticsStore;
+  };
+};
+
+export type IProcessor<
+  D extends Document = Document,
+  S extends OperationScope = OperationScope,
+> = IReceiver<D, S> & {
+  onSetup?: (args: ProcessorSetupArgs) => void;
+  getOptions: () => ProcessorOptions;
+};
+
+// export interface ProcessorType<T> extends Function {
+//   new (...args: any[]): T;
+//   TYPE: string;
+//   OPTIONS: ProcessorOptions;
+// }
+
+export type ProcessorOptions = Omit<Listener, "driveId"> & { label: string };

package/src/utils/create-schema.ts

@@ -8,7 +8,7 @@ import { Context } from "src/types";
 export const createSchema = (
   documentDriveServer: IDocumentDriveServer,
   resolvers: GraphQLResolverMap<Context>,
-  typeDefs: string
+  typeDefs: string,
 ) =>
   buildSubgraphSchema([
     {
@@ -19,7 +19,7 @@ export const createSchema = (
 
 export const getDocumentModelTypeDefs = (
   documentDriveServer: IDocumentDriveServer,
-  typeDefs: string
+  typeDefs: string,
 ) => {
   const documentModels = documentDriveServer.getDocumentModels();
   let dmSchema = "";
@@ -32,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")};
   
@@ -46,14 +46,15 @@ export const getDocumentModelTypeDefs = (
                 .replaceAll(/input (.*?) {[\s\S]*?}/g, "")
                 .replaceAll("type AccountSnapshotLocalState", "")
                 .replaceAll("type BudgetStatementLocalState", "")
-                .replaceAll("type ScopeFrameworkLocalState", "")
+                .replaceAll("type ScopeFrameworkLocalState", ""),
             )
             .join("\n")};
-  
-          type ${documentModel.name} implements IDocument {
+
+    type ${documentModel.name} implements IDocument {
               id: ID!
               name: String!
               documentType: String!
+              operations: [Operation!]!
               revision: Int!
               created: DateTime!
               lastModified: DateTime!
@@ -65,13 +66,21 @@ export const getDocumentModelTypeDefs = (
   const schema = `
       ${scalarsTypeDefs.join("\n")}
       
+
+
+      type Operation {
+        type: String!
+        index: Int!
+        timestamp: DateTime!
+        hash: String!
+      }
       interface IDocument {
           name: String!
           documentType: String!
           revision: Int!
           created: DateTime!
           lastModified: DateTime!
-          
+          operations: [Operation!]!
       }
       ${dmSchema}
   

package/src/utils/get-knex-client.ts

@@ -0,0 +1,23 @@
+import pkg from "knex";
+import ClientPgLite from "knex-pglite";
+const knex = pkg;
+
+function isPG(connectionString: string) {
+  if (connectionString.startsWith("postgres://")) {
+    return true;
+  }
+  return false;
+}
+
+export function getKnexClient(connectionString: string) {
+  const isPg = isPG(connectionString);
+  const client = isPg ? "pg" : (ClientPgLite as typeof knex.Client);
+  const connection = connectionString;
+
+  return knex({
+    client,
+    connection,
+  });
+}
+
+export function getDrizzleClient(connectionString: string) {}

package/test/router.test.ts

@@ -8,8 +8,7 @@ import {
   IDocumentDriveServer,
   DocumentDriveServer,
 } from "../../document-drive/src/server";
-import { addSubgraph } from "../src/index";
-import { initReactorRouter, reactorRouter } from "../src/router";
+import { ReactorRouterManager } from "../src/router";
 import { getDocumentModelTypeDefs } from "../src/utils/create-schema";
 
 const documentModels = [
@@ -20,36 +19,33 @@ const documentModels = [
 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);
+    const reactor = new DocumentDriveServer(documentModels);
+    const reactorRouter = new ReactorRouterManager("/", app, reactor);
+    await expect(reactorRouter.init()).resolves.toBeUndefined();
   });
 
-  it("should be able to add a new subgraph", async () => {
-    const driveServer = new DocumentDriveServer(documentModels);
-    await driveServer.initialize();
-    const newSubgraph = {
-      name: "newSubgraph",
-      getSchema: (documentDriveServer: IDocumentDriveServer) =>
-        buildSubgraphSchema([
-          {
-            typeDefs: getDocumentModelTypeDefs(
-              documentDriveServer,
-              `
-              type Query {
-                hello: String
-              }
-            `,
-            ),
-            resolvers: { Query: { hello: () => "world" } },
-          },
-        ]),
-    };
+  // it("should be able to add a new subgraph", async () => {
+  //   const driveServer = new DocumentDriveServer(documentModels);
+  //   await driveServer.initialize();
+  //   const newSubgraph = {
+  //     name: "newSubgraph",
+  //     getSchema: (documentDriveServer: IDocumentDriveServer) =>
+  //       buildSubgraphSchema([
+  //         {
+  //           typeDefs: getDocumentModelTypeDefs(
+  //             documentDriveServer,
+  //             `
+  //             type Query {
+  //               hello: String
+  //             }
+  //           `,
+  //           ),
+  //           resolvers: { Query: { hello: () => "world" } },
+  //         },
+  //       ]),
+  //   };
 
-    await addSubgraph(newSubgraph);
-    expect(reactorRouter.stack.length).gte(3);
-  });
+  //   await addSubgraph(newSubgraph);
+  //   expect(reactorRouter.stack.length).gte(3);
+  // });
 });

package/src/internal-listener-manager.ts

@@ -1,108 +0,0 @@
-import {
-  IDocumentDriveServer,
-  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: IDocumentDriveServer;
-  private modules: InternalListenerModule[] = [];
-
-  constructor(driveServer: IDocumentDriveServer) {
-    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();
-
-    for (const { options, transmit } of this.modules) {
-      if (!options || !transmit) {
-        continue;
-      }
-
-      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();
-  }
-}