@powerhousedao/reactor-api 1.10.9 → 1.11.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@powerhousedao/reactor-api",
-  "version": "1.10.9",
+  "version": "1.11.0",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -21,8 +21,8 @@
     "esbuild": "^0.24.0",
     "graphql-tag": "^2.12.6",
     "@powerhousedao/scalars": "1.13.0",
-    "document-model": "2.13.0",
-    "document-drive": "1.11.5"
+    "document-drive": "1.11.6",
+    "document-model": "2.13.0"
   },
   "dependencies": {
     "@apollo/server": "^4.11.0",
@@ -42,7 +42,7 @@
     "nanoevents": "^9.0.0",
     "pg": "^8.13.0",
     "uuid": "^9.0.1",
-    "document-model-libs": "1.122.5"
+    "document-model-libs": "1.122.6"
   },
   "scripts": {
     "build": "tsup",

package/src/index.ts

@@ -1,5 +1,7 @@
 export * from "./server";
-export * from "./router";
-export * from "./utils/create-schema";
+export * from "./subgraphs/manager";
+export * from "./utils";
 export * from "./processors";
 export * from "./types";
+export * from "./subgraphs";
+export * from "@powerhousedao/analytics-engine-core";

package/src/processors/analytics-processor.ts

@@ -1,7 +1,7 @@
 import { IAnalyticsStore } from "@powerhousedao/analytics-engine-core";
 import { Document, OperationScope } from "document-model/document";
 import { Processor } from "./processor";
-import { ProcessorOptions, ProcessorSetupArgs } from "src/types";
+import { ProcessorOptions, ProcessorSetupArgs } from "../types";
 
 export * from "@powerhousedao/analytics-engine-core";
 
@@ -13,11 +13,6 @@ export abstract class AnalyticsProcessor<
 
   constructor(args: ProcessorSetupArgs, options?: ProcessorOptions) {
     super(args, options);
-    this.analyticsStore = args.dataSources.analyticsStore;
-  }
-
-  onSetup(args: ProcessorSetupArgs) {
-    super.onSetup(args);
-    this.analyticsStore = args.dataSources.analyticsStore;
+    this.analyticsStore = args.analyticsStore;
   }
 }

package/src/processors/index.ts

@@ -1,2 +1,3 @@
 export * from "./analytics-processor";
 export * from "./processor";
+export * from "./manager";

package/src/{processor-manager.ts → processors/manager.ts}

