document-drive 1.19.1 → 1.20.1

package/dist/src/server/listener/transmitter/pull-responder.js

@@ -0,0 +1,256 @@
+import { childLogger, generateUUID, } from "document-drive";
+import { PULL_DRIVE_INTERVAL } from "#server/constants";
+import { OperationError } from "#server/error";
+import { requestGraphql } from "#utils/graphql";
+import { gql } from "graphql-request";
+const ENABLE_SYNC_DEBUG = false;
+export class PullResponderTransmitter {
+    static staticLogger = childLogger([
+        "PullResponderTransmitter",
+        "static",
+    ]);
+    logger = childLogger([
+        "PullResponderTransmitter",
+        Math.floor(Math.random() * 999).toString(),
+    ]);
+    listener;
+    manager;
+    constructor(listener, manager) {
+        this.listener = listener;
+        this.manager = manager;
+        this.logger.verbose(`constructor(listener: ${listener.listenerId})`);
+    }
+    getStrands(options) {
+        this.logger.verbose(`getStrands(drive: ${this.listener.driveId}, listener: ${this.listener.listenerId})`);
+        return this.manager.getStrands(this.listener.driveId, this.listener.listenerId, options);
+    }
+    disconnect() {
+        // TODO remove listener from switchboard
+        return Promise.resolve();
+    }
+    async processAcknowledge(driveId, listenerId, revisions) {
+        this.logger.verbose(`processAcknowledge(drive: ${driveId}, listener: ${listenerId})`, revisions);
+        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) {
+                this.logger.warn("Unknown sync unit was acknowledged", revision);
+                success = false;
+                continue;
+            }
+            await this.manager.updateListenerRevision(listenerId, driveId, syncUnit.syncId, revision.revision);
+        }
+        return success;
+    }
+    static async registerPullResponder(driveId, url, filter) {
+        PullResponderTransmitter.staticLogger.verbose(`registerPullResponder(url: ${url})`, filter);
+        // graphql request to switchboard
+        const result = await requestGraphql(url, gql `
+        mutation registerPullResponderListener($filter: InputListenerFilter!) {
+          registerPullResponderListener(filter: $filter) {
+            listenerId
+          }
+        }
+      `, { filter });
+        const error = result.errors?.at(0);
+        if (error) {
+            throw error;
+        }
+        if (!result.registerPullResponderListener) {
+            throw new Error("Error registering listener");
+        }
+        return result.registerPullResponderListener.listenerId;
+    }
+    static async pullStrands(driveId, url, listenerId, options) {
+        this.staticLogger.verbose(`pullStrands(url: ${url}, listener: ${listenerId})`);
+        const result = await requestGraphql(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 });
+        const error = result.errors?.at(0);
+        if (error) {
+            throw error;
+        }
+        if (!result.system) {
+            return [];
+        }
+        return result.system.sync.strands.map((s) => ({
+            ...s,
+            operations: s.operations.map((o) => ({
+                ...o,
+                input: JSON.parse(o.input),
+            })),
+        }));
+    }
+    static async acknowledgeStrands(driveId, url, listenerId, revisions) {
+        this.staticLogger.verbose(`acknowledgeStrands(url: ${url}, listener: ${listenerId})`, revisions);
+        const result = await requestGraphql(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;
+        }
+        if (result.acknowledge === null) {
+            throw new Error("Error acknowledging strands");
+        }
+        return result.acknowledge;
+    }
+    static async executePull(driveId, trigger, onStrandUpdate, onError, onRevisions, onAcknowledge) {
+        this.staticLogger.verbose(`executePull(driveId: ${driveId}), trigger:`, trigger);
+        try {
+            const { url, listenerId } = trigger.data;
+            const strands = await PullResponderTransmitter.pullStrands(driveId, url, listenerId);
+            // if there are no new strands then do nothing
+            if (!strands.length) {
+                onRevisions?.([]);
+                return;
+            }
+            const listenerRevisions = [];
+            for (const strand of strands) {
+                const operations = strand.operations.map((op) => ({
+                    ...op,
+                    scope: strand.scope,
+                    branch: strand.branch,
+                }));
+                let error = undefined;
+                try {
+                    const result = await onStrandUpdate(strand, {
+                        type: "trigger",
+                        trigger,
+                    });
+                    if (result.error) {
+                        throw result.error;
+                    }
+                }
+                catch (e) {
+                    error = e;
+                    onError(error);
+                }
+                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,
+                });
+            }
+            onRevisions?.(listenerRevisions);
+            await PullResponderTransmitter.acknowledgeStrands(driveId, url, listenerId, listenerRevisions.map((revision) => {
+                const { error, ...rest } = revision;
+                return rest;
+            }))
+                .then((result) => onAcknowledge?.(result))
+                .catch((error) => this.staticLogger.error("ACK error", error));
+        }
+        catch (error) {
+            onError(error);
+        }
+    }
+    static setupPull(driveId, trigger, onStrandUpdate, onError, onRevisions, onAcknowledge) {
+        this.staticLogger.verbose(`setupPull(drive: ${driveId}), trigger:`, trigger);
+        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;
+        const executeLoop = async () => {
+            while (!isCancelled) {
+                this.staticLogger.verbose("Execute loop...");
+                await this.executePull(driveId, trigger, onStrandUpdate, onError, onRevisions, onAcknowledge);
+                await new Promise((resolve) => {
+                    this.staticLogger.verbose(`Scheduling next pull in ${loopInterval} ms`);
+                    timeout = setTimeout(resolve, loopInterval);
+                });
+            }
+        };
+        executeLoop().catch(this.staticLogger.error);
+        return () => {
+            isCancelled = true;
+            if (timeout !== undefined) {
+                clearTimeout(timeout);
+            }
+        };
+    }
+    static async createPullResponderTrigger(driveId, url, options) {
+        this.staticLogger.verbose(`createPullResponderTrigger(drive: ${driveId}, url: ${url})`);
+        const { pullFilter, pullInterval } = options;
+        const listenerId = await PullResponderTransmitter.registerPullResponder(driveId, url, pullFilter ?? {
+            documentId: ["*"],
+            documentType: ["*"],
+            branch: ["*"],
+            scope: ["*"],
+        });
+        const pullTrigger = {
+            id: generateUUID(),
+            type: "PullResponder",
+            data: {
+                url,
+                listenerId,
+                interval: pullInterval?.toString() ?? "",
+            },
+        };
+        return pullTrigger;
+    }
+    static isPullResponderTrigger(trigger) {
+        return trigger.type === "PullResponder";
+    }
+}

