document-drive 1.0.0-websockets → 1.0.0

package/src/server/listener/transmitter/pull-responder.ts

@@ -1,375 +1,409 @@
-import { ListenerFilter, Trigger } from 'document-model-libs/document-drive';
-import { OperationScope } from 'document-model/document';
-import { PULL_DRIVE_INTERVAL } from '../..';
-import { generateUUID } from '../../../utils';
-import { gql, requestGraphql } from '../../../utils/graphql';
-import { logger as defaultLogger } from '../../../utils/logger';
-import { OperationError } from '../../error';
+import { ListenerFilter, Trigger } from "document-model-libs/document-drive";
+import { Operation, OperationScope } from "document-model/document";
+import { PULL_DRIVE_INTERVAL } from "../..";
+import { generateUUID } from "../../../utils";
+import { gql, requestGraphql } from "../../../utils/graphql";
+import { logger as defaultLogger } from "../../../utils/logger";
+import { OperationError } from "../../error";
 import {
-    BaseDocumentDriveServer,
-    IOperationResult,
-    Listener,
-    ListenerRevision,
-    ListenerRevisionWithError,
-    OperationUpdate,
-    RemoteDriveOptions,
-    StrandUpdate
-} from '../../types';
-import { ListenerManager } from '../manager';
-import { ITriggerTransmitter, PullResponderTrigger } from './types';
-
-export type OperationUpdateGraphQL = Omit<OperationUpdate, 'input'> & {
-    input: string;
+  GetStrandsOptions,
+  IBaseDocumentDriveServer,
+  IOperationResult,
+  Listener,
+  ListenerRevision,
+  ListenerRevisionWithError,
+  OperationUpdate,
+  RemoteDriveOptions,
+  StrandUpdate,
+} from "../../types";
+import { ListenerManager } from "../manager";
+import {
+  ITransmitter,
+  PullResponderTrigger,
+  StrandUpdateSource,
+} from "./types";
+
+export type OperationUpdateGraphQL = Omit<OperationUpdate, "input"> & {
+  input: string;
 };
 
 export type PullStrandsGraphQL = {
-    system: {
-        sync: {
-            strands: StrandUpdateGraphQL[];
-        };
+  system: {
+    sync: {
+      strands: StrandUpdateGraphQL[];
     };
+  };
 };
 
 export type CancelPullLoop = () => void;
 
-export type StrandUpdateGraphQL = Omit<StrandUpdate, 'operations'> & {
-    operations: OperationUpdateGraphQL[];
+export type StrandUpdateGraphQL = Omit<StrandUpdate, "operations"> & {
+  operations: OperationUpdateGraphQL[];
 };
 
-export interface IPullResponderTransmitter extends ITriggerTransmitter {
-    getStrands(since?: string): Promise<StrandUpdate[]>;
+export interface IPullResponderTransmitter extends ITransmitter {
+  getStrands(options?: GetStrandsOptions): Promise<StrandUpdate[]>;
 }
 
 export class PullResponderTransmitter implements IPullResponderTransmitter {
-    private drive: BaseDocumentDriveServer;
-    private listener: Listener;
-    private manager: ListenerManager;
-
-    constructor(
-        listener: Listener,
-        drive: BaseDocumentDriveServer,
-        manager: ListenerManager
-    ) {
-        this.listener = listener;
-        this.drive = drive;
-        this.manager = manager;
-    }
+  private drive: IBaseDocumentDriveServer;
+  private listener: Listener;
+  private manager: ListenerManager;
 
-    async transmit(): Promise<ListenerRevision[]> {
-        return [];
-    }
+  constructor(
+    listener: Listener,
+    drive: IBaseDocumentDriveServer,
+    manager: ListenerManager,
+  ) {
+    this.listener = listener;
+    this.drive = drive;
+    this.manager = manager;
+  }
 
-    getStrands(since?: string | undefined): Promise<StrandUpdate[]> {
-        return this.manager.getStrands(
-            this.listener.driveId,
-            this.listener.listenerId,
-            since
-        );
+  getStrands(options?: GetStrandsOptions): Promise<StrandUpdate[]> {
+    return this.manager.getStrands(
+      this.listener.driveId,
+      this.listener.listenerId,
+      options,
+    );
+  }
+
+  disconnect(): Promise<void> {
+    // TODO remove listener from switchboard
+    return Promise.resolve();
+  }
+
+  async processAcknowledge(
+    driveId: string,
+    listenerId: string,
+    revisions: ListenerRevision[],
+  ): Promise<boolean> {
+    const syncUnits = await this.manager.getListenerSyncUnitIds(
+      driveId,
+      listenerId,
+    );
+    let success = true;
+    for (const revision of revisions) {
+      const syncUnit = syncUnits.find(
+        (s) =>
+          s.scope === revision.scope &&
+          s.branch === revision.branch &&
+          s.driveId === revision.driveId &&
+          s.documentId == revision.documentId,
+      );
+      if (!syncUnit) {
+        defaultLogger.warn("Unknown sync unit was acknowledged", revision);
+        success = false;
+        continue;
+      }
+
+      await this.manager.updateListenerRevision(
+        listenerId,
+        driveId,
+        syncUnit.syncId,
+        revision.revision,
+      );
     }
 
-    async processAcknowledge(
-        driveId: string,
-        listenerId: string,
-        revisions: ListenerRevision[]
-    ): Promise<boolean> {
-        const syncUnits = await this.manager.getListenerSyncUnitIds(
-            driveId,
-            listenerId
-        );
-        let success = true;
-        for (const revision of revisions) {
-            const syncUnit = syncUnits.find(
-                s =>
-                    s.scope === revision.scope &&
-                    s.branch === revision.branch &&
-                    s.driveId === revision.driveId &&
-                    s.documentId == revision.documentId
-            );
-            if (!syncUnit) {
-                defaultLogger.warn(
-                    'Unknown sync unit was acknowledged',
-                    revision
-                );
-                success = false;
-                continue;
-            }
+    return success;
+  }
 
-            await this.manager.updateListenerRevision(
-                listenerId,
-                driveId,
-                syncUnit.syncId,
-                revision.revision
-            );
+  static async registerPullResponder(
+    driveId: string,
+    url: string,
+    filter: ListenerFilter,
+  ): Promise<Listener["listenerId"]> {
+    // graphql request to switchboard
+    const result = await requestGraphql<{
+      registerPullResponderListener: {
+        listenerId: Listener["listenerId"];
+      };
+    }>(
+      url,
+      gql`
+        mutation registerPullResponderListener($filter: InputListenerFilter!) {
+          registerPullResponderListener(filter: $filter) {
+            listenerId
+          }
         }
+      `,
+      { filter },
+    );
 
-        return success;
+    const error = result.errors?.at(0);
+    if (error) {
+      throw error;
     }
 
-    static async registerPullResponder(
-        driveId: string,
-        url: string,
-        filter: ListenerFilter
-    ): Promise<Listener['listenerId']> {
-        // graphql request to switchboard
-        const { registerPullResponderListener } = await requestGraphql<{
-            registerPullResponderListener: {
-                listenerId: Listener['listenerId'];
-            };
-        }>(
-            url,
-            gql`
-                mutation registerPullResponderListener(
-                    $filter: InputListenerFilter!
-                ) {
-                    registerPullResponderListener(filter: $filter) {
-                        listenerId
-                    }
-                }
-            `,
-            { filter }
-        );
-        return registerPullResponderListener.listenerId;
+    if (!result.registerPullResponderListener) {
+      throw new Error("Error registering listener");
     }
 
-    static async pullStrands(
-        driveId: string,
-        url: string,
-        listenerId: string,
-        since?: string // TODO add support for since
-    ): Promise<StrandUpdate[]> {
-        const {
-            system: {
-                sync: { strands }
-            }
-        } = await requestGraphql<PullStrandsGraphQL>(
-            url,
-            gql`
-                query strands($listenerId: ID!) {
-                    system {
-                        sync {
-                            strands(listenerId: $listenerId) {
-                                driveId
-                                documentId
-                                scope
-                                branch
-                                operations {
-                                    id
-                                    timestamp
-                                    skip
-                                    type
-                                    input
-                                    hash
-                                    index
-                                    context {
-                                        signer {
-                                            user {
-                                                address
-                                                networkId
-                                                chainId
-                                            }
-                                            app {
-                                                name
-                                                key
-                                            }
-                                            signature
-                                        }
-                                    }
-                                }
-                            }
-                        }
+    return result.registerPullResponderListener.listenerId;
+  }
+
+  static async pullStrands(
+    driveId: string,
+    url: string,
+    listenerId: string,
+    options?: GetStrandsOptions, // TODO add support for since
+  ): Promise<StrandUpdate[]> {
+    const result = await requestGraphql<PullStrandsGraphQL>(
+      url,
+      gql`
+        query strands($listenerId: ID!) {
+          system {
+            sync {
+              strands(listenerId: $listenerId) {
+                driveId
+                documentId
+                scope
+                branch
+                operations {
+                  id
+                  timestamp
+                  skip
+                  type
+                  input
+                  hash
+                  index
+                  context {
+                    signer {
+                      user {
+                        address
+                        networkId
+                        chainId
+                      }
+                      app {
+                        name
+                        key
+                      }
+                      signatures
                     }
+                  }
                 }
-            `,
-            { listenerId }
-        );
-        return strands.map(s => ({
-            ...s,
-            operations: s.operations.map(o => ({
-                ...o,
-                input: JSON.parse(o.input) as object
-            }))
-        }));
+              }
+            }
+          }
+        }
+      `,
+      { listenerId },
+    );
+
+    const error = result.errors?.at(0);
+    if (error) {
+      throw error;
     }
 
-    static async acknowledgeStrands(
-        driveId: string,
-        url: string,
-        listenerId: string,
-        revisions: ListenerRevision[]
-    ): Promise<boolean> {
-        const result = await requestGraphql<{ acknowledge: boolean }>(
-            url,
-            gql`
-                mutation acknowledge(
-                    $listenerId: String!
-                    $revisions: [ListenerRevisionInput]
-                ) {
-                    acknowledge(listenerId: $listenerId, revisions: $revisions)
-                }
-            `,
-            { listenerId, revisions }
-        );
-        return result.acknowledge;
+    if (!result.system) {
+      return [];
     }
 
-    private static async executePull(
-        driveId: string,
-        trigger: PullResponderTrigger,
-        onStrandUpdate: (strand: StrandUpdate) => Promise<IOperationResult>,
-        onError: (error: Error) => void,
-        onRevisions?: (revisions: ListenerRevisionWithError[]) => void,
-        onAcknowledge?: (success: boolean) => void
-    ) {
-        try {
-            const { url, listenerId } = trigger.data;
-            const strands = await PullResponderTransmitter.pullStrands(
-                driveId,
-                url,
-                listenerId
-                // since ?
-            );
-
-            // if there are no new strands then do nothing
-            if (!strands.length) {
-                onRevisions?.([]);
-                return;
-            }
+    return result.system.sync.strands.map((s) => ({
+      ...s,
+      operations: s.operations.map((o) => ({
+        ...o,
+        input: JSON.parse(o.input) as object,
+      })),
+    }));
+  }
+
+  static async acknowledgeStrands(
+    driveId: string,
+    url: string,
+    listenerId: string,
+    revisions: ListenerRevision[],
+  ): Promise<boolean> {
+    const result = await requestGraphql<{ acknowledge: boolean }>(
+      url,
+      gql`
+        mutation acknowledge(
+          $listenerId: String!
+          $revisions: [ListenerRevisionInput]
+        ) {
+          acknowledge(listenerId: $listenerId, revisions: $revisions)
+        }
+      `,
+      { listenerId, revisions },
+    );
+    const error = result.errors?.at(0);
+    if (error) {
+      throw error;
+    }
 
-            const listenerRevisions: ListenerRevisionWithError[] = [];
+    if (result.acknowledge === null) {
+      throw new Error("Error acknowledging strands");
+    }
+    return result.acknowledge;
+  }
 
-            for (const strand of strands) {
-                let result: IOperationResult | undefined = undefined;
-                let error: Error | undefined = undefined;
-                try {
-                    result = await onStrandUpdate(strand);
-                    if (result.error) {
-                        throw result.error;
-                    }
-                } catch (e) {
-                    error = e as Error;
-                    onError(error);
-                }
+  private static async executePull(
+    driveId: string,
+    trigger: PullResponderTrigger,
+    onStrandUpdate: (
+      strand: StrandUpdate,
+      source: StrandUpdateSource,
+    ) => Promise<IOperationResult>,
+    onError: (error: Error) => void,
+    onRevisions?: (revisions: ListenerRevisionWithError[]) => void,
+    onAcknowledge?: (success: boolean) => void,
+  ) {
+    try {
+      const { url, listenerId } = trigger.data;
+      const strands = await PullResponderTransmitter.pullStrands(
+        driveId,
+        url,
+        listenerId,
+        // since ?
+      );
 
-                listenerRevisions.push({
-                    branch: strand.branch,
-                    documentId: strand.documentId || '',
-                    driveId: strand.driveId,
-                    revision:
-                        result?.document?.operations[strand.scope]?.at(-1)
-                            ?.index ?? -1,
-                    scope: strand.scope as OperationScope,
-                    status: error
-                        ? error instanceof OperationError
-                            ? error.status
-                            : 'ERROR'
-                        : 'SUCCESS',
-                    error
-                });
-            }
+      // if there are no new strands then do nothing
+      if (!strands.length) {
+        onRevisions?.([]);
+        return;
+      }
 
-            onRevisions?.(listenerRevisions);
-
-            await PullResponderTransmitter.acknowledgeStrands(
-                driveId,
-                url,
-                listenerId,
-                listenerRevisions.map(revision => {
-                    const { error, ...rest } = revision;
-                    return rest;
-                })
-            )
-                .then(result => onAcknowledge?.(result))
-                .catch(error => defaultLogger.error('ACK error', error));
-        } catch (error) {
-            onError(error as Error);
-        }
-    }
+      const listenerRevisions: ListenerRevisionWithError[] = [];
 
-    static setupPull(
-        driveId: string,
-        trigger: PullResponderTrigger,
-        onStrandUpdate: (strand: StrandUpdate) => Promise<IOperationResult>,
-        onError: (error: Error) => void,
-        onRevisions?: (revisions: ListenerRevisionWithError[]) => void,
-        onAcknowledge?: (success: boolean) => void
-    ): CancelPullLoop {
-        const { interval } = trigger.data;
-        let loopInterval = PULL_DRIVE_INTERVAL;
-        if (interval) {
-            try {
-                const intervalNumber = parseInt(interval);
-                if (intervalNumber) {
-                    loopInterval = intervalNumber;
-                }
-            } catch {
-                // ignore invalid interval
-            }
+      for (const strand of strands) {
+        const operations: Operation[] = strand.operations.map((op) => ({
+          ...op,
+          scope: strand.scope,
+          branch: strand.branch,
+        }));
+
+        let error: Error | undefined = undefined;
+        try {
+          const result = await onStrandUpdate(strand, {
+            type: "trigger",
+            trigger,
+          });
+          if (result.error) {
+            throw result.error;
+          }
+        } catch (e) {
+          error = e as Error;
+          onError(error);
         }
 
-        let isCancelled = false;
-        let timeout: number | undefined;
-
-        const executeLoop = async () => {
-            while (!isCancelled) {
-                await this.executePull(
-                    driveId,
-                    trigger,
-                    onStrandUpdate,
-                    onError,
-                    onRevisions,
-                    onAcknowledge
-                );
-                await new Promise(resolve => {
-                    timeout = setTimeout(
-                        resolve,
-                        loopInterval
-                    ) as unknown as number;
-                });
-            }
-        };
+        listenerRevisions.push({
+          branch: strand.branch,
+          documentId: strand.documentId || "",
+          driveId: strand.driveId,
+          revision: operations.pop()?.index ?? -1,
+          scope: strand.scope,
+          status: error
+            ? error instanceof OperationError
+              ? error.status
+              : "ERROR"
+            : "SUCCESS",
+          error,
+        });
+      }
 
-        executeLoop().catch(defaultLogger.error);
+      onRevisions?.(listenerRevisions);
 
-        return () => {
-            isCancelled = true;
-            if (timeout !== undefined) {
-                clearTimeout(timeout);
-            }
-        };
+      await PullResponderTransmitter.acknowledgeStrands(
+        driveId,
+        url,
+        listenerId,
+        listenerRevisions.map((revision) => {
+          const { error, ...rest } = revision;
+          return rest;
+        }),
+      )
+        .then((result) => onAcknowledge?.(result))
+        .catch((error) => defaultLogger.error("ACK error", error));
+    } catch (error) {
+      onError(error as Error);
     }
+  }
 
-    static async createPullResponderTrigger(
-        driveId: string,
-        url: string,
-        options: Pick<RemoteDriveOptions, 'pullInterval' | 'pullFilter'>
-    ): Promise<PullResponderTrigger> {
-        const { pullFilter, pullInterval } = options;
-        const listenerId = await PullResponderTransmitter.registerPullResponder(
-            driveId,
-            url,
-            pullFilter ?? {
-                documentId: ['*'],
-                documentType: ['*'],
-                branch: ['*'],
-                scope: ['*']
-            }
+  static setupPull(
+    driveId: string,
+    trigger: PullResponderTrigger,
+    onStrandUpdate: (
+      strand: StrandUpdate,
+      source: StrandUpdateSource,
+    ) => Promise<IOperationResult>,
+    onError: (error: Error) => void,
+    onRevisions?: (revisions: ListenerRevisionWithError[]) => void,
+    onAcknowledge?: (success: boolean) => void,
+  ): CancelPullLoop {
+    const { interval } = trigger.data;
+    let loopInterval = PULL_DRIVE_INTERVAL;
+    if (interval) {
+      try {
+        const intervalNumber = parseInt(interval);
+        if (intervalNumber) {
+          loopInterval = intervalNumber;
+        }
+      } catch {
+        // ignore invalid interval
+      }
+    }
+
+    let isCancelled = false;
+    let timeout: number | undefined;
+
+    const executeLoop = async () => {
+      while (!isCancelled) {
+        await this.executePull(
+          driveId,
+          trigger,
+          onStrandUpdate,
+          onError,
+          onRevisions,
+          onAcknowledge,
         );
+        await new Promise((resolve) => {
+          timeout = setTimeout(resolve, loopInterval) as unknown as number;
+        });
+      }
+    };
 
-        const pullTrigger: PullResponderTrigger = {
-            id: generateUUID(),
-            type: 'PullResponder',
-            data: {
-                url,
-                listenerId,
-                interval: pullInterval?.toString() ?? ''
-            }
-        };
-        return pullTrigger;
-    }
+    executeLoop().catch(defaultLogger.error);
 
-    static isPullResponderTrigger(
-        trigger: Trigger
-    ): trigger is PullResponderTrigger {
-        return trigger.type === 'PullResponder';
-    }
+    return () => {
+      isCancelled = true;
+      if (timeout !== undefined) {
+        clearTimeout(timeout);
+      }
+    };
+  }
+
+  static async createPullResponderTrigger(
+    driveId: string,
+    url: string,
+    options: Pick<RemoteDriveOptions, "pullInterval" | "pullFilter">,
+  ): Promise<PullResponderTrigger> {
+    const { pullFilter, pullInterval } = options;
+    const listenerId = await PullResponderTransmitter.registerPullResponder(
+      driveId,
+      url,
+      pullFilter ?? {
+        documentId: ["*"],
+        documentType: ["*"],
+        branch: ["*"],
+        scope: ["*"],
+      },
+    );
+
+    const pullTrigger: PullResponderTrigger = {
+      id: generateUUID(),
+      type: "PullResponder",
+      data: {
+        url,
+        listenerId,
+        interval: pullInterval?.toString() ?? "",
+      },
+    };
+    return pullTrigger;
+  }
+
+  static isPullResponderTrigger(
+    trigger: Trigger,
+  ): trigger is PullResponderTrigger {
+    return trigger.type === "PullResponder";
+  }
 }