@powerhousedao/reactor-api 1.9.4 → 1.10.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@powerhousedao/reactor-api",
-  "version": "1.9.4",
+  "version": "1.10.0",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -13,20 +13,23 @@
   "author": "",
   "license": "AGPL-3.0-only",
   "devDependencies": {
+    "@powerhousedao/analytics-engine-graphql": "^0.2.0",
     "@types/body-parser": "^1.19.5",
     "@types/cors": "^2.8.17",
     "@types/express": "^5.0.0",
     "@types/pg": "^8.11.10",
     "esbuild": "^0.24.0",
     "graphql-tag": "^2.12.6",
-    "@powerhousedao/scalars": "1.12.0",
-    "document-model": "2.10.0",
-    "document-drive": "1.8.4"
+    "@powerhousedao/scalars": "1.13.0",
+    "document-drive": "1.9.0",
+    "document-model": "2.11.0"
   },
   "dependencies": {
     "@apollo/server": "^4.11.0",
     "@apollo/subgraph": "^2.9.2",
     "@electric-sql/pglite": "^0.2.12",
+    "@powerhousedao/analytics-engine-core": "^0.3.0",
+    "@powerhousedao/analytics-engine-knex": "^0.4.0",
     "body-parser": "^1.20.3",
     "cors": "^2.8.5",
     "drizzle-kit": "^0.25.0",
@@ -34,10 +37,12 @@
     "express": "^4.21.1",
     "graphql": "^16.9.0",
     "graphql-request": "^6.1.0",
+    "knex": "^3.1.0",
+    "knex-pglite": "^0.10.0",
     "nanoevents": "^9.0.0",
     "pg": "^8.13.0",
     "uuid": "^9.0.1",
-    "document-model-libs": "1.120.3"
+    "document-model-libs": "1.121.0"
   },
   "scripts": {
     "build": "tsup",

package/src/index.ts

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

package/src/processor-manager.ts

@@ -0,0 +1,67 @@
+import { IAnalyticsStore } from "@powerhousedao/analytics-engine-core";
+import { IDocumentDriveServer } from "document-drive";
+import { DocumentDriveDocument } from "document-model-libs/document-drive";
+import { IProcessor, IProcessorManager, ProcessorSetupArgs } from "./types";
+import { ProcessorClass, isProcessorClass } from "./processors";
+
+export class ProcessorManager implements IProcessorManager {
+  private reactor: IDocumentDriveServer;
+  private processors: IProcessor[] = [];
+
+  constructor(
+    driveServer: IDocumentDriveServer,
+    private analyticsStore: IAnalyticsStore,
+  ) {
+    this.reactor = driveServer;
+    driveServer.on("driveAdded", this.#onDriveAdded.bind(this));
+  }
+
+  async #onDriveAdded(drive: DocumentDriveDocument) {
+    await Promise.all(
+      this.processors.map((module) =>
+        this.reactor.addInternalListener(
+          drive.state.global.id,
+          {
+            onStrands: (strands) => module.onStrands(strands),
+            onDisconnect: () => module.onDisconnect(),
+          },
+          { ...module.getOptions() },
+        ),
+      ),
+    );
+  }
+
+  async #onProcessorAdded(processor: IProcessor) {
+    const drives = await this.reactor.getDrives();
+
+    const options = processor.getOptions();
+    await Promise.all(
+      drives.map((drive) =>
+        this.reactor.addInternalListener(
+          drive,
+          {
+            onStrands: (strands) => processor.onStrands(strands),
+            onDisconnect: () => processor.onDisconnect(),
+          },
+          options,
+        ),
+      ),
+    );
+  }
+
+  async registerProcessor(module: IProcessor | ProcessorClass) {
+    const args: ProcessorSetupArgs = {
+      reactor: this.reactor,
+      dataSources: {
+        analyticsStore: this.analyticsStore,
+      },
+    };
+
+    const processor = isProcessorClass(module) ? new module(args) : module;
+    processor.onSetup?.(args);
+
+    await this.#onProcessorAdded(processor);
+    this.processors.push(processor);
+    return processor;
+  }
+}

package/src/processors/analytics-processor.ts

@@ -0,0 +1,21 @@
+import { IAnalyticsStore } from "@powerhousedao/analytics-engine-core";
+import { Document, OperationScope } from "document-model/document";
+import { Processor } from "./processor";
+import { ProcessorOptions, ProcessorSetupArgs } from "src/types";
+
+export abstract class AnalyticsProcessor<
+  D extends Document = Document,
+  S extends OperationScope = OperationScope,
+> extends Processor<D, S> {
+  protected analyticsStore: IAnalyticsStore;
+
+  constructor(args: ProcessorSetupArgs, options?: ProcessorOptions) {
+    super(args, options);
+    this.analyticsStore = args.dataSources.analyticsStore;
+  }
+
+  onSetup(args: ProcessorSetupArgs) {
+    super.onSetup(args);
+    this.analyticsStore = args.dataSources.analyticsStore;
+  }
+}