package/dist/src/server/listener/transmitter/switchboard-push.d.ts

@@ -0,0 +1,9 @@
+import { ListenerRevision, StrandUpdate } from "#server/types";
+import { ITransmitter, StrandUpdateSource } from "./types.js";
+export declare class SwitchboardPushTransmitter implements ITransmitter {
+    private targetURL;
+    private logger;
+    constructor(targetURL: string);
+    transmit(strands: StrandUpdate[], source: StrandUpdateSource): Promise<ListenerRevision[]>;
+}
+//# sourceMappingURL=switchboard-push.d.ts.map

package/dist/src/server/listener/transmitter/switchboard-push.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"switchboard-push.d.ts","sourceRoot":"","sources":["../../../../../src/server/listener/transmitter/switchboard-push.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,gBAAgB,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAC/D,OAAO,EAAE,YAAY,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAI9D,qBAAa,0BAA2B,YAAW,YAAY;IAC7D,OAAO,CAAC,SAAS,CAAS;IAC1B,OAAO,CAAC,MAAM,CAGX;gBAES,SAAS,EAAE,MAAM;IAIvB,QAAQ,CACZ,OAAO,EAAE,YAAY,EAAE,EACvB,MAAM,EAAE,kBAAkB,GACzB,OAAO,CAAC,gBAAgB,EAAE,CAAC;CA2F/B"}

package/dist/src/server/listener/transmitter/switchboard-push.js

