@powerhousedao/reactor-api 1.9.4 → 1.10.0

package/CHANGELOG.md

@@ -1,9 +1,24 @@
-## 1.9.4 (2024-12-10)
+## 1.10.0 (2024-12-11)
+
+### 🚀 Features
+
+- **reactor-api:** Added support for processors ([#655](https://github.com/powerhouse-inc/powerhouse/pull/655))
+
+### 🩹 Fixes
+
+- **monorepo:** remove nx cloud id ([45da8784](https://github.com/powerhouse-inc/powerhouse/commit/45da8784))
 
 ### 🧱 Updated Dependencies
 
-- Updated document-model-libs to 1.120.3
-- Updated document-drive to 1.8.4
+- Updated document-model-libs to 1.121.0
+- Updated document-drive to 1.9.0
+- Updated document-model to 2.11.0
+- Updated @powerhousedao/scalars to 1.13.0
+
+### ❤️ Thank You
+
+- acaldas
+- ryanwolhuter @ryanwolhuter
 
 ## 1.2.0 (2024-10-29)
 

package/dist/index.d.ts

@@ -1,11 +1,11 @@
 import { PGlite } from '@electric-sql/pglite';
-import { Trigger, PullResponderTriggerData, DocumentDriveDocument, ListenerFilter, DocumentDriveLocalState, ListenerCallInfo, DocumentDriveAction, DocumentDriveState } from 'document-model-libs/document-drive';
-import { Document, OperationScope, Operation, DocumentModel, Action, ActionContext, BaseAction, State, CreateChildDocumentInput, ReducerOptions, Signal } from 'document-model/document';
+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 { Unsubscribe } from 'nanoevents';
 import express, { Express } from 'express';
-import pg from 'pg';
-import { PgDatabase } from 'drizzle-orm/pg-core';
+import { Pool } from 'pg';
 import { IncomingHttpHeaders } from 'http';
+import { IAnalyticsStore } from '@powerhousedao/analytics-engine-core';
 import * as graphql from 'graphql';
 import { GraphQLResolverMap } from '@apollo/subgraph/dist/schema-helper';
 
@@ -24,22 +24,6 @@ type PullResponderTrigger = Omit<Trigger, "data" | "type"> & {
     type: "PullResponder";
 };
 
-interface IReceiver {
-    transmit: (strands: InternalTransmitterUpdate[]) => Promise<void>;
-    disconnect: () => Promise<void>;
-}
-type InternalTransmitterUpdate<T extends Document = Document, S extends OperationScope = OperationScope> = {
-    driveId: string;
-    documentId: string;
-    scope: S;
-    branch: string;
-    operations: OperationUpdate[];
-    state: T["state"][S];
-};
-interface IInternalTransmitter extends ITransmitter {
-    setReceiver(receiver: IReceiver): void;
-}
-
 declare class DocumentModelNotFoundError extends Error {
     id: string;
     constructor(id: string, cause?: unknown);
@@ -103,6 +87,26 @@ interface IReadModeDriveService {
     deleteReadDrive(id: string): Promise<ReadDriveNotFoundError | undefined>;
 }
 
+interface IReceiver<T extends Document = Document, S extends OperationScope = OperationScope> {
+    onStrands: (strands: InternalTransmitterUpdate<T, S>[]) => Promise<void>;
+    onDisconnect: () => Promise<void>;
+}
+type InternalOperationUpdate<D extends Document = Document, S extends OperationScope = OperationScope> = Omit<Operation<InferDocumentOperation<D>>, "scope"> & {
+    state: D["state"][S];
+    previousState: D["state"][S];
+};
+type InternalTransmitterUpdate<D extends Document = Document, S extends OperationScope = OperationScope> = {
+    driveId: string;
+    documentId: string;
+    scope: S;
+    branch: string;
+    operations: InternalOperationUpdate<D, S>[];
+    state: D["state"][S];
+};
+interface IInternalTransmitter extends ITransmitter {
+    setReceiver(receiver: IReceiver): void;
+}
+
 interface IDefaultDrivesManager {
     initializeDefaultRemoteDrives(): Promise<void>;
     getDefaultRemoteDrives(): Map<string, DefaultRemoteDriveInfo>;
@@ -283,67 +287,89 @@ type PublicPart<T> = Pick<T, PublicKeys<T>>;
 type IBaseDocumentDriveServer = PublicPart<AbstractDocumentDriveServer>;
 type IDocumentDriveServer = IBaseDocumentDriveServer & IDefaultDrivesManager & IReadModeDriveServer;
 
-type InternalListenerModule = {
-    name: string;
-    options: Omit<Listener, "driveId">;
-    transmit: (strands: InternalTransmitterUpdate[]) => Promise<void>;
-};
-declare class InternalListenerManager {
+declare class ReactorRouterManager {
     #private;
-    private driveServer;
-    private modules;
-    constructor(driveServer: IDocumentDriveServer);
+    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>;
-    registerInternalListener(module: InternalListenerModule): 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;
+    protected processorOptions: ProcessorOptions;
+    constructor(args: ProcessorSetupArgs, options?: ProcessorOptions);
+    onSetup(args: ProcessorSetupArgs): void;
+    abstract onStrands(strands: ProcessorUpdate<D, S>[]): Promise<void>;
+    abstract onDisconnect(): Promise<void>;
+    getOptions(): ProcessorOptions;
+}
+declare class BaseProcessor extends Processor {
+    onStrands(strands: ProcessorUpdate[]): Promise<void>;
+    onDisconnect(): Promise<void>;
+}
+type ProcessorClass = typeof BaseProcessor;
+declare function isProcessorClass(candidate: unknown): candidate is ProcessorClass;
+
+type IProcessorManager = {
+    registerProcessor(module: IProcessor | ProcessorClass): Promise<IProcessor>;
+};
+type API = {
+    app: Express;
+    reactorRouterManager: ReactorRouterManager;
+    processorManager: IProcessorManager;
+};
 interface Context {
     headers: IncomingHttpHeaders;
     driveId: string | undefined;
     driveServer: IDocumentDriveServer;
-    db: PgDatabase<any, any, any>;
 }
-type Processor = {
+type Subgraph = {
     name: string;
     resolvers: any;
     typeDefs: string;
     options?: Omit<Listener, "driveId">;
-    transmit?: (strands: InternalTransmitterUpdate[]) => Promise<void>;
+    transmit?: (strands: InternalTransmitterUpdate[]) => Promise<ListenerRevision[]>;
+};
+type ProcessorType = "analytics" | "operational";
+type ProcessorSetupArgs = {
+    reactor: IDocumentDriveServer;
+    dataSources: {
+        analyticsStore: IAnalyticsStore;
+    };
+};
+type IProcessor<D extends Document = Document, S extends OperationScope = OperationScope> = IReceiver<D, S> & {
+    onSetup?: (args: ProcessorSetupArgs) => void;
+    getOptions: () => ProcessorOptions;
+};
+type ProcessorOptions = Omit<Listener, "driveId"> & {
+    label: string;
 };
-
-declare const Pool$1: typeof pg.Pool;
-declare class ReactorRouterManager {
-    #private;
-    private readonly path;
-    private readonly app;
-    private readonly driveServer;
-    private readonly client;
-    private listenerManager;
-    private database;
-    private reactorRouter;
-    private contextFields;
-    private registry;
-    constructor(path: string, app: express.Express, driveServer: IDocumentDriveServer, client?: PGlite | typeof Pool$1, listenerManager?: InternalListenerManager);
-    init(): Promise<void>;
-    updateRouter(): Promise<void>;
-    registerProcessor(processor: Processor): Promise<void>;
-    getAdditionalContextFields: () => Record<string, any>;
-    setAdditionalContextFields(fields: Record<string, any>): void;
-}
-
-declare const Pool: typeof pg.Pool;
 
 type Options = {
     express?: Express;
     port?: number;
+    dbConnection: string | undefined;
     client?: PGlite | typeof Pool | undefined;
 };
-declare function startAPI(reactor: IDocumentDriveServer, options: Options): Promise<{
-    app: express.Express;
-    reactorRouterManager: ReactorRouterManager;
-}>;
+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;
 
-export { ReactorRouterManager, createSchema, getDocumentModelTypeDefs, startAPI };
+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;
+}
+
+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 };