document-drive 1.19.1 → 1.20.0

package/dist/src/server/listener/listener-manager.js

@@ -0,0 +1,401 @@
+import { DefaultListenerManagerOptions, } from "#server/types";
+import { childLogger } from "document-drive";
+import { OperationError } from "#server/error";
+import { debounce } from "./util.js";
+const ENABLE_SYNC_DEBUG = false;
+export class ListenerManager {
+    static LISTENER_UPDATE_DELAY = 250;
+    logger = childLogger([
+        "ListenerManager",
+        Math.floor(Math.random() * 999).toString(),
+    ]);
+    syncManager;
+    options;
+    // driveId -> listenerId -> listenerState
+    listenerStateByDriveId = new Map();
+    constructor(syncManager, options = DefaultListenerManagerOptions) {
+        this.syncManager = syncManager;
+        this.options = { ...DefaultListenerManagerOptions, ...options };
+        this.logger.verbose(`constructor(...)`);
+    }
+    async initialize(handler) {
+        this.logger.verbose("initialize(...)");
+        // if network connect comes back online
+        // then triggers the listeners update
+        if (typeof window !== "undefined") {
+            window.addEventListener("online", () => {
+                this.triggerUpdate(false, { type: "local" }, handler).catch((error) => {
+                    this.logger.error("Non handled error updating listeners", error);
+                });
+            });
+        }
+    }
+    driveHasListeners(driveId) {
+        return this.listenerStateByDriveId.has(driveId);
+    }
+    async setListener(driveId, listener) {
+        this.logger.verbose(`setListener(drive: ${driveId}, listener: ${listener.listenerId})`);
+        // slight code smell -- drive id may not need to be on listener or not passed in
+        if (driveId !== listener.driveId) {
+            throw new Error("Drive ID mismatch");
+        }
+        let existingState;
+        try {
+            existingState = this.getListenerState(driveId, listener.listenerId);
+        }
+        catch {
+            existingState = {};
+        }
+        // keep existing state if it exists
+        this.setListenerState(driveId, listener.listenerId, {
+            ...existingState,
+            block: listener.block,
+            driveId: listener.driveId,
+            pendingTimeout: "0",
+            listener,
+            listenerStatus: "CREATED",
+            syncUnits: new Map(),
+        });
+        this.triggerUpdate(true, { type: "local" });
+    }
+    async removeListener(driveId, listenerId) {
+        this.logger.verbose("setListener()");
+        const driveMap = this.listenerStateByDriveId.get(driveId);
+        if (!driveMap) {
+            return false;
+        }
+        return Promise.resolve(driveMap.delete(listenerId));
+    }
+    async removeSyncUnits(driveId, syncUnits) {
+        const listeners = this.listenerStateByDriveId.get(driveId);
+        if (!listeners) {
+            return;
+        }
+        for (const [, listener] of listeners) {
+            for (const syncUnit of syncUnits) {
+                listener.syncUnits.delete(syncUnit.syncId);
+            }
+        }
+        return Promise.resolve();
+    }
+    async updateSynchronizationRevisions(driveId, syncUnits, source, willUpdate, onError, forceSync = false) {
+        const listenerIdToListenerState = this.listenerStateByDriveId.get(driveId);
+        if (!listenerIdToListenerState) {
+            return [];
+        }
+        const outdatedListeners = [];
+        for (const [, listenerState] of listenerIdToListenerState) {
+            if (outdatedListeners.find((l) => l.listenerId === listenerState.listener.listenerId)) {
+                continue;
+            }
+            const transmitter = listenerState.listener.transmitter;
+            if (!transmitter?.transmit) {
+                continue;
+            }
+            for (const syncUnit of syncUnits) {
+                if (!this._checkFilter(listenerState.listener.filter, syncUnit)) {
+                    continue;
+                }
+                const listenerRev = listenerState.syncUnits.get(syncUnit.syncId);
+                if (!listenerRev || listenerRev.listenerRev < syncUnit.revision) {
+                    outdatedListeners.push(listenerState.listener);
+                    break;
+                }
+            }
+        }
+        if (outdatedListeners.length) {
+            willUpdate?.(outdatedListeners);
+            return this.triggerUpdate(forceSync, source, onError);
+        }
+        return [];
+    }
+    async updateListenerRevision(listenerId, driveId, syncId, listenerRev) {
+        const drive = this.listenerStateByDriveId.get(driveId);
+        if (!drive) {
+            return;
+        }
+        const listener = drive.get(listenerId);
+        if (!listener) {
+            return;
+        }
+        const lastUpdated = new Date().toISOString();
+        const entry = listener.syncUnits.get(syncId);
+        if (entry) {
+            entry.listenerRev = listenerRev;
+            entry.lastUpdated = lastUpdated;
+        }
+        else {
+            listener.syncUnits.set(syncId, { listenerRev, lastUpdated });
+        }
+        return Promise.resolve();
+    }
+    triggerUpdate = debounce(this._triggerUpdate.bind(this), ListenerManager.LISTENER_UPDATE_DELAY);
+    async _triggerUpdate(source, onError, maxContinues = 500) {
+        this.logger.verbose(`_triggerUpdate(source: ${source.type}, maxContinues: ${maxContinues})`, this.listenerStateByDriveId);
+        if (maxContinues < 0) {
+            throw new Error("Maximum retries exhausted.");
+        }
+        const listenerUpdates = [];
+        for (const [driveId, drive] of this.listenerStateByDriveId) {
+            for (const [listenerId, listenerState] of drive) {
+                const transmitter = listenerState.listener.transmitter;
+                if (!transmitter?.transmit) {
+                    this.logger.verbose(`Transmitter not set on listener: ${listenerId}`);
+                    continue;
+                }
+                const syncUnits = await this.getListenerSyncUnits(driveId, listenerId);
+                const strandUpdates = [];
+                this.logger.verbose("syncUnits", syncUnits);
+                // TODO change to push one after the other, reusing operation data
+                const tasks = syncUnits.map((syncUnit) => async () => {
+                    const unitState = listenerState.syncUnits.get(syncUnit.syncId);
+                    if (unitState && unitState.listenerRev >= syncUnit.revision) {
+                        this.logger.verbose(`Abandoning push for sync unit ${syncUnit.syncId}: already up-to-date (${unitState.listenerRev} >= ${syncUnit.revision})`);
+                        return;
+                    }
+                    else {
+                        this.logger.verbose(`Listener out-of-date for sync unit ${syncUnit.syncId}: ${unitState?.listenerRev} < ${syncUnit.revision}`);
+                    }
+                    const opData = [];
+                    try {
+                        const data = await this.syncManager.getOperationData(
+                        // TODO - join queries, DEAL WITH INVALID SYNC ID ERROR
+                        driveId, syncUnit.syncId, {
+                            fromRevision: unitState?.listenerRev,
+                        });
+                        opData.push(...data);
+                    }
+                    catch (e) {
+                        this.logger.error(e);
+                    }
+                    if (!opData.length) {
+                        this.logger.verbose(`Abandoning push for ${syncUnit.syncId}: no operations found`);
+                        return;
+                    }
+                    strandUpdates.push({
+                        driveId,
+                        documentId: syncUnit.documentId,
+                        branch: syncUnit.branch,
+                        operations: opData,
+                        scope: syncUnit.scope,
+                    });
+                });
+                if (this.options.sequentialUpdates) {
+                    this.logger.verbose(`Collecting ${tasks.length} syncUnit strandUpdates in sequence`);
+                    for (const task of tasks) {
+                        await task();
+                    }
+                }
+                else {
+                    this.logger.verbose(`Collecting ${tasks.length} syncUnit strandUpdates in parallel`);
+                    await Promise.all(tasks.map((task) => task()));
+                }
+                if (strandUpdates.length == 0) {
+                    this.logger.verbose(`No strandUpdates needed for listener ${listenerId}`);
+                    continue;
+                }
+                listenerState.pendingTimeout = new Date(new Date().getTime() / 1000 + 300).toISOString();
+                listenerState.listenerStatus = "PENDING";
+                // TODO update listeners in parallel, blocking for listeners with block=true
+                try {
+                    this.logger.verbose(`_triggerUpdate(source: ${source.type}) > transmitter.transmit`);
+                    const listenerRevisions = await transmitter.transmit(strandUpdates, source);
+                    this.logger.verbose(`_triggerUpdate(source: ${source.type}) > transmission succeeded`, listenerRevisions);
+                    listenerState.pendingTimeout = "0";
+                    listenerState.listenerStatus = "PENDING";
+                    const lastUpdated = new Date().toISOString();
+                    let continuationNeeded = false;
+                    for (const revision of listenerRevisions) {
+                        const syncUnit = syncUnits.find((unit) => revision.documentId === unit.documentId &&
+                            revision.scope === unit.scope &&
+                            revision.branch === unit.branch);
+                        if (syncUnit) {
+                            listenerState.syncUnits.set(syncUnit.syncId, {
+                                lastUpdated,
+                                listenerRev: revision.revision,
+                            });
+                            // Check for revision status vv
+                            const su = strandUpdates.find((su) => su.driveId === revision.driveId &&
+                                su.documentId === revision.documentId &&
+                                su.scope === revision.scope &&
+                                su.branch === revision.branch);
+                            if (su && su.operations.length > 0) {
+                                const suIndex = su.operations.at(su.operations.length - 1)?.index;
+                                if (suIndex !== revision.revision) {
+                                    this.logger.verbose(`Revision still out-of-date for ${su.documentId}:${su.scope}:${su.branch} ${suIndex} <> ${revision.revision}`);
+                                    continuationNeeded = true;
+                                }
+                                else {
+                                    this.logger.verbose(`Revision match for ${su.documentId}:${su.scope}:${su.branch} ${suIndex}`);
+                                }
+                            }
+                            else {
+                                this.logger.verbose(`Cannot find strand update for (${revision.documentId}:${revision.scope}:${revision.branch} in drive ${revision.driveId})`);
+                            }
+                            // Check for revision status ^^
+                        }
+                        else {
+                            this.logger.warn(`Received revision for untracked unit for listener ${listenerState.listener.listenerId}`, revision);
+                        }
+                    }
+                    for (const revision of listenerRevisions) {
+                        const error = revision.status === "ERROR";
+                        if (revision.error?.includes("Missing operations")) {
+                            continuationNeeded = true;
+                        }
+                        else if (error) {
+                            throw new OperationError(revision.status, undefined, revision.error, revision.error);
+                        }
+                    }
+                    if (!continuationNeeded) {
+                        listenerUpdates.push({
+                            listenerId: listenerState.listener.listenerId,
+                            listenerRevisions,
+                        });
+                    }
+                    else {
+                        const updates = await this._triggerUpdate(source, onError, maxContinues - 1);
+                        listenerUpdates.push(...updates);
+                    }
+                    listenerState.listenerStatus = "SUCCESS";
+                }
+                catch (e) {
+                    // TODO: Handle error based on listener params (blocking, retry, etc)
+                    onError?.(e, driveId, listenerState);
+                    listenerState.listenerStatus =
+                        e instanceof OperationError ? e.status : "ERROR";
+                }
+            }
+        }
+        this.logger.verbose(`Returning listener updates (maxContinues: ${maxContinues})`, listenerUpdates);
+        return listenerUpdates;
+    }
+    _checkFilter(filter, syncUnit) {
+        const { branch, documentId, scope, documentType } = syncUnit;
+        // TODO: Needs to be optimized
+        if ((!filter.branch ||
+            filter.branch.includes(branch) ||
+            filter.branch.includes("*")) &&
+            (!filter.documentId ||
+                filter.documentId.includes(documentId) ||
+                filter.documentId.includes("*")) &&
+            (!filter.scope ||
+                filter.scope.includes(scope) ||
+                filter.scope.includes("*")) &&
+            (!filter.documentType ||
+                filter.documentType.includes(documentType) ||
+                filter.documentType.includes("*"))) {
+            return true;
+        }
+        return false;
+    }
+    getListenerSyncUnits(driveId, listenerId) {
+        const listener = this.listenerStateByDriveId.get(driveId)?.get(listenerId);
+        if (!listener) {
+            return [];
+        }
+        const filter = listener.listener.filter;
+        return this.syncManager.getSynchronizationUnits(driveId, filter.documentId ?? ["*"], filter.scope ?? ["*"], filter.branch ?? ["*"], filter.documentType ?? ["*"]);
+    }
+    getListenerSyncUnitIds(driveId, listenerId) {
+        const listener = this.listenerStateByDriveId.get(driveId)?.get(listenerId);
+        if (!listener) {
+            return Promise.resolve([]);
+        }
+        const filter = listener.listener.filter;
+        return this.syncManager.getSynchronizationUnitsIds(driveId, filter.documentId ?? ["*"], filter.scope ?? ["*"], filter.branch ?? ["*"], filter.documentType ?? ["*"]);
+    }
+    async removeDrive(driveId) {
+        const listenerIdToListenerState = this.listenerStateByDriveId.get(driveId);
+        if (!listenerIdToListenerState) {
+            return;
+        }
+        // delete first
+        this.listenerStateByDriveId.delete(driveId);
+        for (const [_, listenerState] of listenerIdToListenerState) {
+            // guarantee that all disconnects are called
+            try {
+                await listenerState.listener.transmitter?.disconnect?.();
+            }
+            catch (error) {
+                this.logger.error(error);
+            }
+        }
+    }
+    async getStrands(driveId, listenerId, options) {
+        // this will throw if listenerState is not found
+        const listenerState = this.getListenerState(driveId, listenerId);
+        // fetch operations from drive  and prepare strands
+        const strands = [];
+        const syncUnits = await this.getListenerSyncUnits(driveId, listenerId);
+        const limit = options?.limit; // maximum number of operations to send across all sync units
+        let operationsCount = 0; // total amount of operations that have been retrieved
+        const tasks = syncUnits.map((syncUnit) => async () => {
+            if (limit && operationsCount >= limit) {
+                // break;
+                return;
+            }
+            if (syncUnit.revision < 0) {
+                return;
+            }
+            const entry = listenerState.syncUnits.get(syncUnit.syncId);
+            if (entry && entry.listenerRev >= syncUnit.revision) {
+                return;
+            }
+            const { documentId, driveId, scope, branch } = syncUnit;
+            try {
+                const operations = await this.syncManager.getOperationData(
+                // DEAL WITH INVALID SYNC ID ERROR
+                driveId, syncUnit.syncId, {
+                    since: options?.since,
+                    fromRevision: options?.fromRevision ?? entry?.listenerRev,
+                    limit: limit ? limit - operationsCount : undefined,
+                });
+                if (!operations.length) {
+                    return;
+                }
+                operationsCount += operations.length;
+                strands.push({
+                    driveId,
+                    documentId,
+                    scope: scope,
+                    branch,
+                    operations,
+                });
+            }
+            catch (error) {
+                this.logger.error(error);
+                return;
+            }
+        });
+        if (this.options.sequentialUpdates) {
+            for (const task of tasks) {
+                await task();
+            }
+        }
+        else {
+            await Promise.all(tasks.map((task) => task()));
+        }
+        return strands;
+    }
+    getListenerState(driveId, listenerId) {
+        let listenerStateByListenerId = this.listenerStateByDriveId.get(driveId);
+        if (!listenerStateByListenerId) {
+            listenerStateByListenerId = new Map();
+            this.listenerStateByDriveId.set(driveId, listenerStateByListenerId);
+        }
+        const listenerState = listenerStateByListenerId.get(listenerId);
+        if (!listenerState) {
+            throw new Error("Listener not found");
+        }
+        return listenerState;
+    }
+    setListenerState(driveId, listenerId, listenerState) {
+        let listenerStateByListenerId = this.listenerStateByDriveId.get(driveId);
+        if (!listenerStateByListenerId) {
+            listenerStateByListenerId = new Map();
+            this.listenerStateByDriveId.set(driveId, listenerStateByListenerId);
+        }
+        listenerStateByListenerId.set(listenerId, listenerState);
+    }
+}

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

