@powerhousedao/reactor-api 1.20.2 → 1.21.0

package/CHANGELOG.md

@@ -1,23 +1,3 @@
-## 1.20.2 (2025-02-10)
-
-### 🚀 Features
-
-- **design-system:** add danger zone settings page ([572345bc](https://github.com/powerhouse-inc/powerhouse/commit/572345bc))
-
-### 🩹 Fixes
-
-- **reactor-api:** sanitize document model name before using it as __typename ([adcca457](https://github.com/powerhouse-inc/powerhouse/commit/adcca457))
-
-### 🧱 Updated Dependencies
-
-- Updated document-model-libs to 1.131.2
-- Updated document-drive to 1.17.2
-
-### ❤️ Thank You
-
-- ryanwolhuter @ryanwolhuter
-- Wouter Kampmann
-
 ## 1.2.0 (2024-10-29)
 
 ### 🚀 Features

package/dist/index.d.ts

@@ -1,7 +1,7 @@
 import { PGlite } from '@electric-sql/pglite';
 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 { DocumentDriveDocument, ListenerFilter, Trigger, PullResponderTriggerData, DocumentDriveState, DocumentDriveLocalState, ListenerCallInfo, DocumentDriveAction } from 'document-model-libs/document-drive';
+import { Operation, Document, DocumentModel, Action, OperationScope, State, BaseAction, ActionContext, ReducerOptions, Signal } from 'document-model/document';
 import { Unsubscribe } from 'nanoevents';
 import express, { Express } from 'express';
 import { Pool } from 'pg';
@@ -15,21 +15,6 @@ import { GraphQLResolverMap as GraphQLResolverMap$1 } from '@apollo/subgraph/dis
 import { AnalyticsModel } from '@powerhousedao/analytics-engine-graphql';
 import { GraphQLResolverMap } from '@apollo/subgraph/dist/schema-helper/resolverMap.js';
 
-type StrandUpdateSource = {
-    type: "local";
-} | {
-    type: "trigger";
-    trigger: Trigger;
-};
-interface ITransmitter {
-    transmit?(strands: StrandUpdate[], source: StrandUpdateSource): Promise<ListenerRevision[]>;
-    disconnect?(): Promise<void>;
-}
-type PullResponderTrigger = Omit<Trigger, "data" | "type"> & {
-    data: PullResponderTriggerData;
-    type: "PullResponder";
-};
-
 declare class DocumentModelNotFoundError extends Error {
     id: string;
     constructor(id: string, cause?: unknown);
@@ -93,6 +78,28 @@ interface IReadModeDriveService {
     deleteReadDrive(id: string): Promise<ReadDriveNotFoundError | undefined>;
 }
 
+interface IDefaultDrivesManager {
+    initializeDefaultRemoteDrives(): Promise<void>;
+    getDefaultRemoteDrives(): Map<string, DefaultRemoteDriveInfo>;
+    setDefaultDriveAccessLevel(url: string, level: RemoteDriveAccessLevel): Promise<void>;
+    setAllDefaultDrivesAccessLevel(level: RemoteDriveAccessLevel): Promise<void>;
+}
+
+type StrandUpdateSource = {
+    type: "local";
+} | {
+    type: "trigger";
+    trigger: Trigger;
+};
+interface ITransmitter {
+    transmit?(strands: StrandUpdate[], source: StrandUpdateSource): Promise<ListenerRevision[]>;
+    disconnect?(): Promise<void>;
+}
+type PullResponderTrigger = Omit<Trigger, "data" | "type"> & {
+    data: PullResponderTriggerData;
+    type: "PullResponder";
+};
+
 interface IReceiver<T extends Document = Document, S extends OperationScope = OperationScope> {
     onStrands: (strands: InternalTransmitterUpdate<T, S>[]) => Promise<void>;
     onDisconnect: () => Promise<void>;
@@ -113,13 +120,6 @@ interface IInternalTransmitter extends ITransmitter {
     setReceiver(receiver: IReceiver): void;
 }
 
-interface IDefaultDrivesManager {
-    initializeDefaultRemoteDrives(): Promise<void>;
-    getDefaultRemoteDrives(): Map<string, DefaultRemoteDriveInfo>;
-    setDefaultDriveAccessLevel(url: string, level: RemoteDriveAccessLevel): Promise<void>;
-    setAllDefaultDrivesAccessLevel(level: RemoteDriveAccessLevel): Promise<void>;
-}
-
 type DriveInput = State<Omit<DocumentDriveState, "__typename" | "id" | "nodes"> & {
     id?: string;
 }, DocumentDriveLocalState>;
@@ -130,7 +130,6 @@ type RemoteDriveOptions = DocumentDriveLocalState & {
     expectedDriveInfo?: DriveInfo;
     accessLevel?: RemoteDriveAccessLevel;
 };
-type CreateDocumentInput = CreateChildDocumentInput;
 type SignalResult = {
     signal: Signal;
     result: unknown;
@@ -161,6 +160,7 @@ type Listener = {
     system: boolean;
     filter: ListenerFilter;
     callInfo?: ListenerCallInfo;
+    transmitter?: ITransmitter;
 };
 type ListenerRevision = {
     driveId: string;
@@ -232,65 +232,52 @@ type GetStrandsOptions = {
     since?: string;
     fromRevision?: number;
 };
-declare abstract class AbstractDocumentDriveServer {
-    /** Public methods **/
-    abstract initialize(): Promise<Error[] | null>;
-    abstract setDocumentModels(models: DocumentModel[]): void;
-    abstract getDrives(): Promise<string[]>;
-    abstract addDrive(drive: DriveInput): Promise<DocumentDriveDocument>;
-    abstract addRemoteDrive(url: string, options: RemoteDriveOptions): Promise<DocumentDriveDocument>;
-    abstract deleteDrive(id: string): Promise<void>;
-    abstract getDrive(id: string, options?: GetDocumentOptions): Promise<DocumentDriveDocument>;
-    abstract getDriveBySlug(slug: string): Promise<DocumentDriveDocument>;
-    abstract getDocuments(drive: string): Promise<string[]>;
-    abstract getDocument(drive: string, id: string, options?: GetDocumentOptions): Promise<Document>;
-    abstract addOperation(drive: string, id: string, operation: Operation, options?: AddOperationOptions): Promise<IOperationResult>;
-    abstract addOperations(drive: string, id: string, operations: Operation[], options?: AddOperationOptions): Promise<IOperationResult>;
-    abstract queueOperation(drive: string, id: string, operation: Operation, options?: AddOperationOptions): Promise<IOperationResult>;
-    abstract queueOperations(drive: string, id: string, operations: Operation[], options?: AddOperationOptions): Promise<IOperationResult>;
-    abstract queueAction(drive: string, id: string, action: Action, options?: AddOperationOptions): Promise<IOperationResult>;
-    abstract queueActions(drive: string, id: string, actions: Action[], options?: AddOperationOptions): Promise<IOperationResult>;
-    abstract addDriveOperation(drive: string, operation: Operation<DocumentDriveAction | BaseAction>, options?: AddOperationOptions): Promise<IOperationResult<DocumentDriveDocument>>;
-    abstract addDriveOperations(drive: string, operations: Operation<DocumentDriveAction | BaseAction>[], options?: AddOperationOptions): Promise<IOperationResult<DocumentDriveDocument>>;
-    abstract queueDriveOperation(drive: string, operation: Operation<DocumentDriveAction | BaseAction>, options?: AddOperationOptions): Promise<IOperationResult<DocumentDriveDocument>>;
-    abstract queueDriveOperations(drive: string, operations: Operation<DocumentDriveAction | BaseAction>[], options?: AddOperationOptions): Promise<IOperationResult<DocumentDriveDocument>>;
-    abstract queueDriveAction(drive: string, action: DocumentDriveAction | BaseAction, options?: AddOperationOptions): Promise<IOperationResult<DocumentDriveDocument>>;
-    abstract queueDriveActions(drive: string, actions: Array<DocumentDriveAction | BaseAction>, options?: AddOperationOptions): Promise<IOperationResult<DocumentDriveDocument>>;
-    abstract addAction(drive: string, id: string, action: Action, options?: AddOperationOptions): Promise<IOperationResult>;
-    abstract addActions(drive: string, id: string, actions: Action[], options?: AddOperationOptions): Promise<IOperationResult>;
-    abstract addDriveAction(drive: string, action: DocumentDriveAction | BaseAction, options?: AddOperationOptions): Promise<IOperationResult<DocumentDriveDocument>>;
-    abstract addDriveActions(drive: string, actions: (DocumentDriveAction | BaseAction)[], options?: AddOperationOptions): Promise<IOperationResult<DocumentDriveDocument>>;
-    abstract getSyncStatus(syncUnitId: string): SyncStatus | SynchronizationUnitNotFoundError;
-    abstract addInternalListener(driveId: string, receiver: IReceiver, options: {
+interface IBaseDocumentDriveServer {
+    initialize(): Promise<Error[] | null>;
+    setDocumentModels(models: DocumentModel[]): void;
+    getDrives(): Promise<string[]>;
+    addDrive(input: DriveInput): Promise<DocumentDriveDocument>;
+    addRemoteDrive(url: string, options: RemoteDriveOptions): Promise<DocumentDriveDocument>;
+    deleteDrive(driveId: string): Promise<void>;
+    getDrive(driveId: string, options?: GetDocumentOptions): Promise<DocumentDriveDocument>;
+    getDriveBySlug(slug: string): Promise<DocumentDriveDocument>;
+    getDocuments(driveId: string): Promise<string[]>;
+    getDocument(driveId: string, documentId: string, options?: GetDocumentOptions): Promise<Document>;
+    addOperation(driveId: string, documentId: string, operation: Operation, options?: AddOperationOptions): Promise<IOperationResult>;
+    addOperations(driveId: string, documentId: string, operations: Operation[], options?: AddOperationOptions): Promise<IOperationResult>;
+    queueOperation(driveId: string, documentId: string, operation: Operation, options?: AddOperationOptions): Promise<IOperationResult>;
+    queueOperations(driveId: string, documentId: string, operations: Operation[], options?: AddOperationOptions): Promise<IOperationResult>;
+    queueAction(driveId: string, documentId: string, action: Action, options?: AddOperationOptions): Promise<IOperationResult>;
+    queueActions(driveId: string, documentId: string, actions: Action[], options?: AddOperationOptions): Promise<IOperationResult>;
+    addDriveOperation(driveId: string, operation: Operation<DocumentDriveAction | BaseAction>, options?: AddOperationOptions): Promise<IOperationResult<DocumentDriveDocument>>;
+    addDriveOperations(driveId: string, operations: Operation<DocumentDriveAction | BaseAction>[], options?: AddOperationOptions): Promise<IOperationResult<DocumentDriveDocument>>;
+    queueDriveOperation(driveId: string, operation: Operation<DocumentDriveAction | BaseAction>, options?: AddOperationOptions): Promise<IOperationResult<DocumentDriveDocument>>;
+    queueDriveOperations(driveId: string, operations: Operation<DocumentDriveAction | BaseAction>[], options?: AddOperationOptions): Promise<IOperationResult<DocumentDriveDocument>>;
+    queueDriveAction(driveId: string, action: DocumentDriveAction | BaseAction, options?: AddOperationOptions): Promise<IOperationResult<DocumentDriveDocument>>;
+    queueDriveActions(driveId: string, actions: Array<DocumentDriveAction | BaseAction>, options?: AddOperationOptions): Promise<IOperationResult<DocumentDriveDocument>>;
+    addAction(driveId: string, documentId: string, action: Action, options?: AddOperationOptions): Promise<IOperationResult>;
+    addActions(driveId: string, documentId: string, actions: Action[], options?: AddOperationOptions): Promise<IOperationResult>;
+    addDriveAction(driveId: string, action: DocumentDriveAction | BaseAction, options?: AddOperationOptions): Promise<IOperationResult<DocumentDriveDocument>>;
+    addDriveActions(driveId: string, actions: (DocumentDriveAction | BaseAction)[], options?: AddOperationOptions): Promise<IOperationResult<DocumentDriveDocument>>;
+    getSyncStatus(syncUnitId: string): SyncStatus | SynchronizationUnitNotFoundError;
+    addInternalListener(driveId: string, receiver: IReceiver, options: {
         listenerId: string;
         label: string;
         block: boolean;
         filter: ListenerFilter;
     }): Promise<IInternalTransmitter>;
     /** Synchronization methods */
-    abstract getSynchronizationUnits(driveId: string, documentId?: string[], scope?: string[], branch?: string[], documentType?: string[], loadedDrive?: DocumentDriveDocument): Promise<SynchronizationUnit[]>;
-    abstract getSynchronizationUnit(driveId: string, syncId: string, loadedDrive?: DocumentDriveDocument): Promise<SynchronizationUnit | undefined>;
-    abstract getSynchronizationUnitsIds(driveId: string, documentId?: string[], scope?: string[], branch?: string[], documentType?: string[]): Promise<SynchronizationUnitQuery[]>;
-    abstract getOperationData(driveId: string, syncId: string, filter: GetStrandsOptions, loadedDrive?: DocumentDriveDocument): Promise<OperationUpdate[]>;
+    getSynchronizationUnits(driveId: string, documentId?: string[], scope?: string[], branch?: string[], documentType?: string[], loadedDrive?: DocumentDriveDocument): Promise<SynchronizationUnit[]>;
+    getSynchronizationUnit(driveId: string, syncId: string, loadedDrive?: DocumentDriveDocument): Promise<SynchronizationUnit | undefined>;
+    getSynchronizationUnitsIds(driveId: string, documentId?: string[], scope?: string[], branch?: string[], documentType?: string[]): Promise<SynchronizationUnitQuery[]>;
+    getOperationData(driveId: string, syncId: string, filter: GetStrandsOptions, loadedDrive?: DocumentDriveDocument): Promise<OperationUpdate[]>;
     /** Internal methods **/
-    protected abstract createDocument(drive: string, document: CreateDocumentInput): Promise<Document>;
-    protected abstract deleteDocument(drive: string, id: string): Promise<void>;
-    protected abstract getDocumentModel(documentType: string): DocumentModel;
-    abstract getDocumentModels(): DocumentModel[];
-    /** Event methods **/
-    protected abstract emit<K extends keyof DriveEvents>(event: K, ...args: Parameters<DriveEvents[K]>): void;
-    abstract on<K extends keyof DriveEvents>(event: K, cb: DriveEvents[K]): Unsubscribe;
-    abstract getTransmitter(driveId: string, listenerId: string): Promise<ITransmitter | undefined>;
-    abstract clearStorage(): Promise<void>;
-    abstract registerPullResponderTrigger(id: string, url: string, options: Pick<RemoteDriveOptions, "pullFilter" | "pullInterval">): Promise<PullResponderTrigger>;
+    getDocumentModels(): DocumentModel[];
+    getTransmitter(driveId: string, listenerId: string): Promise<ITransmitter | undefined>;
+    clearStorage(): Promise<void>;
+    registerPullResponderTrigger(id: string, url: string, options: Pick<RemoteDriveOptions, "pullFilter" | "pullInterval">): Promise<PullResponderTrigger>;
+    on<K extends keyof DriveEvents>(event: K, cb: DriveEvents[K]): Unsubscribe;
 }
-type PublicKeys<T> = {
-    [K in keyof T]: T extends {
-        [P in K]: T[K];
-    } ? K : never;
-}[keyof T];
-type PublicPart<T> = Pick<T, PublicKeys<T>>;
-type IBaseDocumentDriveServer = PublicPart<AbstractDocumentDriveServer>;
 type IDocumentDriveServer = IBaseDocumentDriveServer & IDefaultDrivesManager & IReadModeDriveServer;
 
 type ProcessorUpdate<D extends Document = Document, S extends OperationScope = OperationScope> = InternalTransmitterUpdate<D, S>;

package/dist/index.js

@@ -25926,6 +25926,55 @@ index.documentHelpers;
 
 // ../document-drive/src/server/listener/transmitter/switchboard-push.ts
 __toESM(require_lib4());
+
+// src/sync/utils.ts
+var processPushUpdate = async (reactor, strand) => {
+  const result = await (strand.documentId !== undefined ? reactor.queueOperations(
+    strand.driveId,
+    strand.documentId,
+    strand.operations
+  ) : reactor.queueDriveOperations(
+    strand.driveId,
+    strand.operations
+  ));
+  const scopeOperations = result.document?.operations[strand.scope] ?? [];
+  if (scopeOperations.length === 0) {
+    return {
+      revision: -1,
+      branch: strand.branch,
+      documentId: strand.documentId ?? "",
+      driveId: strand.driveId,
+      scope: strand.scope,
+      status: result.status
+    };
+  }
+  const revision = scopeOperations.slice().pop()?.index ?? -1;
+  return {
+    revision,
+    branch: strand.branch,
+    documentId: strand.documentId ?? "",
+    driveId: strand.driveId,
+    scope: strand.scope,
+    status: result.status,
+    error: result.error?.message || undefined
+  };
+};
+var processAcknowledge = async (reactor, driveId, listenerId, revisions) => {
+  const transmitter = await reactor.getTransmitter(
+    driveId,
+    listenerId
+  );
+  return transmitter.processAcknowledge(driveId, listenerId, revisions);
+};
+var processGetStrands = async (reactor, driveId, listenerId, since) => {
+  const transmitter = await reactor.getTransmitter(
+    driveId,
+    listenerId
+  );
+  return transmitter.getStrands({ since });
+};
+
+// src/subgraphs/drive/index.ts
 var DriveSubgraph = class extends Subgraph {
   name = "d/:drive";
   typeDefs = gql`
@@ -26159,49 +26208,26 @@ var DriveSubgraph = class extends Subgraph {
         }
         return listener;
       },
-      pushUpdates: async (_, { strands }, ctx) => {
+      pushUpdates: async (_, { strands: strandsGql }, ctx) => {
         if (!ctx.driveId) throw new Error("Drive ID is required");
-        const listenerRevisions = await Promise.all(
-          strands.map(async (s2) => {
-            const operations = s2.operations.map((o) => ({
-              ...o,
-              input: JSON.parse(o.input),
-              skip: o.skip ?? 0,
-              scope: s2.scope,
+        const strands = strandsGql.map((strandGql) => {
+          return {
+            operations: strandGql.operations.map((op) => ({
+              ...op,
+              input: JSON.parse(op.input),
+              skip: op.skip ?? 0,
+              scope: strandGql.scope,
               branch: "main"
-            })) ?? [];
-            const result = await (s2.documentId !== undefined ? this.reactor.queueOperations(
-              s2.driveId,
-              s2.documentId,
-              operations
-            ) : this.reactor.queueDriveOperations(
-              s2.driveId,
-              operations
-            ));
-            const scopeOperations = result.document?.operations[s2.scope] ?? [];
-            if (scopeOperations.length === 0) {
-              return {
-                revision: -1,
-                branch: s2.branch,
-                documentId: s2.documentId ?? "",
-                driveId: s2.driveId,
-                scope: s2.scope,
-                status: result.status
-              };
-            }
-            const revision = scopeOperations.slice().pop()?.index ?? -1;
-            return {
-              revision,
-              branch: s2.branch,
-              documentId: s2.documentId ?? "",
-              driveId: s2.driveId,
-              scope: s2.scope,
-              status: result.status,
-              error: result.error?.message || undefined
-            };
-          })
+            })),
+            documentId: strandGql.documentId,
+            driveId: strandGql.driveId,
+            scope: strandGql.scope,
+            branch: strandGql.branch
+          };
+        });
+        return await Promise.all(
+          strands.map((strand) => processPushUpdate(this.reactor, strand))
         );
-        return listenerRevisions;
       },
       acknowledge: async (_, {
         listenerId,
@@ -26217,16 +26243,12 @@ var DriveSubgraph = class extends Subgraph {
           revision: e.revision,
           status: e.status
         }));
-        const transmitter = await this.reactor.getTransmitter(
+        return await processAcknowledge(
+          this.reactor,
           ctx.driveId,
-          listenerId
-        );
-        const result = await transmitter.processAcknowledge(
-          ctx.driveId ?? "1",
           listenerId,
           validEntries
         );
-        return result;
       }
     },
     System: {},
@@ -26236,26 +26258,27 @@ var DriveSubgraph = class extends Subgraph {
         since
       }, ctx) => {
         if (!ctx.driveId) throw new Error("Drive ID is required");
-        const listener = await this.reactor.getTransmitter(
+        const strands = await processGetStrands(
+          this.reactor,
           ctx.driveId,
-          listenerId
+          listenerId,
+          since
         );
-        const strands = await listener.getStrands({ since });
-        return strands.map((e) => ({
-          driveId: e.driveId,
-          documentId: e.documentId,
-          scope: e.scope,
-          branch: e.branch,
-          operations: e.operations.map((o) => ({
-            index: o.index,
-            skip: o.skip,
-            name: o.type,
-            input: JSON.stringify(o.input),
-            hash: o.hash,
-            timestamp: o.timestamp,
-            type: o.type,
-            context: o.context,
-            id: o.id
+        return strands.map((update) => ({
+          driveId: update.driveId,
+          documentId: update.documentId,
+          scope: update.scope,
+          branch: update.branch,
+          operations: update.operations.map((op) => ({
+            index: op.index,
+            skip: op.skip,
+            name: op.type,
+            input: JSON.stringify(op.input),
+            hash: op.hash,
+            timestamp: op.timestamp,
+            type: op.type,
+            context: op.context,
+            id: op.id
           }))
         }));
       }