@@ -0,0 +1,77 @@
+import stringify from "json-stringify-deterministic";
+import { gql, requestGraphql } from "#utils/graphql";
+import { childLogger } from "#utils/logger";
+const SYNC_OPS_BATCH_LIMIT = 10;
+export class SwitchboardPushTransmitter {
+    targetURL;
+    logger = childLogger([
+        "SwitchboardPushTransmitter",
+        Math.floor(Math.random() * 999).toString(),
+    ]);
+    constructor(targetURL) {
+        this.targetURL = targetURL;
+    }
+    async transmit(strands, source) {
+        if (source.type === "trigger" &&
+            source.trigger.data?.url === this.targetURL) {
+            this.logger.verbose(`Cutting trigger loop from ${this.targetURL}.`);
+            return strands.map((strand) => ({
+                driveId: strand.driveId,
+                documentId: strand.documentId,
+                scope: strand.scope,
+                branch: strand.branch,
+                status: "SUCCESS",
+                revision: strand.operations.at(-1)?.index ?? -1,
+            }));
+        }
+        const culledStrands = [];
+        let opsCounter = 0;
+        for (let s = 0; opsCounter <= SYNC_OPS_BATCH_LIMIT && s < strands.length; s++) {
+            const currentStrand = strands.at(s);
+            if (!currentStrand) {
+                break;
+            }
+            const newOps = Math.min(SYNC_OPS_BATCH_LIMIT - opsCounter, currentStrand.operations.length);
+            culledStrands.push({
+                ...currentStrand,
+                operations: currentStrand.operations.slice(0, newOps),
+            });
+            opsCounter += newOps;
+        }
+        this.logger.verbose(` Total update: [${strands.map((s) => s.operations.length).join(", ")}] operations`);
+        this.logger.verbose(`Culled update: [${culledStrands.map((s) => s.operations.length).join(", ")}] operations`);
+        // Send Graphql mutation to switchboard
+        try {
+            const { pushUpdates } = await requestGraphql(this.targetURL, gql `
+          mutation pushUpdates($strands: [InputStrandUpdate!]) {
+            pushUpdates(strands: $strands) {
+              driveId
+              documentId
+              scope
+              branch
+              status
+              revision
+              error
+            }
+          }
+        `, {
+                strands: culledStrands.map((strand) => ({
+                    ...strand,
+                    operations: strand.operations.map((op) => ({
+                        ...op,
+                        input: stringify(op.input),
+                    })),
+                })),
+            });
+            if (!pushUpdates) {
+                throw new Error("Couldn't update listener revision");
+            }
+            return pushUpdates;
+        }
+        catch (e) {
+            this.logger.error(e);
+            throw e;
+        }
+        return [];
+    }
+}

package/dist/src/server/listener/transmitter/types.d.ts

@@ -0,0 +1,20 @@
+import { PullResponderTriggerData, Trigger } from "#drive-document-model/gen/types";
+import { ListenerRevision, StrandUpdate } from "#server/types";
+export type StrandUpdateSource = {
+    type: "local";
+} | {
+    type: "trigger";
+    trigger: Trigger;
+};
+export interface ITransmitter {
+    transmit?(strands: StrandUpdate[], source: StrandUpdateSource): Promise<ListenerRevision[]>;
+    disconnect?(): Promise<void>;
+}
+export interface InternalTransmitterService extends ITransmitter {
+    getName(): string;
+}
+export type PullResponderTrigger = Omit<Trigger, "data" | "type"> & {
+    data: PullResponderTriggerData;
+    type: "PullResponder";
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/src/server/listener/transmitter/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../../src/server/listener/transmitter/types.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,wBAAwB,EACxB,OAAO,EACR,MAAM,iCAAiC,CAAC;AACzC,OAAO,EAAE,gBAAgB,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAE/D,MAAM,MAAM,kBAAkB,GAC1B;IACE,IAAI,EAAE,OAAO,CAAC;CACf,GACD;IAAE,IAAI,EAAE,SAAS,CAAC;IAAC,OAAO,EAAE,OAAO,CAAA;CAAE,CAAC;AAE1C,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,CACP,OAAO,EAAE,YAAY,EAAE,EACvB,MAAM,EAAE,kBAAkB,GACzB,OAAO,CAAC,gBAAgB,EAAE,CAAC,CAAC;IAC/B,UAAU,CAAC,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CAC9B;AACD,MAAM,WAAW,0BAA2B,SAAQ,YAAY;IAC9D,OAAO,IAAI,MAAM,CAAC;CACnB;AAED,MAAM,MAAM,oBAAoB,GAAG,IAAI,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAAC,GAAG;IAClE,IAAI,EAAE,wBAAwB,CAAC;IAC/B,IAAI,EAAE,eAAe,CAAC;CACvB,CAAC"}

package/dist/src/server/listener/transmitter/types.js

@@ -0,0 +1 @@
+export {};

package/dist/src/server/listener/util.d.ts

@@ -0,0 +1,2 @@
+export declare function debounce<T extends unknown[], R>(func: (...args: T) => Promise<R>, delay?: number): (immediate: boolean, ...args: T) => Promise<R>;
+//# sourceMappingURL=util.d.ts.map

package/dist/src/server/listener/util.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"util.d.ts","sourceRoot":"","sources":["../../../../src/server/listener/util.ts"],"names":[],"mappings":"AAAA,wBAAgB,QAAQ,CAAC,CAAC,SAAS,OAAO,EAAE,EAAE,CAAC,EAC7C,IAAI,EAAE,CAAC,GAAG,IAAI,EAAE,CAAC,KAAK,OAAO,CAAC,CAAC,CAAC,EAChC,KAAK,SAAM,eAGQ,OAAO,WAAW,CAAC,gBAkBvC"}