@@ -0,0 +1,8 @@
+import { IBaseDocumentDriveServer, IListenerManager, ITransmitterFactory, Listener } from "#server/types";
+import { ITransmitter } from "./types.js";
+export default class TransmitterFactory implements ITransmitterFactory {
+    private readonly listenerManager;
+    constructor(listenerManager: IListenerManager);
+    instance(transmitterType: string, listener: Listener, driveServer: IBaseDocumentDriveServer): ITransmitter;
+}
+//# sourceMappingURL=factory.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"factory.d.ts","sourceRoot":"","sources":["../../../../../src/server/listener/transmitter/factory.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,wBAAwB,EACxB,gBAAgB,EAChB,mBAAmB,EACnB,QAAQ,EACT,MAAM,eAAe,CAAC;AAIvB,OAAO,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAE1C,MAAM,CAAC,OAAO,OAAO,kBAAmB,YAAW,mBAAmB;IACpE,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAmB;gBAEvC,eAAe,EAAE,gBAAgB;IAI7C,QAAQ,CACN,eAAe,EAAE,MAAM,EACvB,QAAQ,EAAE,QAAQ,EAClB,WAAW,EAAE,wBAAwB,GACpC,YAAY;CAiBhB"}

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

@@ -0,0 +1,25 @@
+import { InternalTransmitter } from "./internal.js";
+import { PullResponderTransmitter } from "./pull-responder.js";
+import { SwitchboardPushTransmitter } from "./switchboard-push.js";
+export default class TransmitterFactory {
+    listenerManager;
+    constructor(listenerManager) {
+        this.listenerManager = listenerManager;
+    }
+    instance(transmitterType, listener, driveServer) {
+        switch (transmitterType) {
+            case "SwitchboardPush": {
+                if (!listener.callInfo?.data) {
+                    throw new Error("No call info data: " + JSON.stringify(listener));
+                }
+                return new SwitchboardPushTransmitter(listener.callInfo.data);
+            }
+            case "Internal": {
+                return new InternalTransmitter(listener, driveServer);
+            }
+            default: {
+                return new PullResponderTransmitter(listener, this.listenerManager);
+            }
+        }
+    }
+}

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