@@ -1,8 +1,14 @@
-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";
+
+import {
+  Db,
+  IProcessor,
+  IProcessorManager,
+  ProcessorSetupArgs,
+} from "../types";
+import { IAnalyticsStore } from "./analytics-processor";
+import { isProcessorClass, ProcessorClass } from "./processor";
 
 export class ProcessorManager implements IProcessorManager {
   private reactor: IDocumentDriveServer;
@@ -10,6 +16,7 @@ export class ProcessorManager implements IProcessorManager {
 
   constructor(
     driveServer: IDocumentDriveServer,
+    private operationalStore: Db,
     private analyticsStore: IAnalyticsStore,
   ) {
     this.reactor = driveServer;
@@ -52,9 +59,8 @@ export class ProcessorManager implements IProcessorManager {
   async registerProcessor(module: IProcessor | ProcessorClass) {
     const args: ProcessorSetupArgs = {
       reactor: this.reactor,
-      dataSources: {
-        analyticsStore: this.analyticsStore,
-      },
+      operationalStore: this.operationalStore,
+      analyticsStore: this.analyticsStore,
     };
 
     const processor = isProcessorClass(module) ? new module(args) : module;

package/src/processors/processor.ts

@@ -3,7 +3,7 @@ import {
   InternalTransmitterUpdate,
 } from "document-drive";
 import { Document, OperationScope } from "document-model/document";
-import { IProcessor, ProcessorOptions, ProcessorSetupArgs } from "src/types";
+import { IProcessor, ProcessorOptions, ProcessorSetupArgs } from "../types";
 
 export type ProcessorUpdate<
   D extends Document = Document,

package/src/server.ts

@@ -1,18 +1,15 @@
 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 { Pool } from "pg";
-import { ReactorRouterManager } from "./router";
-import { getKnexClient } from "./utils/get-knex-client";
-import { ProcessorManager } from "./processor-manager";
+import { ProcessorManager } from "./processors";
+import { SubgraphManager } from "./subgraphs/manager";
 import { API } from "./types";
-import { initialize } from "./subgraphs/analytics";
+import { getDbClient } from "./utils/get-db-client";
+import {
+  KnexAnalyticsStore,
+  KnexQueryExecutor,
+} from "@powerhousedao/analytics-engine-knex";
 
 type Options = {
   express?: Express;
@@ -29,25 +26,21 @@ export async function startAPI(
 ): Promise<API> {
   const port = options.port ?? DEFAULT_PORT;
   const app = options.express ?? express();
-
-  const knex = getKnexClient(options.dbPath);
-  await initialize(knex);
-
+  const db = getDbClient(options.dbPath);
   const analyticsStore = new KnexAnalyticsStore({
     executor: new KnexQueryExecutor(),
-    knex,
-  });
-  const reactorRouterManager = new ReactorRouterManager("/", app, reactor);
-  reactorRouterManager.setAdditionalContextFields({
-    dataSources: {
-      db: {
-        Analytics: new AnalyticsModel(new AnalyticsQueryEngine(analyticsStore)),
-      },
-    },
+    knex: db,
   });
-  await reactorRouterManager.init();
-  const processorManager = new ProcessorManager(reactor, analyticsStore);
+  const subgraphManager = new SubgraphManager(
+    "/",
+    app,
+    reactor,
+    db,
+    analyticsStore,
+  );
+  await subgraphManager.init();
+  const processorManager = new ProcessorManager(reactor, db, analyticsStore);
 
   app.listen(port);
-  return { app, reactorRouterManager, processorManager };
+  return { app, subgraphManager, processorManager };
 }

package/src/subgraphs/analytics/index.ts

@@ -1,12 +1,119 @@
 import {
-  AnalyticsResolvers as resolvers,
-  typedefs as typeDefs,
+  AnalyticsQueryEngine,
+  IAnalyticsStore,
+} from "@powerhousedao/analytics-engine-core";
+import {
+  AnalyticsModel,
+  typedefs,
+  AnalyticsResolvers,
 } from "@powerhousedao/analytics-engine-graphql";
-import { createSchema } from "./db.js";
-import { Knex } from "knex";
+import gql from "graphql-tag";
+import { Subgraph } from "../base/index.js";
+import { Context, SubgraphArgs } from "../index.js";
+import { GraphQLResolverMap } from "@apollo/subgraph/dist/schema-helper/resolverMap.js";
+
+export class AnalyticsSubgraph extends Subgraph {
+  analyticsStore: IAnalyticsStore;
+  analyticsModel: AnalyticsModel;
+
+  name = "analytics";
+  typeDefs = gql`
+    ${typedefs}
+  `;
+
+  resolvers = AnalyticsResolvers as GraphQLResolverMap<Context>;
+
+  constructor(args: SubgraphArgs) {
+    super(args);
+    this.analyticsStore = args.analyticsStore;
+
+    this.analyticsModel = new AnalyticsModel(
+      new AnalyticsQueryEngine(this.analyticsStore),
+    );
+
+    args.subgraphManager.setAdditionalContextFields({
+      dataSources: {
+        db: {
+          Analytics: this.analyticsModel,
+        },
+      },
+    });
+  }
+
+  async onSetup() {
+    await this.#createTables();
+  }
+
+  async #createTables() {
+    if (!(await this.operationalStore.schema.hasTable("AnalyticsDimension"))) {
+      await this.operationalStore.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();
+        },
+      );
+    }
 
-export { resolvers, typeDefs };
+    if (!(await this.operationalStore.schema.hasTable("AnalyticsSeries"))) {
+      await this.operationalStore.schema.createTable(
+        "AnalyticsSeries",
+        (table) => {
+          table.increments("id").primary();
+          table
+            .string("source")
+            .notNullable()
+            .index("analyticsseries_source_index");
+          table
+            .timestamp("start")
+            .notNullable()
+            .index("analyticsseries_start_index");
+          table.timestamp("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();
+        },
+      );
+    }
 
-export async function initialize(knex: Knex) {
-  await createSchema(knex);
+    if (
+      !(await this.operationalStore.schema.hasTable(
+        "AnalyticsSeries_AnalyticsDimension",
+      ))
+    ) {
+      await this.operationalStore.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/base/index.ts

@@ -0,0 +1,31 @@
+import { ISubgraph } from "../types";
+import { DocumentNode } from "graphql";
+import { IDocumentDriveServer } from "document-drive";
+import { SubgraphArgs } from "../types";
+import { GraphQLResolverMap } from "@apollo/subgraph/dist/schema-helper";
+import { gql } from "graphql-tag";
+import { Context } from "../types";
+import { Db } from "src/types";
+
+export class Subgraph implements ISubgraph {
+  name = "example";
+  resolvers: GraphQLResolverMap<Context> = {
+    Query: {
+      hello: () => this.name,
+    },
+  };
+  typeDefs: DocumentNode = gql`
+    type Query {
+      hello: String
+    }
+  `;
+  reactor: IDocumentDriveServer;
+  operationalStore: Db;
+  constructor(args: SubgraphArgs) {
+    this.reactor = args.reactor;
+    this.operationalStore = args.operationalStore;
+  }
+  async onSetup() {
+    // noop
+  }
+}