package/src/processors/index.ts

@@ -0,0 +1,3 @@
+export * from "./analytics-processor";
+// export * from "./rwa-analytics-processor";
+export * from "./processor";

package/src/processors/processor.ts

@@ -0,0 +1,75 @@
+import {
+  IDocumentDriveServer,
+  InternalTransmitterUpdate,
+} from "document-drive";
+import { Document, OperationScope } from "document-model/document";
+import { IProcessor, ProcessorOptions, ProcessorSetupArgs } from "src/types";
+
+export type ProcessorUpdate<
+  D extends Document = Document,
+  S extends OperationScope = OperationScope,
+> = InternalTransmitterUpdate<D, S>;
+
+export abstract class Processor<
+  D extends Document = Document,
+  S extends OperationScope = OperationScope,
+> implements IProcessor<D, S>
+{
+  protected reactor: IDocumentDriveServer;
+  protected processorOptions: ProcessorOptions = {
+    listenerId: "processor",
+    filter: {
+      branch: ["main"],
+      documentId: ["*"],
+      documentType: ["*"],
+      scope: ["global"],
+    },
+    block: false,
+    label: "processor",
+    system: true,
+  };
+
+  constructor(args: ProcessorSetupArgs, options?: ProcessorOptions) {
+    this.reactor = args.reactor;
+    if (options) {
+      this.processorOptions = { ...this.processorOptions, ...options };
+    }
+  }
+
+  onSetup(args: ProcessorSetupArgs): void {
+    this.reactor = args.reactor;
+  }
+
+  abstract onStrands(strands: ProcessorUpdate<D, S>[]): Promise<void>;
+
+  abstract onDisconnect(): Promise<void>;
+
+  getOptions() {
+    return this.processorOptions;
+  }
+}
+
+export class BaseProcessor extends Processor {
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  async onStrands(strands: ProcessorUpdate[]): Promise<void> {}
+  async onDisconnect(): Promise<void> {}
+}
+
+export type ProcessorClass = typeof BaseProcessor;
+
+// checks if the provided candidate is a descendant of the Processor class.
+export function isProcessorClass(
+  candidate: unknown,
+): candidate is ProcessorClass {
+  if (typeof candidate !== "function") return false;
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+  let proto = Object.getPrototypeOf(candidate);
+
+  while (proto) {
+    if (Object.prototype.isPrototypeOf.call(proto, Processor)) return true;
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+    proto = Object.getPrototypeOf(proto);
+  }
+
+  return false;
+}

package/src/router.ts

@@ -1,31 +1,21 @@
 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 { GraphQLResolverMap } from "@apollo/subgraph/dist/schema-helper";
 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";
-import {
-  InternalListenerManager,
-  InternalListenerModule,
-} from "./internal-listener-manager";
-import { driveSubgraph, systemSubgraph } from "./subgraphs";
-import { Context, Processor } from "./types";
+import { analyticsSubgraph, driveSubgraph, systemSubgraph } from "./subgraphs";
+import { Context, Subgraph } from "./types";
 import { createSchema } from "./utils/create-schema";