package/dist/src/server/listener/util.js

@@ -0,0 +1,22 @@
+export function debounce(func, delay = 250) {
+    let timer;
+    return (immediate, ...args) => {
+        if (timer) {
+            clearTimeout(timer);
+        }
+        return new Promise((resolve, reject) => {
+            if (immediate) {
+                func(...args)
+                    .then(resolve)
+                    .catch(reject);
+            }
+            else {
+                timer = setTimeout(() => {
+                    func(...args)
+                        .then(resolve)
+                        .catch(reject);
+                }, delay);
+            }
+        });
+    };
+}

package/dist/src/server/sync-manager.d.ts

@@ -0,0 +1,30 @@
+import { ICache } from "#cache/types";
+import { DocumentDriveDocument } from "#drive-document-model/gen/types";
+import { IDriveStorage } from "#storage/types";
+import { DocumentModelModule } from "document-model";
+import { SynchronizationUnitNotFoundError } from "./error.js";
+import { GetStrandsOptions, IEventEmitter, ISynchronizationManager, OperationUpdate, SyncStatus, SyncUnitStatusObject, SynchronizationUnit, SynchronizationUnitQuery } from "./types.js";
+export default class SynchronizationManager implements ISynchronizationManager {
+    private readonly storage;
+    private readonly cache;
+    private readonly documentModelModules;
+    private readonly eventEmitter?;
+    private syncStatus;
+    constructor(storage: IDriveStorage, cache: ICache, documentModelModules: DocumentModelModule[], eventEmitter?: IEventEmitter | undefined);
+    getSynchronizationUnits(driveId: string, documentId?: string[], scope?: string[], branch?: string[], documentType?: string[]): Promise<SynchronizationUnit[]>;
+    getSynchronizationUnitsRevision(driveId: string, syncUnitsQuery: SynchronizationUnitQuery[]): Promise<SynchronizationUnit[]>;
+    getSynchronizationUnitsIds(driveId: string, documentId?: string[], scope?: string[], branch?: string[], documentType?: string[]): Promise<SynchronizationUnitQuery[]>;
+    getSynchronizationUnitIdInfo(driveId: string, syncId: string): Promise<SynchronizationUnitQuery | undefined>;
+    getSynchronizationUnit(driveId: string, syncId: string): Promise<SynchronizationUnit | undefined>;
+    getOperationData(driveId: string, syncId: string, filter: GetStrandsOptions): Promise<OperationUpdate[]>;
+    private getDrive;
+    private getDocument;
+    private _buildDocument;
+    private getDocumentModelModule;
+    getCombinedSyncUnitStatus(syncUnitStatus: SyncUnitStatusObject): SyncStatus;
+    getSyncStatus(syncUnitId: string): SyncStatus | SynchronizationUnitNotFoundError;
+    updateSyncStatus(syncUnitId: string, status: Partial<SyncUnitStatusObject> | null, error?: Error): void;
+    private initSyncStatus;
+    initializeDriveSyncStatus(driveId: string, drive: DocumentDriveDocument): Promise<void>;
+}
+//# sourceMappingURL=sync-manager.d.ts.map

