@powerhousedao/reactor-api 1.10.8 → 1.11.0

package/CHANGELOG.md

@@ -1,9 +1,24 @@
-## 1.10.8 (2024-12-12)
+## 1.11.0 (2024-12-16)
+
+### 🚀 Features
+
+- **reactor-api:** refactor knex and analytics store initialization ([2c19a7aa](https://github.com/powerhouse-inc/powerhouse/commit/2c19a7aa))
+
+### 🩹 Fixes
+
+- **switchboard:** subgraph manager and db instantiation ([874bdc4b](https://github.com/powerhouse-inc/powerhouse/commit/874bdc4b))
+- **reactor-api:** datasource for analytics resolvers ([b015437e](https://github.com/powerhouse-inc/powerhouse/commit/b015437e))
+- **reactor-api:** build issues ([d0182d5d](https://github.com/powerhouse-inc/powerhouse/commit/d0182d5d))
 
 ### 🧱 Updated Dependencies
 
-- Updated document-model-libs to 1.122.4
-- Updated document-drive to 1.11.4
+- Updated document-model-libs to 1.122.6
+- Updated document-drive to 1.11.6
+
+### ❤️ Thank You
+
+- acaldas @acaldas
+- Frank
 
 ## 1.2.0 (2024-10-29)
 

package/dist/index.d.ts

@@ -1,14 +1,19 @@
 import { PGlite } from '@electric-sql/pglite';
-import { Trigger, PullResponderTriggerData, DocumentDriveDocument, ListenerFilter, ListenerCallInfo, DocumentDriveLocalState, DocumentDriveAction, DocumentDriveState } from 'document-model-libs/document-drive';
-import { Operation, Document, DocumentModel, Action, OperationScope, BaseAction, State, CreateChildDocumentInput, ActionContext, ReducerOptions, Signal } from 'document-model/document';
+import * as document_model_libs_document_drive from 'document-model-libs/document-drive';
+import { Trigger, PullResponderTriggerData, DocumentDriveDocument, ListenerFilter, DocumentDriveState, DocumentDriveLocalState, ListenerCallInfo, DocumentDriveAction } from 'document-model-libs/document-drive';
+import { Operation, Document, DocumentModel, Action, OperationScope, State, BaseAction, CreateChildDocumentInput, ActionContext, ReducerOptions, Signal } from 'document-model/document';
 import { Unsubscribe } from 'nanoevents';
 import express, { Express } from 'express';
 import { Pool } from 'pg';
 import { IncomingHttpHeaders } from 'http';
+import * as graphql from 'graphql';
+import { DocumentNode } from 'graphql';
+import { Knex } from 'knex';
 import { IAnalyticsStore } from '@powerhousedao/analytics-engine-core';
 export * from '@powerhousedao/analytics-engine-core';
-import * as graphql from 'graphql';
 import { GraphQLResolverMap } from '@apollo/subgraph/dist/schema-helper';
+import { AnalyticsModel } from '@powerhousedao/analytics-engine-graphql';
+import { GraphQLResolverMap as GraphQLResolverMap$1 } from '@apollo/subgraph/dist/schema-helper/resolverMap.js';
 
 type StrandUpdateSource = {
     type: "local";
@@ -288,22 +293,6 @@ type PublicPart<T> = Pick<T, PublicKeys<T>>;
 type IBaseDocumentDriveServer = PublicPart<AbstractDocumentDriveServer>;
 type IDocumentDriveServer = IBaseDocumentDriveServer & IDefaultDrivesManager & IReadModeDriveServer;
 
-declare class ReactorRouterManager {
-    #private;
-    private readonly path;
-    private readonly app;
-    private readonly reactor;
-    private reactorRouter;
-    private contextFields;
-    private subgraphs;
-    constructor(path: string, app: express.Express, reactor: IDocumentDriveServer);
-    init(): Promise<void>;
-    updateRouter(): Promise<void>;
-    registerSubgraph(subgraph: Subgraph): Promise<void>;
-    getAdditionalContextFields: () => Record<string, any>;
-    setAdditionalContextFields(fields: Record<string, any>): void;
-}
-
 type ProcessorUpdate<D extends Document = Document, S extends OperationScope = OperationScope> = InternalTransmitterUpdate<D, S>;
 declare abstract class Processor<D extends Document = Document, S extends OperationScope = OperationScope> implements IProcessor<D, S> {
     protected reactor: IDocumentDriveServer;
@@ -321,32 +310,128 @@ declare class BaseProcessor extends Processor {
 type ProcessorClass = typeof BaseProcessor;
 declare function isProcessorClass(candidate: unknown): candidate is ProcessorClass;
 
+type Context = {
+    driveServer: IDocumentDriveServer;
+    driveId?: string;
+    headers: IncomingHttpHeaders;
+    db: unknown;
+};
+type ISubgraph = {
+    name: string;
+    resolvers: Record<string, any>;
+    typeDefs: DocumentNode;
+    reactor: IDocumentDriveServer;
+    operationalStore: Db;
+    onSetup?: () => Promise<void>;
+};
+type SubgraphArgs = {
+    reactor: IDocumentDriveServer;
+    operationalStore: Db;
+    analyticsStore: IAnalyticsStore;
+    subgraphManager: SubgraphManager;
+};
+
+declare class Subgraph implements ISubgraph {
+    name: string;
+    resolvers: GraphQLResolverMap<Context>;
+    typeDefs: DocumentNode;
+    reactor: IDocumentDriveServer;
+    operationalStore: Db;
+    constructor(args: SubgraphArgs);
+    onSetup(): Promise<void>;
+}
+
+declare class AnalyticsSubgraph extends Subgraph {
+    #private;
+    analyticsStore: IAnalyticsStore;
+    analyticsModel: AnalyticsModel;
+    name: string;
+    typeDefs: graphql.DocumentNode;
+    resolvers: GraphQLResolverMap$1<Context>;
+    constructor(args: SubgraphArgs);
+    onSetup(): Promise<void>;
+}
+
+type index$2_AnalyticsSubgraph = AnalyticsSubgraph;
+declare const index$2_AnalyticsSubgraph: typeof AnalyticsSubgraph;
+declare namespace index$2 {
+  export { index$2_AnalyticsSubgraph as AnalyticsSubgraph };
+}
+
+declare class DriveSubgraph extends Subgraph {
+    #private;
+    name: string;
+    typeDefs: graphql.DocumentNode;
+    onSetup(): Promise<void>;
+}
+
+type index$1_DriveSubgraph = DriveSubgraph;
+declare const index$1_DriveSubgraph: typeof DriveSubgraph;
+declare namespace index$1 {
+  export { index$1_DriveSubgraph as DriveSubgraph };
+}
+
+declare class SystemSubgraph extends Subgraph {
+    name: string;
+    typeDefs: graphql.DocumentNode;
+    resolvers: {
+        Query: {
+            drives: () => Promise<string[]>;
+        };
+        Mutation: {
+            addDrive: (parent: unknown, args: DriveInput) => Promise<document_model_libs_document_drive.DocumentDriveState>;
+        };
+    };
+}
+
+type index_SystemSubgraph = SystemSubgraph;
+declare const index_SystemSubgraph: typeof SystemSubgraph;
+declare namespace index {
+  export { index_SystemSubgraph as SystemSubgraph };
+}
+
+type SubgraphClass = typeof Subgraph;
+declare function isSubgraphClass(candidate: unknown): candidate is SubgraphClass;
+
+declare class SubgraphManager {
+    #private;
+    private readonly path;
+    private readonly app;
+    private readonly reactor;
+    private readonly operationalStore;
+    private readonly analyticsStore;
+    private reactorRouter;
+    private contextFields;
+    private subgraphs;
+    constructor(path: string, app: express.Express, reactor: IDocumentDriveServer, operationalStore: Db, analyticsStore: IAnalyticsStore);
+    init(): Promise<void>;
+    updateRouter(): Promise<void>;
+    registerSubgraph(subgraph: SubgraphClass): Promise<void>;
+    getAdditionalContextFields: () => Record<string, any>;
+    setAdditionalContextFields(fields: Record<string, any>): void;
+}
+
+type Db = Knex;
+declare function getDbClient(connectionString?: string | undefined): Db;
+
+declare abstract class AnalyticsProcessor<D extends Document = Document, S extends OperationScope = OperationScope> extends Processor<D, S> {
+    protected analyticsStore: IAnalyticsStore;
+    constructor(args: ProcessorSetupArgs, options?: ProcessorOptions);
+}
+
 type IProcessorManager = {
     registerProcessor(module: IProcessor | ProcessorClass): Promise<IProcessor>;
 };
 type API = {
     app: Express;
-    reactorRouterManager: ReactorRouterManager;
+    subgraphManager: SubgraphManager;
     processorManager: IProcessorManager;
 };
-interface Context {
-    headers: IncomingHttpHeaders;
-    driveId: string | undefined;
-    driveServer: IDocumentDriveServer;
-}
-type Subgraph = {
-    name: string;
-    resolvers: any;
-    typeDefs: string;
-    options?: Omit<Listener, "driveId">;
-    transmit?: (strands: InternalTransmitterUpdate[]) => Promise<ListenerRevision[]>;
-};
 type ProcessorType = "analytics" | "operational";
 type ProcessorSetupArgs = {
     reactor: IDocumentDriveServer;
-    dataSources: {
-        analyticsStore: IAnalyticsStore;
-    };
+    operationalStore: Db;
+    analyticsStore: IAnalyticsStore;
 };
 type IProcessor<D extends Document = Document, S extends OperationScope = OperationScope> = IReceiver<D, S> & {
     onSetup?: (args: ProcessorSetupArgs) => void;
@@ -364,13 +449,17 @@ type Options = {
 };
 declare function startAPI(reactor: IDocumentDriveServer, options: Options): Promise<API>;
 
-declare const createSchema: (documentDriveServer: IDocumentDriveServer, resolvers: GraphQLResolverMap<Context>, typeDefs: string) => graphql.GraphQLSchema;
-declare const getDocumentModelTypeDefs: (documentDriveServer: IDocumentDriveServer, typeDefs: string) => graphql.DocumentNode;
+declare const createSchema: (documentDriveServer: IDocumentDriveServer, resolvers: GraphQLResolverMap<Context>, typeDefs: DocumentNode) => graphql.GraphQLSchema;
+declare const getDocumentModelTypeDefs: (documentDriveServer: IDocumentDriveServer, typeDefs: DocumentNode) => DocumentNode;
 
-declare abstract class AnalyticsProcessor<D extends Document = Document, S extends OperationScope = OperationScope> extends Processor<D, S> {
-    protected analyticsStore: IAnalyticsStore;
-    constructor(args: ProcessorSetupArgs, options?: ProcessorOptions);
-    onSetup(args: ProcessorSetupArgs): void;
+declare class ProcessorManager implements IProcessorManager {
+    #private;
+    private operationalStore;
+    private analyticsStore;
+    private reactor;
+    private processors;
+    constructor(driveServer: IDocumentDriveServer, operationalStore: Db, analyticsStore: IAnalyticsStore);
+    registerProcessor(module: IProcessor | ProcessorClass): Promise<IProcessor>;
 }
 
-export { type API, AnalyticsProcessor, BaseProcessor, type Context, type IProcessor, type IProcessorManager, Processor, type ProcessorClass, type ProcessorOptions, type ProcessorSetupArgs, type ProcessorType, type ProcessorUpdate, ReactorRouterManager, type Subgraph, createSchema, getDocumentModelTypeDefs, isProcessorClass, startAPI };
+export { type API, AnalyticsProcessor, BaseProcessor, type Context, type Db, type IProcessor, type IProcessorManager, type ISubgraph, Processor, type ProcessorClass, ProcessorManager, type ProcessorOptions, type ProcessorSetupArgs, type ProcessorType, type ProcessorUpdate, Subgraph, type SubgraphArgs, type SubgraphClass, SubgraphManager, index$2 as analyticsSubgraph, createSchema, index$1 as driveSubgraph, getDbClient, getDocumentModelTypeDefs, isProcessorClass, isSubgraphClass, startAPI, index as systemSubgraph };