@@ -0,0 +1,34 @@
+import { GlobalStateFromDocument, LocalStateFromDocument, OperationFromDocument, OperationScope, PHDocument } from "document-model";
+import { IBaseDocumentDriveServer, Listener, ListenerRevision, StrandUpdate } from "#server/types";
+import { ITransmitter, StrandUpdateSource } from "./types.js";
+export interface IReceiver {
+    onStrands: <TDocument extends PHDocument>(strands: InternalTransmitterUpdate<TDocument>[]) => Promise<void>;
+    onDisconnect: () => Promise<void>;
+}
+export type InternalOperationUpdate<TDocument extends PHDocument> = Omit<OperationFromDocument<TDocument>, "scope"> & {
+    state: GlobalStateFromDocument<TDocument> | LocalStateFromDocument<TDocument>;
+    previousState: GlobalStateFromDocument<TDocument> | LocalStateFromDocument<TDocument>;
+};
+export type InternalTransmitterUpdate<TDocument extends PHDocument> = {
+    driveId: string;
+    documentId: string;
+    scope: OperationScope;
+    branch: string;
+    operations: InternalOperationUpdate<TDocument>[];
+    state: GlobalStateFromDocument<TDocument> | LocalStateFromDocument<TDocument>;
+};
+export interface IInternalTransmitter extends ITransmitter {
+    setReceiver(receiver: IReceiver): void;
+}
+export declare class InternalTransmitter implements ITransmitter {
+    #private;
+    protected drive: IBaseDocumentDriveServer;
+    protected listener: Listener;
+    protected receiver: IReceiver | undefined;
+    constructor(listener: Listener, drive: IBaseDocumentDriveServer);
+    transmit(strands: StrandUpdate[], _source: StrandUpdateSource): Promise<ListenerRevision[]>;
+    setReceiver(receiver: IReceiver): void;
+    disconnect(): Promise<void>;
+    getListener(): Listener;
+}
+//# sourceMappingURL=internal.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"internal.d.ts","sourceRoot":"","sources":["../../../../../src/server/listener/transmitter/internal.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,uBAAuB,EACvB,sBAAsB,EACtB,qBAAqB,EACrB,cAAc,EACd,UAAU,EACX,MAAM,gBAAgB,CAAC;AAMxB,OAAO,EAEL,wBAAwB,EACxB,QAAQ,EACR,gBAAgB,EAChB,YAAY,EACb,MAAM,eAAe,CAAC;AAEvB,OAAO,EAAE,YAAY,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAE9D,MAAM,WAAW,SAAS;IACxB,SAAS,EAAE,CAAC,SAAS,SAAS,UAAU,EACtC,OAAO,EAAE,yBAAyB,CAAC,SAAS,CAAC,EAAE,KAC5C,OAAO,CAAC,IAAI,CAAC,CAAC;IACnB,YAAY,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CACnC;AAED,MAAM,MAAM,uBAAuB,CAAC,SAAS,SAAS,UAAU,IAAI,IAAI,CACtE,qBAAqB,CAAC,SAAS,CAAC,EAChC,OAAO,CACR,GAAG;IACF,KAAK,EAAE,uBAAuB,CAAC,SAAS,CAAC,GAAG,sBAAsB,CAAC,SAAS,CAAC,CAAC;IAC9E,aAAa,EACT,uBAAuB,CAAC,SAAS,CAAC,GAClC,sBAAsB,CAAC,SAAS,CAAC,CAAC;CACvC,CAAC;AAEF,MAAM,MAAM,yBAAyB,CAAC,SAAS,SAAS,UAAU,IAAI;IACpE,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,EAAE,cAAc,CAAC;IACtB,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,uBAAuB,CAAC,SAAS,CAAC,EAAE,CAAC;IACjD,KAAK,EAAE,uBAAuB,CAAC,SAAS,CAAC,GAAG,sBAAsB,CAAC,SAAS,CAAC,CAAC;CAC/E,CAAC;AAEF,MAAM,WAAW,oBAAqB,SAAQ,YAAY;IACxD,WAAW,CAAC,QAAQ,EAAE,SAAS,GAAG,IAAI,CAAC;CACxC;AAED,qBAAa,mBAAoB,YAAW,YAAY;;IACtD,SAAS,CAAC,KAAK,EAAE,wBAAwB,CAAC;IAC1C,SAAS,CAAC,QAAQ,EAAE,QAAQ,CAAC;IAC7B,SAAS,CAAC,QAAQ,EAAE,SAAS,GAAG,SAAS,CAAC;gBAE9B,QAAQ,EAAE,QAAQ,EAAE,KAAK,EAAE,wBAAwB;IAkDzD,QAAQ,CACZ,OAAO,EAAE,YAAY,EAAE,EAEvB,OAAO,EAAE,kBAAkB,GAC1B,OAAO,CAAC,gBAAgB,EAAE,CAAC;IAiC9B,WAAW,CAAC,QAAQ,EAAE,SAAS;IAIzB,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAIjC,WAAW,IAAI,QAAQ;CAGxB"}

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