package/dist/src/server/sync-manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sync-manager.d.ts","sourceRoot":"","sources":["../../../src/server/sync-manager.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AACtC,OAAO,EACL,qBAAqB,EAEtB,MAAM,iCAAiC,CAAC;AAEzC,OAAO,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAG/C,OAAO,EACL,mBAAmB,EAKpB,MAAM,gBAAgB,CAAC;AACxB,OAAO,EAAE,gCAAgC,EAAE,MAAM,YAAY,CAAC;AAC9D,OAAO,EACL,iBAAiB,EACjB,aAAa,EACb,uBAAuB,EACvB,eAAe,EACf,UAAU,EACV,oBAAoB,EACpB,mBAAmB,EACnB,wBAAwB,EACzB,MAAM,YAAY,CAAC;AAEpB,MAAM,CAAC,OAAO,OAAO,sBAAuB,YAAW,uBAAuB;IAI1E,OAAO,CAAC,QAAQ,CAAC,OAAO;IACxB,OAAO,CAAC,QAAQ,CAAC,KAAK;IACtB,OAAO,CAAC,QAAQ,CAAC,oBAAoB;IACrC,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAC;IANhC,OAAO,CAAC,UAAU,CAA2C;gBAG1C,OAAO,EAAE,aAAa,EACtB,KAAK,EAAE,MAAM,EACb,oBAAoB,EAAE,mBAAmB,EAAE,EAC3C,YAAY,CAAC,EAAE,aAAa,YAAA;IAGzC,uBAAuB,CAC3B,OAAO,EAAE,MAAM,EACf,UAAU,CAAC,EAAE,MAAM,EAAE,EACrB,KAAK,CAAC,EAAE,MAAM,EAAE,EAChB,MAAM,CAAC,EAAE,MAAM,EAAE,EACjB,YAAY,CAAC,EAAE,MAAM,EAAE,GACtB,OAAO,CAAC,mBAAmB,EAAE,CAAC;IAe3B,+BAA+B,CACnC,OAAO,EAAE,MAAM,EACf,cAAc,EAAE,wBAAwB,EAAE,GACzC,OAAO,CAAC,mBAAmB,EAAE,CAAC;IA6B3B,0BAA0B,CAC9B,OAAO,EAAE,MAAM,EACf,UAAU,CAAC,EAAE,MAAM,EAAE,EACrB,KAAK,CAAC,EAAE,MAAM,EAAE,EAChB,MAAM,CAAC,EAAE,MAAM,EAAE,EACjB,YAAY,CAAC,EAAE,MAAM,EAAE,GACtB,OAAO,CAAC,wBAAwB,EAAE,CAAC;IAmEhC,4BAA4B,CAChC,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,MAAM,GACb,OAAO,CAAC,wBAAwB,GAAG,SAAS,CAAC;IA6B1C,sBAAsB,CAC1B,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,MAAM,GACb,OAAO,CAAC,mBAAmB,GAAG,SAAS,CAAC;IA0BrC,gBAAgB,CACpB,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,iBAAiB,GACxB,OAAO,CAAC,eAAe,EAAE,CAAC;YA2Cf,QAAQ;YAiBR,WAAW;IAgBzB,OAAO,CAAC,cAAc;IAuBtB,OAAO,CAAC,sBAAsB;IAU9B,yBAAyB,CAAC,cAAc,EAAE,oBAAoB,GAAG,UAAU;IAoB3E,aAAa,CACX,UAAU,EAAE,MAAM,GACjB,UAAU,GAAG,gCAAgC;IAWhD,gBAAgB,CACd,UAAU,EAAE,MAAM,EAClB,MAAM,EAAE,OAAO,CAAC,oBAAoB,CAAC,GAAG,IAAI,EAC5C,KAAK,CAAC,EAAE,KAAK,GACZ,IAAI;IAiDP,OAAO,CAAC,cAAc;IAyBhB,yBAAyB,CAC7B,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,qBAAqB,GAC3B,OAAO,CAAC,IAAI,CAAC;CAejB"}