-const { Pool } = pg;
 
 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[] = [
+  private subgraphs: Subgraph[] = [
     {
       name: "system",
       resolvers: systemSubgraph.resolvers,
@@ -36,25 +26,21 @@ export class ReactorRouterManager {
       resolvers: driveSubgraph.resolvers,
       typeDefs: driveSubgraph.typeDefs,
     },
+    {
+      name: "analytics",
+      resolvers: analyticsSubgraph.resolvers as GraphQLResolverMap<Context>,
+      typeDefs: analyticsSubgraph.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,
-    ),
+    private readonly reactor: IDocumentDriveServer,
   ) {}
 
   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 models = this.reactor.getDocumentModels();
     const driveModel = models.find(
       (it) => it.documentModel.name === "DocumentDrive",
     );
@@ -62,7 +48,7 @@ export class ReactorRouterManager {
       throw new Error("DocumentDrive model required");
     }
 
-    this.driveServer.on("documentModels", () => {
+    this.reactor.on("documentModels", () => {
       this.updateRouter().catch((error: unknown) => console.error(error));
     });
 
@@ -74,30 +60,18 @@ export class ReactorRouterManager {
   }
 
   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,
-        });
-      }
-
+    for (const subgraph of this.subgraphs) {
       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,
+        this.reactor,
+        subgraphConfig.resolvers as GraphQLResolverMap<Context>,
         subgraphConfig.typeDefs,
       );
       // create apollo server
@@ -119,8 +93,7 @@ export class ReactorRouterManager {
           context: ({ req }): Context => ({
             headers: req.headers,
             driveId: req.params.drive ?? undefined,
-            driveServer: this.driveServer,
-            db: this.database!,
+            driveServer: this.reactor,
             // analyticStore: undefined, // TODO: add analytic store
             ...this.getAdditionalContextFields(),
           }),
@@ -132,31 +105,14 @@ export class ReactorRouterManager {
     console.log("Router updated.");
   }
 
-  async registerProcessor(processor: Processor) {
-    const schema = createSchema(
-      this.driveServer,
-      processor.resolvers,
-      processor.typeDefs,
-    );
-
-    this.registry.unshift({
-      ...processor,
-    });
-
-    // update router
-    console.log(`Registering [${processor.name}] processor.`);
-    await this.updateRouter();
+  async registerSubgraph(subgraph: Subgraph) {
+    this.subgraphs.unshift(subgraph);
+    console.log(`Registered [${subgraph.name}] subgraph.`);
+    return Promise.resolve();
   }
 
   #getLocalSubgraphConfig(subgraphName: string) {
-    return this.registry.find((it) => it.name === subgraphName);
-  }
-
-  async #registerInternalListener(module: InternalListenerModule) {
-    if (!this.listenerManager) {
-      throw new Error("Listener manager not initialized");
-    }
-    await this.listenerManager.registerInternalListener(module);
+    return this.subgraphs.find((it) => it.name === subgraphName);
   }
 
   getAdditionalContextFields = () => {

package/src/server.ts

@@ -1,13 +1,23 @@
 import { PGlite } from "@electric-sql/pglite";
+import { AnalyticsQueryEngine } from "@powerhousedao/analytics-engine-core";
+import { AnalyticsModel } from "@powerhousedao/analytics-engine-graphql";
+import {
+  KnexAnalyticsStore,
+  KnexQueryExecutor,
+} from "@powerhousedao/analytics-engine-knex";
 import { IDocumentDriveServer } from "document-drive";
 import express, { Express } from "express";
-import pg from "pg";
-const { Pool } = pg;
+import { Pool } from "pg";
 import { ReactorRouterManager } from "./router";
+import { getKnexClient } from "./utils/get-knex-client";
+import { ProcessorManager } from "./processor-manager";
+import { API } from "./types";
+import { initialize } from "./subgraphs/analytics";
 
 type Options = {
   express?: Express;
   port?: number;
+  dbConnection: string | undefined;
   client?: PGlite | typeof Pool | undefined;
 };
 
@@ -15,20 +25,29 @@ const DEFAULT_PORT = 4000;
 
 export async function startAPI(
   reactor: IDocumentDriveServer,
-  options: Options
-) {
+  options: Options,
+): Promise<API> {
   const port = options.port ?? DEFAULT_PORT;
   const app = options.express ?? express();
 
-  const reactorRouterManager = new ReactorRouterManager(
-    "/",
-    app,
-    reactor,
-    options.client
-  );
+  const knex = getKnexClient(options.dbConnection ?? "./dev.db");
+  await initialize(knex);
+
+  const analyticsStore = new KnexAnalyticsStore({
+    executor: new KnexQueryExecutor(),
+    knex,
+  });
+  const reactorRouterManager = new ReactorRouterManager("/", app, reactor);
+  reactorRouterManager.setAdditionalContextFields({
+    dataSources: {
+      db: {
+        Analytics: new AnalyticsModel(new AnalyticsQueryEngine(analyticsStore)),
+      },
+    },
+  });
   await reactorRouterManager.init();
+  const processorManager = new ProcessorManager(reactor, analyticsStore);
 
   app.listen(port);
-
-  return { app, reactorRouterManager };
+  return { app, reactorRouterManager, processorManager };
 }

package/src/subgraphs/analytics/db.ts

@@ -0,0 +1,55 @@
+import { Knex } from "knex";
+
+export async function createSchema(knex: Knex) {
+  if (!(await knex.schema.hasTable("AnalyticsDimension"))) {
+    await knex.schema.createTable("AnalyticsDimension", (table) => {
+      table.increments("id").primary();
+      table
+        .string("dimension")
+        .notNullable()
+        .index("analyticsdimension_dimension_index");
+      table.string("path").notNullable().index("analyticsdimension_path_index");
+      table.string("label").nullable();
+      table.string("icon").nullable();
+      table.text("description").nullable();
+    });
+  }
+
+  if (!(await knex.schema.hasTable("AnalyticsSeries"))) {
+    await knex.schema.createTable("AnalyticsSeries", (table) => {
+      table.increments("id").primary();
+      table
+        .string("source")
+        .notNullable()
+        .index("analyticsseries_source_index");
+      table.date("start").notNullable().index("analyticsseries_start_index");
+      table.date("end").nullable().index("analyticsseries_end_index");
+      table
+        .string("metric")
+        .notNullable()
+        .index("analyticsseries_metric_index");
+      table.float("value").notNullable().index("analyticsseries_value_index");
+      table.string("unit").nullable().index("analyticsseries_unit_index");
+      table.string("fn").notNullable().index("analyticsseries_fn_index");
+      table.json("params").nullable();
+    });
+  }
+
+  if (!(await knex.schema.hasTable("AnalyticsSeries_AnalyticsDimension"))) {
+    await knex.schema.createTable(
+      "AnalyticsSeries_AnalyticsDimension",
+      (table) => {
+        table
+          .integer("seriesId")
+          .references("AnalyticsSeries.id")
+          .onDelete("CASCADE")
+          .index("analyticsseries_analyticsdimension_seriesid_index");
+        table
+          .integer("dimensionId")
+          .references("AnalyticsDimension.id")
+          .onDelete("CASCADE")
+          .index("analyticsseries_analyticsdimension_dimensionid_index");
+      },
+    );
+  }
+}

package/src/subgraphs/analytics/index.ts

@@ -0,0 +1,12 @@
+import {
+  AnalyticsResolvers as resolvers,
+  typedefs as typeDefs,
+} from "@powerhousedao/analytics-engine-graphql";
+import { createSchema } from "./db.js";
+import { Knex } from "knex";
+
+export { resolvers, typeDefs };
+
+export async function initialize(knex: Knex) {
+  await createSchema(knex);
+}

package/src/subgraphs/drive/resolvers.ts

@@ -1,3 +1,4 @@
+import { GraphQLResolverMap } from "@apollo/subgraph/dist/schema-helper";
 import {
   generateUUID,
   ListenerRevision,
@@ -7,19 +8,30 @@ import {
 import {
   actions,
   DocumentDriveAction,
+  FileNode,
   Listener,
   ListenerFilter,
   TransmitterType,
 } from "document-model-libs/document-drive";
+import { Asset } from "document-model-libs/real-world-assets";
 import { BaseAction, Operation } from "document-model/document";
 import {
   DocumentModelInput,
   DocumentModelState,
 } from "document-model/document-model";
 import { Context } from "../types";
-import { GraphQLResolverMap } from "@apollo/subgraph/dist/schema-helper";
 
 export const resolvers: GraphQLResolverMap<Context> = {
+  Asset: {
+    __resolveType: (obj: Asset) => {
+      return obj.type;
+    },
+  },
+  Node: {
+    __resolveType: (obj: FileNode) => {
+      return obj.documentType ? "FileNode" : "FolderNode";
+    },
+  },
   Query: {
     drive: async (_: unknown, args: unknown, ctx: Context) => {
       if (!ctx.driveId) throw new Error("Drive ID is required");
@@ -38,7 +50,7 @@ export const resolvers: GraphQLResolverMap<Context> = {
       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");
@@ -63,7 +75,7 @@ export const resolvers: GraphQLResolverMap<Context> = {
     registerPullResponderListener: async (
       _: unknown,
       { filter }: { filter: ListenerFilter },
-      ctx: Context
+      ctx: Context,
     ) => {
       if (!ctx.driveId) throw new Error("Drive ID is required");
       const uuid = generateUUID();
@@ -87,12 +99,12 @@ export const resolvers: GraphQLResolverMap<Context> = {
 
       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}`,
         );
       }
 
@@ -101,7 +113,7 @@ export const resolvers: GraphQLResolverMap<Context> = {
     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(
@@ -119,11 +131,11 @@ export const resolvers: GraphQLResolverMap<Context> = {
             ? 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] ?? [];
@@ -148,7 +160,7 @@ export const resolvers: GraphQLResolverMap<Context> = {
             status: result.status,
             error: result.error?.message || undefined,
           };
-        })
+        }),
       );
 
       return listenerRevisions;
@@ -159,7 +171,7 @@ export const resolvers: GraphQLResolverMap<Context> = {
         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");
@@ -176,12 +188,12 @@ export const resolvers: GraphQLResolverMap<Context> = {
 
       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;
@@ -192,12 +204,12 @@ export const resolvers: GraphQLResolverMap<Context> = {
     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/src/subgraphs/index.ts

@@ -1,3 +1,4 @@
 export * as systemSubgraph from "./system";
 export * as driveSubgraph from "./drive";
+export * as analyticsSubgraph from "./analytics";
 export * from "./types";