@@ -0,0 +1,87 @@
+import { logger } from "#utils/logger";
+export class InternalTransmitter {
+    drive;
+    listener;
+    receiver;
+    constructor(listener, drive) {
+        this.listener = listener;
+        this.drive = drive;
+    }
+    async #buildInternalOperationUpdate(strand) {
+        const operations = [];
+        const stateByIndex = new Map();
+        const getStateByIndex = async (index) => {
+            const state = stateByIndex.get(index);
+            if (state) {
+                return state;
+            }
+            const getDocumentOptions = {
+                revisions: {
+                    [strand.scope]: index,
+                },
+                checkHashes: false,
+            };
+            const document = await (strand.documentId
+                ? this.drive.getDocument(strand.driveId, strand.documentId, getDocumentOptions)
+                : this.drive.getDrive(strand.driveId, getDocumentOptions));
+            if (index < 0) {
+                stateByIndex.set(index, document.initialState.state[strand.scope]);
+            }
+            else {
+                stateByIndex.set(index, document.state[strand.scope]);
+            }
+            return stateByIndex.get(index);
+        };
+        for (const operation of strand.operations) {
+            operations.push({
+                ...operation,
+                state: await getStateByIndex(operation.index),
+                previousState: await getStateByIndex(operation.index - 1),
+            });
+        }
+        return operations;
+    }
+    async transmit(strands, 
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    _source) {
+        if (!this.receiver) {
+            return [];
+        }
+        const updates = [];
+        for (const strand of strands) {
+            const operations = await this.#buildInternalOperationUpdate(strand);
+            const state = operations.at(-1)?.state ?? {};
+            updates.push({
+                ...strand,
+                operations,
+                state,
+            });
+        }
+        try {
+            await this.receiver.onStrands(updates);
+            return strands.map(({ operations, ...s }) => ({
+                ...s,
+                status: "SUCCESS",
+                revision: operations.at(operations.length - 1)?.index ?? -1,
+            }));
+        }
+        catch (error) {
+            logger.error(error);
+            // TODO check which strand caused an error
+            return strands.map(({ operations, ...s }) => ({
+                ...s,
+                status: "ERROR",
+                revision: (operations.at(0)?.index ?? 0) - 1,
+            }));
+        }
+    }
+    setReceiver(receiver) {
+        this.receiver = receiver;
+    }
+    async disconnect() {
+        await this.receiver?.onDisconnect();
+    }
+    getListener() {
+        return this.listener;
+    }
+}

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

@@ -0,0 +1,38 @@
+import { GetStrandsOptions, IListenerManager, IOperationResult, Listener, ListenerRevision, ListenerRevisionWithError, OperationUpdate, RemoteDriveOptions, StrandUpdate } from "#server/types";
+import { ListenerFilter, Trigger } from "document-drive";
+import { ITransmitter, PullResponderTrigger, StrandUpdateSource } from "./types.js";
+export type OperationUpdateGraphQL = Omit<OperationUpdate, "input"> & {
+    input: string;
+};
+export type PullStrandsGraphQL = {
+    system: {
+        sync: {
+            strands: StrandUpdateGraphQL[];
+        };
+    };
+};
+export type CancelPullLoop = () => void;
+export type StrandUpdateGraphQL = Omit<StrandUpdate, "operations"> & {
+    operations: OperationUpdateGraphQL[];
+};
+export interface IPullResponderTransmitter extends ITransmitter {
+    getStrands(options?: GetStrandsOptions): Promise<StrandUpdate[]>;
+}
+export declare class PullResponderTransmitter implements IPullResponderTransmitter {
+    private static staticLogger;
+    private logger;
+    private listener;
+    private manager;
+    constructor(listener: Listener, manager: IListenerManager);
+    getStrands(options?: GetStrandsOptions): Promise<StrandUpdate[]>;
+    disconnect(): Promise<void>;
+    processAcknowledge(driveId: string, listenerId: string, revisions: ListenerRevision[]): Promise<boolean>;
+    static registerPullResponder(driveId: string, url: string, filter: ListenerFilter): Promise<Listener["listenerId"]>;
+    static pullStrands(driveId: string, url: string, listenerId: string, options?: GetStrandsOptions): Promise<StrandUpdate[]>;
+    static acknowledgeStrands(driveId: string, url: string, listenerId: string, revisions: ListenerRevision[]): Promise<boolean>;
+    private static executePull;
+    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;
+    static createPullResponderTrigger(driveId: string, url: string, options: Pick<RemoteDriveOptions, "pullInterval" | "pullFilter">): Promise<PullResponderTrigger>;
+    static isPullResponderTrigger(trigger: Trigger): trigger is PullResponderTrigger;
+}
+//# sourceMappingURL=pull-responder.d.ts.map

package/dist/src/server/listener/transmitter/pull-responder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pull-responder.d.ts","sourceRoot":"","sources":["../../../../../src/server/listener/transmitter/pull-responder.ts"],"names":[],"mappings":"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"}