document-drive 1.19.1 → 1.20.1

package/dist/src/server/base-server.js

@@ -0,0 +1,1280 @@
+import { addListener, removeListener, removeTrigger, setSharingType, } from "#drive-document-model/gen/creators";
+import { createDocument } from "#drive-document-model/gen/utils";
+import { isActionJob, isOperationJob, } from "#queue/types";
+import { ReadModeServer } from "#read-mode/server";
+import { DefaultDrivesManager, } from "#utils/default-drives-manager";
+import { requestPublicDrive } from "#utils/graphql";
+import { logger } from "#utils/logger";
+import { generateUUID, isDocumentDrive, runAsapAsync } from "#utils/misc";
+import { RunAsap } from "#utils/run-asap";
+import { attachBranch, garbageCollect, garbageCollectDocumentOperations, groupOperationsByScope, merge, precedes, removeExistingOperations, replayDocument, reshuffleByTimestamp, skipHeaderOperations, sortOperations } from "document-model";
+import { ClientError } from "graphql-request";
+import { ConflictOperationError, DriveAlreadyExistsError, OperationError, } from "./error.js";
+import { InternalTransmitter, } from "./listener/transmitter/internal.js";
+import { PullResponderTransmitter, } from "./listener/transmitter/pull-responder.js";
+import { DefaultListenerManagerOptions, } from "./types.js";
+import { filterOperationsByRevision, isAtRevision } from "./utils.js";
+export class BaseDocumentDriveServer {
+    // external dependencies
+    documentModelModules;
+    storage;
+    cache;
+    queueManager;
+    eventEmitter;
+    options;
+    // waiting to move to external dependencies
+    listenerManager;
+    transmitterFactory;
+    synchronizationManager;
+    // internal dependencies
+    defaultDrivesManager;
+    // internal state
+    triggerMap = new Map();
+    initializePromise;
+    constructor(documentModelModules, storage, cache, queueManager, eventEmitter, synchronizationManager, listenerManager, transmitterFactory, options) {
+        this.documentModelModules = documentModelModules;
+        this.storage = storage;
+        this.cache = cache;
+        this.queueManager = queueManager;
+        this.eventEmitter = eventEmitter;
+        this.synchronizationManager = synchronizationManager;
+        this.listenerManager = listenerManager;
+        this.transmitterFactory = transmitterFactory;
+        this.options = {
+            ...options,
+            defaultDrives: {
+                ...options?.defaultDrives,
+            },
+            listenerManager: {
+                ...DefaultListenerManagerOptions,
+                ...options?.listenerManager,
+            },
+            taskQueueMethod: options?.taskQueueMethod === undefined
+                ? RunAsap.runAsap
+                : options.taskQueueMethod,
+        };
+        this.defaultDrivesManager = new DefaultDrivesManager(this, this.defaultDrivesManagerDelegate, options);
+        this.storage.setStorageDelegate?.({
+            getCachedOperations: async (drive, id) => {
+                try {
+                    const document = await this.cache.getDocument(drive, id);
+                    return document?.operations;
+                }
+                catch (error) {
+                    logger.error(error);
+                    return undefined;
+                }
+            },
+        });
+        this.initializePromise = this._initialize();
+    }
+    initialize() {
+        return this.initializePromise;
+    }
+    async _initialize() {
+        await this.listenerManager.initialize(this.handleListenerError);
+        await this.queueManager.init(this.queueDelegate, (error) => {
+            logger.error(`Error initializing queue manager`, error);
+            errors.push(error);
+        });
+        try {
+            await this.defaultDrivesManager.removeOldremoteDrives();
+        }
+        catch (error) {
+            logger.error(error);
+        }
+        const errors = [];
+        const drives = await this.getDrives();
+        for (const drive of drives) {
+            await this._initializeDrive(drive).catch((error) => {
+                logger.error(`Error initializing drive ${drive}`, error);
+                errors.push(error);
+            });
+        }
+        if (this.options.defaultDrives.loadOnInit !== false) {
+            await this.defaultDrivesManager.initializeDefaultRemoteDrives();
+        }
+        return errors.length === 0 ? null : errors;
+    }
+    setDocumentModelModules(modules) {
+        this.documentModelModules = [...modules];
+        this.eventEmitter.emit("documentModelModules", [...modules]);
+    }
+    initializeDefaultRemoteDrives() {
+        return this.defaultDrivesManager.initializeDefaultRemoteDrives();
+    }
+    getDefaultRemoteDrives() {
+        return this.defaultDrivesManager.getDefaultRemoteDrives();
+    }
+    setDefaultDriveAccessLevel(url, level) {
+        return this.defaultDrivesManager.setDefaultDriveAccessLevel(url, level);
+    }
+    setAllDefaultDrivesAccessLevel(level) {
+        return this.defaultDrivesManager.setAllDefaultDrivesAccessLevel(level);
+    }
+    getOperationSource(source) {
+        return source.type === "local" ? "push" : "pull";
+    }
+    handleListenerError(error, driveId, listener) {
+        logger.error(`Listener ${listener.listener.label ?? listener.listener.listenerId} error:`, error);
+        const status = error instanceof OperationError ? error.status : "ERROR";
+        this.synchronizationManager.updateSyncStatus(driveId, { push: status }, error);
+    }
+    shouldSyncRemoteDrive(drive) {
+        return (drive.state.local.availableOffline &&
+            drive.state.local.triggers.length > 0);
+    }
+    async startSyncRemoteDrive(driveId) {
+        let driveTriggers = this.triggerMap.get(driveId);
+        const syncUnits = await this.getSynchronizationUnitsIds(driveId);
+        const drive = await this.getDrive(driveId);
+        for (const trigger of drive.state.local.triggers) {
+            if (driveTriggers?.get(trigger.id)) {
+                continue;
+            }
+            if (!driveTriggers) {
+                driveTriggers = new Map();
+            }
+            this.synchronizationManager.updateSyncStatus(driveId, {
+                pull: "SYNCING",
+            });
+            for (const syncUnit of syncUnits) {
+                this.synchronizationManager.updateSyncStatus(syncUnit.syncId, {
+                    pull: "SYNCING",
+                });
+            }
+            if (PullResponderTransmitter.isPullResponderTrigger(trigger)) {
+                let firstPull = true;
+                const cancelPullLoop = PullResponderTransmitter.setupPull(driveId, trigger, this.saveStrand.bind(this), (error) => {
+                    const statusError = error instanceof OperationError ? error.status : "ERROR";
+                    this.synchronizationManager.updateSyncStatus(driveId, { pull: statusError }, error);
+                    if (error instanceof ClientError) {
+                        this.eventEmitter.emit("clientStrandsError", driveId, trigger, error.response.status, error.message);
+                    }
+                }, (revisions) => {
+                    const errorRevision = revisions.filter((r) => r.status !== "SUCCESS");
+                    if (errorRevision.length < 1) {
+                        this.synchronizationManager.updateSyncStatus(driveId, {
+                            pull: "SUCCESS",
+                        });
+                    }
+                    const documentIdsFromRevision = revisions
+                        .filter((rev) => rev.documentId !== "")
+                        .map((rev) => rev.documentId);
+                    this.getSynchronizationUnitsIds(driveId, documentIdsFromRevision)
+                        .then((revSyncUnits) => {
+                        for (const syncUnit of revSyncUnits) {
+                            const fileErrorRevision = errorRevision.find((r) => r.documentId === syncUnit.documentId);
+                            if (fileErrorRevision) {
+                                this.synchronizationManager.updateSyncStatus(syncUnit.syncId, { pull: fileErrorRevision.status }, fileErrorRevision.error);
+                            }
+                            else {
+                                this.synchronizationManager.updateSyncStatus(syncUnit.syncId, {
+                                    pull: "SUCCESS",
+                                });
+                            }
+                        }
+                    })
+                        .catch(console.error);
+                    // if it is the first pull and returns empty
+                    // then updates corresponding push transmitter
+                    if (firstPull) {
+                        firstPull = false;
+                        const pushListener = drive.state.local.listeners.find((listener) => trigger.data.url === listener.callInfo?.data);
+                        if (pushListener) {
+                            this.getSynchronizationUnitsRevision(driveId, syncUnits)
+                                .then((syncUnitRevisions) => {
+                                for (const revision of syncUnitRevisions) {
+                                    this.listenerManager
+                                        .updateListenerRevision(pushListener.listenerId, driveId, revision.syncId, revision.revision)
+                                        .catch(logger.error);
+                                }
+                            })
+                                .catch(logger.error);
+                        }
+                    }
+                });
+                driveTriggers.set(trigger.id, cancelPullLoop);
+                this.triggerMap.set(driveId, driveTriggers);
+            }
+        }
+    }
+    async stopSyncRemoteDrive(driveId) {
+        const syncUnits = await this.getSynchronizationUnitsIds(driveId);
+        const filesNodeSyncId = syncUnits
+            .filter((syncUnit) => syncUnit.documentId !== "")
+            .map((syncUnit) => syncUnit.syncId);
+        const triggers = this.triggerMap.get(driveId);
+        triggers?.forEach((cancel) => cancel());
+        this.synchronizationManager.updateSyncStatus(driveId, null);
+        for (const fileNodeSyncId of filesNodeSyncId) {
+            this.synchronizationManager.updateSyncStatus(fileNodeSyncId, null);
+        }
+        return this.triggerMap.delete(driveId);
+    }
+    defaultDrivesManagerDelegate = {
+        detachDrive: this.detachDrive.bind(this),
+        emit: (...args) => this.eventEmitter.emit("defaultRemoteDrive", ...args),
+    };
+    queueDelegate = {
+        checkDocumentExists: (driveId, documentId) => this.storage.checkDocumentExists(driveId, documentId),
+        processOperationJob: async ({ driveId, documentId, operations, options, }) => {
+            return documentId
+                ? this.addOperations(driveId, documentId, operations, options)
+                : this.addDriveOperations(driveId, operations, options);
+        },
+        processActionJob: async ({ driveId, documentId, actions, options, }) => {
+            return documentId
+                ? this.addActions(driveId, documentId, actions, options)
+                : this.addDriveActions(driveId, actions, options);
+        },
+        processJob: async (job) => {
+            if (isOperationJob(job)) {
+                return this.queueDelegate.processOperationJob(job);
+            }
+            else if (isActionJob(job)) {
+                return this.queueDelegate.processActionJob(job);
+            }
+            else {
+                throw new Error("Unknown job type", job);
+            }
+        },
+    };
+    async _initializeDrive(driveId) {
+        const drive = await this.getDrive(driveId);
+        await this.synchronizationManager.initializeDriveSyncStatus(driveId, drive);
+        if (this.shouldSyncRemoteDrive(drive)) {
+            await this.startSyncRemoteDrive(driveId);
+        }
+        for (const zodListener of drive.state.local.listeners) {
+            const transmitter = this.transmitterFactory.instance(zodListener.callInfo?.transmitterType ?? "", {
+                driveId,
+                listenerId: zodListener.listenerId,
+                block: zodListener.block,
+                filter: zodListener.filter,
+                system: zodListener.system,
+                label: zodListener.label ?? "",
+                callInfo: zodListener.callInfo ?? undefined,
+            }, this);
+            await this.listenerManager.setListener(driveId, {
+                block: zodListener.block,
+                driveId: drive.state.global.id,
+                filter: {
+                    branch: zodListener.filter.branch ?? [],
+                    documentId: zodListener.filter.documentId ?? [],
+                    documentType: zodListener.filter.documentType,
+                    scope: zodListener.filter.scope ?? [],
+                },
+                listenerId: zodListener.listenerId,
+                callInfo: zodListener.callInfo ?? undefined,
+                system: zodListener.system,
+                label: zodListener.label ?? "",
+                transmitter,
+            });
+        }
+    }
+    // Delegate synchronization methods to synchronizationManager
+    getSynchronizationUnits(driveId, documentId, scope, branch, documentType) {
+        return this.synchronizationManager.getSynchronizationUnits(driveId, documentId, scope, branch, documentType);
+    }
+    getSynchronizationUnitsIds(driveId, documentId, scope, branch, documentType) {
+        return this.synchronizationManager.getSynchronizationUnitsIds(driveId, documentId, scope, branch, documentType);
+    }
+    getOperationData(driveId, syncId, filter) {
+        return this.synchronizationManager.getOperationData(driveId, syncId, filter);
+    }
+    getSynchronizationUnitsRevision(driveId, syncUnitsQuery) {
+        return this.synchronizationManager.getSynchronizationUnitsRevision(driveId, syncUnitsQuery);
+    }
+    getDocumentModelModule(documentType) {
+        const documentModelModule = this.documentModelModules.find((module) => module.documentModel.id === documentType);
+        if (!documentModelModule) {
+            throw new Error(`Document type ${documentType} not supported`);
+        }
+        return documentModelModule;
+    }
+    getDocumentModelModules() {
+        return [...this.documentModelModules];
+    }
+    async addDrive(input, preferredEditor) {
+        const id = input.global.id || generateUUID();
+        if (!id) {
+            throw new Error("Invalid Drive Id");
+        }
+        const drives = await this.storage.getDrives();
+        if (drives.includes(id)) {
+            throw new DriveAlreadyExistsError(id);
+        }
+        const document = createDocument({
+            state: input,
+        });
+        document.meta = {
+            preferredEditor: preferredEditor,
+        };
+        await this.storage.createDrive(id, document);
+        if (input.global.slug) {
+            await this.cache.deleteDocument("drives-slug", input.global.slug);
+        }
+        await this._initializeDrive(id);
+        this.eventEmitter.emit("driveAdded", document);
+        return document;
+    }
+    async addRemoteDrive(url, options) {
+        const { id, name, slug, icon, meta } = options.expectedDriveInfo || (await requestPublicDrive(url));
+        const { pullFilter, pullInterval, availableOffline, sharingType, listeners, triggers, } = options;
+        const pullTrigger = await PullResponderTransmitter.createPullResponderTrigger(id, url, {
+            pullFilter,
+            pullInterval,
+        });
+        return await this.addDrive({
+            global: {
+                id: id,
+                name,
+                slug,
+                icon: icon ?? null,
+            },
+            local: {
+                triggers: [...triggers, pullTrigger],
+                listeners: listeners,
+                availableOffline,
+                sharingType,
+            },
+        }, meta?.preferredEditor);
+    }
+    async registerPullResponderTrigger(driveId, url, options) {
+        const pullTrigger = await PullResponderTransmitter.createPullResponderTrigger(driveId, url, options);
+        return pullTrigger;
+    }
+    async deleteDrive(driveId) {
+        const result = await Promise.allSettled([
+            this.stopSyncRemoteDrive(driveId),
+            this.listenerManager.removeDrive(driveId),
+            this.cache.deleteDocument("drives", driveId),
+            this.storage.deleteDrive(driveId),
+        ]);
+        result.forEach((r) => {
+            if (r.status === "rejected") {
+                throw r.reason;
+            }
+        });
+    }
+    getDrives() {
+        return this.storage.getDrives();
+    }
+    async getDrive(driveId, options) {
+        let document;
+        try {
+            const cachedDocument = await this.cache.getDocument("drives", driveId); // TODO support GetDocumentOptions
+            if (cachedDocument && isDocumentDrive(cachedDocument)) {
+                document = cachedDocument;
+                if (isAtRevision(document, options?.revisions)) {
+                    return document;
+                }
+            }
+        }
+        catch (e) {
+            logger.error("Error getting drive from cache", e);
+        }
+        const driveStorage = document ?? (await this.storage.getDrive(driveId));
+        const result = this._buildDocument(driveStorage, options);
+        if (!isDocumentDrive(result)) {
+            throw new Error(`Document with id ${driveId} is not a Document Drive`);
+        }
+        else {
+            if (!options?.revisions) {
+                this.cache.setDocument("drives", driveId, result).catch(logger.error);
+            }
+            return result;
+        }
+    }
+    async getDriveBySlug(slug, options) {
+        try {
+            const document = await this.cache.getDocument("drives-slug", slug);
+            if (document && isDocumentDrive(document)) {
+                return document;
+            }
+        }
+        catch (e) {
+            logger.error("Error getting drive from cache", e);
+        }
+        const driveStorage = await this.storage.getDriveBySlug(slug);
+        const document = this._buildDocument(driveStorage, options);
+        if (!isDocumentDrive(document)) {
+            throw new Error(`Document with slug ${slug} is not a Document Drive`);
+        }
+        else {
+            this.cache.setDocument("drives-slug", slug, document).catch(logger.error);
+            return document;
+        }
+    }
+    async getDocument(driveId, documentId, options) {
+        let cachedDocument;
+        try {
+            cachedDocument = await this.cache.getDocument(driveId, documentId); // TODO support GetDocumentOptions
+            if (cachedDocument && isAtRevision(cachedDocument, options?.revisions)) {
+                return cachedDocument;
+            }
+        }
+        catch (e) {
+            logger.error("Error getting document from cache", e);
+        }
+        const documentStorage = cachedDocument ??
+            (await this.storage.getDocument(driveId, documentId));
+        const document = this._buildDocument(documentStorage, options);
+        if (!options?.revisions) {
+            this.cache.setDocument(driveId, documentId, document).catch(logger.error);
+        }
+        return document;
+    }
+    getDocuments(driveId) {
+        return this.storage.getDocuments(driveId);
+    }
+    async createDocument(driveId, input) {
+        // if a document was provided then checks if it's valid
+        let state = undefined;
+        if (input.document) {
+            if (input.documentType !== input.document.documentType) {
+                throw new Error(`Provided document is not ${input.documentType}`);
+            }
+            const doc = this._buildDocument(input.document);
+            state = doc.state;
+        }
+        // if no document was provided then create a new one
+        const document = input.document ??
+            this.getDocumentModelModule(input.documentType).utils.createDocument();
+        // stores document information
+        const documentStorage = {
+            name: document.name,
+            revision: document.revision,
+            documentType: document.documentType,
+            created: document.created,
+            lastModified: document.lastModified,
+            operations: { global: [], local: [] },
+            initialState: document.initialState,
+            clipboard: [],
+            state: state ?? document.state,
+        };
+        await this.storage.createDocument(driveId, input.id, documentStorage);
+        // set initial state for new syncUnits
+        for (const syncUnit of input.synchronizationUnits) {
+            this.synchronizationManager.updateSyncStatus(syncUnit.syncId, {
+                pull: this.triggerMap.get(driveId) ? "INITIAL_SYNC" : undefined,
+                push: this.listenerManager.driveHasListeners(driveId)
+                    ? "SUCCESS"
+                    : undefined,
+            });
+        }
+        // if the document contains operations then
+        // stores the operations in the storage
+        const operations = Object.values(document.operations).flat();
+        if (operations.length) {
+            if (isDocumentDrive(document)) {
+                await this.storage.addDriveOperations(driveId, operations, document);
+            }
+            else {
+                await this.storage.addDocumentOperations(driveId, input.id, operations, document);
+            }
+        }
+        return document;
+    }
+    async deleteDocument(driveId, documentId) {
+        try {
+            const syncUnits = await this.getSynchronizationUnitsIds(driveId, [
+                documentId,
+            ]);
+            // remove document sync units status when a document is deleted
+            for (const syncUnit of syncUnits) {
+                this.synchronizationManager.updateSyncStatus(syncUnit.syncId, null);
+            }
+            await this.listenerManager.removeSyncUnits(driveId, syncUnits);
+        }
+        catch (error) {
+            logger.warn("Error deleting document", error);
+        }
+        await this.cache.deleteDocument(driveId, documentId);
+        return this.storage.deleteDocument(driveId, documentId);
+    }
+    async _processOperations(driveId, documentId, documentStorage, operations) {
+        const operationsApplied = [];
+        const signals = [];
+        const documentStorageWithState = await this._addDocumentResultingStage(documentStorage, driveId, documentId);
+        let document = this._buildDocument(documentStorageWithState);
+        let error; // TODO: replace with an array of errors/consistency issues
+        const operationsByScope = groupOperationsByScope(operations);
+        for (const scope of Object.keys(operationsByScope)) {
+            const storageDocumentOperations = documentStorage.operations[scope];
+            // TODO two equal operations done by two clients will be considered the same, ie: { type: "INCREMENT" }
+            const branch = removeExistingOperations(operationsByScope[scope] || [], storageDocumentOperations);
+            // No operations to apply
+            if (branch.length < 1) {
+                continue;
+            }
+            const trunk = garbageCollect(sortOperations(storageDocumentOperations));
+            const [invertedTrunk, tail] = attachBranch(trunk, branch);
+            const newHistory = tail.length < 1
+                ? invertedTrunk
+                : merge(trunk, invertedTrunk, reshuffleByTimestamp);
+            const newOperations = newHistory.filter((op) => trunk.length < 1 || precedes(trunk[trunk.length - 1], op));
+            for (const nextOperation of newOperations) {
+                let skipHashValidation = false;
+                // when dealing with a merge (tail.length > 0) we have to skip hash validation
+                // for the operations that were re-indexed (previous hash becomes invalid due the new position in the history)
+                if (tail.length > 0) {
+                    const sourceOperation = operations.find((op) => op.hash === nextOperation.hash);
+                    skipHashValidation =
+                        !sourceOperation ||
+                            sourceOperation.index !== nextOperation.index ||
+                            sourceOperation.skip !== nextOperation.skip;
+                }
+                try {
+                    // runs operation on next available tick, to avoid blocking the main thread
+                    const taskQueueMethod = this.options.taskQueueMethod;
+                    const task = () => this._performOperation(driveId, documentId, document, nextOperation, skipHashValidation);
+                    const appliedResult = await (taskQueueMethod
+                        ? runAsapAsync(task, taskQueueMethod)
+                        : task());
+                    document = appliedResult.document;
+                    signals.push(...appliedResult.signals);
+                    operationsApplied.push(appliedResult.operation);
+                    // TODO what to do if one of the applied operations has an error?
+                }
+                catch (e) {
+                    error =
+                        e instanceof OperationError
+                            ? e
+                            : new OperationError("ERROR", nextOperation, e.message, e.cause);
+                    // TODO: don't break on errors...
+                    break;
+                }
+            }
+        }
+        return {
+            document,
+            operationsApplied,
+            signals,
+            error,
+        };
+    }
+    async _addDocumentResultingStage(document, driveId, documentId, options) {
+        // apply skip header operations to all scopes
+        const operations = options?.revisions !== undefined
+            ? filterOperationsByRevision(document.operations, options.revisions)
+            : document.operations;
+        const documentOperations = garbageCollectDocumentOperations(operations);
+        for (const scope of Object.keys(documentOperations)) {
+            const lastRemainingOperation = documentOperations[scope].at(-1);
+            // if the latest operation doesn't have a resulting state then tries
+            // to retrieve it from the db to avoid rerunning all the operations
+            if (lastRemainingOperation && !lastRemainingOperation.resultingState) {
+                lastRemainingOperation.resultingState = await (documentId
+                    ? this.storage.getOperationResultingState?.(driveId, documentId, lastRemainingOperation.index, lastRemainingOperation.scope, "main")
+                    : this.storage.getDriveOperationResultingState?.(driveId, lastRemainingOperation.index, lastRemainingOperation.scope, "main"));
+            }
+        }
+        return {
+            ...document,
+            operations: documentOperations,
+        };
+    }
+    _buildDocument(documentStorage, options) {
+        if (documentStorage.state &&
+            (!options || options.checkHashes === false) &&
+            isAtRevision(documentStorage, options?.revisions)) {
+            return documentStorage;
+        }
+        const documentModelModule = this.getDocumentModelModule(documentStorage.documentType);
+        const revisionOperations = options?.revisions !== undefined
+            ? filterOperationsByRevision(documentStorage.operations, options.revisions)
+            : documentStorage.operations;
+        const operations = garbageCollectDocumentOperations(revisionOperations);
+        return replayDocument(documentStorage.initialState, operations, documentModelModule.reducer, undefined, documentStorage, undefined, {
+            ...options,
+            checkHashes: options?.checkHashes ?? true,
+            reuseOperationResultingState: options?.checkHashes ?? true,
+        });
+    }
+    async _performOperation(driveId, documentId, document, operation, skipHashValidation = false) {
+        const documentModelModule = this.getDocumentModelModule(document.documentType);
+        const signalResults = [];
+        let newDocument = document;
+        const scope = operation.scope;
+        const documentOperations = garbageCollectDocumentOperations({
+            ...document.operations,
+            [scope]: skipHeaderOperations(document.operations[scope], operation),
+        });
+        const lastRemainingOperation = documentOperations[scope].at(-1);
+        // if the latest operation doesn't have a resulting state then tries
+        // to retrieve it from the db to avoid rerunning all the operations
+        if (lastRemainingOperation && !lastRemainingOperation.resultingState) {
+            lastRemainingOperation.resultingState = await (documentId
+                ? this.storage.getOperationResultingState?.(driveId, documentId, lastRemainingOperation.index, lastRemainingOperation.scope, "main")
+                : this.storage.getDriveOperationResultingState?.(driveId, lastRemainingOperation.index, lastRemainingOperation.scope, "main"));
+        }
+        const operationSignals = [];
+        newDocument = documentModelModule.reducer(newDocument, operation, (signal) => {
+            let handler = undefined;
+            switch (signal.type) {
+                case "CREATE_CHILD_DOCUMENT":
+                    handler = () => this.createDocument(driveId, signal.input);
+                    break;
+                case "DELETE_CHILD_DOCUMENT":
+                    handler = () => this.deleteDocument(driveId, signal.input.id);
+                    break;
+                case "COPY_CHILD_DOCUMENT":
+                    handler = () => this.getDocument(driveId, signal.input.id).then((documentToCopy) => this.createDocument(driveId, {
+                        id: signal.input.newId,
+                        documentType: documentToCopy.documentType,
+                        document: documentToCopy,
+                        synchronizationUnits: signal.input.synchronizationUnits,
+                    }));
+                    break;
+            }
+            if (handler) {
+                operationSignals.push(() => handler().then((result) => ({ signal, result })));
+            }
+        }, { skip: operation.skip, reuseOperationResultingState: true });
+        const appliedOperations = newDocument.operations[operation.scope].filter((op) => op.index == operation.index && op.skip == operation.skip);
+        const appliedOperation = appliedOperations.at(0);
+        if (!appliedOperation) {
+            throw new OperationError("ERROR", operation, `Operation with index ${operation.index}:${operation.skip} was not applied.`);
+        }
+        if (!appliedOperation.error &&
+            appliedOperation.hash !== operation.hash &&
+            !skipHashValidation) {
+            throw new ConflictOperationError(operation, appliedOperation);
+        }
+        for (const signalHandler of operationSignals) {
+            const result = await signalHandler();
+            signalResults.push(result);
+        }
+        return {
+            document: newDocument,
+            signals: signalResults,
+            operation: appliedOperation,
+        };
+    }
+    addOperation(driveId, documentId, operation, options) {
+        return this.addOperations(driveId, documentId, [operation], options);
+    }
+    async _addOperations(driveId, documentId, callback) {
+        if (!this.storage.addDocumentOperationsWithTransaction) {
+            const documentStorage = await this.storage.getDocument(driveId, documentId);
+            const result = await callback(documentStorage);
+            // saves the applied operations to storage
+            if (result.operations.length > 0) {
+                await this.storage.addDocumentOperations(driveId, documentId, result.operations, result.header);
+            }
+        }
+        else {
+            await this.storage.addDocumentOperationsWithTransaction(driveId, documentId, callback);
+        }
+    }
+    queueOperation(driveId, documentId, operation, options) {
+        return this.queueOperations(driveId, documentId, [operation], options);
+    }
+    async resultIfExistingOperations(drive, id, operations) {
+        try {
+            const document = await this.getDocument(drive, id);
+            const newOperation = operations.find((op) => !op.id ||
+                !document.operations[op.scope].find((existingOp) => existingOp.id === op.id &&
+                    existingOp.index === op.index &&
+                    existingOp.type === op.type &&
+                    existingOp.hash === op.hash));
+            if (!newOperation) {
+                return {
+                    status: "SUCCESS",
+                    document,
+                    operations,
+                    signals: [],
+                };
+            }
+            else {
+                return undefined;
+            }
+        }
+        catch (error) {
+            if (!error.message.includes(`Document with id ${id} not found`)) {
+                console.error(error);
+            }
+            return undefined;
+        }
+    }
+    async queueOperations(driveId, documentId, operations, options) {
+        // if operations are already stored then returns cached document
+        const result = await this.resultIfExistingOperations(driveId, documentId, operations);
+        if (result) {
+            return result;
+        }
+        try {
+            const jobId = await this.queueManager.addJob({
+                driveId: driveId,
+                documentId: documentId,
+                operations,
+                options,
+            });
+            return new Promise((resolve, reject) => {
+                const unsubscribe = this.queueManager.on("jobCompleted", (job, result) => {
+                    if (job.jobId === jobId) {
+                        unsubscribe();
+                        unsubscribeError();
+                        resolve(result);
+                    }
+                });
+                const unsubscribeError = this.queueManager.on("jobFailed", (job, error) => {
+                    if (job.jobId === jobId) {
+                        unsubscribe();
+                        unsubscribeError();
+                        reject(error);
+                    }
+                });
+            });
+        }
+        catch (error) {
+            logger.error("Error adding job", error);
+            throw error;
+        }
+    }
+    async queueAction(driveId, documentId, action, options) {
+        return this.queueActions(driveId, documentId, [action], options);
+    }
+    async queueActions(driveId, documentId, actions, options) {
+        try {
+            const jobId = await this.queueManager.addJob({
+                driveId: driveId,
+                documentId: documentId,
+                actions,
+                options,
+            });
+            return new Promise((resolve, reject) => {
+                const unsubscribe = this.queueManager.on("jobCompleted", (job, result) => {
+                    if (job.jobId === jobId) {
+                        unsubscribe();
+                        unsubscribeError();
+                        resolve(result);
+                    }
+                });
+                const unsubscribeError = this.queueManager.on("jobFailed", (job, error) => {
+                    if (job.jobId === jobId) {
+                        unsubscribe();
+                        unsubscribeError();
+                        reject(error);
+                    }
+                });
+            });
+        }
+        catch (error) {
+            logger.error("Error adding job", error);
+            throw error;
+        }
+    }
+    async queueDriveAction(driveId, action, options) {
+        return this.queueDriveActions(driveId, [action], options);
+    }
+    async queueDriveActions(driveId, actions, options) {
+        try {
+            const jobId = await this.queueManager.addJob({
+                driveId: driveId,
+                actions,
+                options,
+            });
+            return new Promise((resolve, reject) => {
+                const unsubscribe = this.queueManager.on("jobCompleted", (job, result) => {
+                    if (job.jobId === jobId) {
+                        unsubscribe();
+                        unsubscribeError();
+                        resolve(result);
+                    }
+                });
+                const unsubscribeError = this.queueManager.on("jobFailed", (job, error) => {
+                    if (job.jobId === jobId) {
+                        unsubscribe();
+                        unsubscribeError();
+                        reject(error);
+                    }
+                });
+            });
+        }
+        catch (error) {
+            logger.error("Error adding drive job", error);
+            throw error;
+        }
+    }
+    async addOperations(driveId, documentId, operations, options) {
+        // if operations are already stored then returns the result
+        const result = await this.resultIfExistingOperations(driveId, documentId, operations);
+        if (result) {
+            return result;
+        }
+        let document;
+        const operationsApplied = [];
+        const signals = [];
+        let error;
+        try {
+            await this._addOperations(driveId, documentId, async (documentStorage) => {
+                const result = await this._processOperations(driveId, documentId, documentStorage, operations);
+                if (!result.document) {
+                    logger.error("Invalid document");
+                    throw result.error ?? new Error("Invalid document");
+                }
+                document = result.document;
+                error = result.error;
+                signals.push(...result.signals);
+                operationsApplied.push(...result.operationsApplied);
+                return {
+                    operations: result.operationsApplied,
+                    header: result.document,
+                    newState: document.state,
+                };
+            });
+            if (document) {
+                this.cache
+                    .setDocument(driveId, documentId, document)
+                    .catch(logger.error);
+            }
+            // gets all the different scopes and branches combinations from the operations
+            const { scopes, branches } = operationsApplied.reduce((acc, operation) => {
+                if (!acc.scopes.includes(operation.scope)) {
+                    acc.scopes.push(operation.scope);
+                }
+                return acc;
+            }, { scopes: [], branches: ["main"] });
+            const syncUnits = await this.getSynchronizationUnits(driveId, [documentId], scopes, branches);
+            // checks if any of the provided operations where reshufled
+            const newOp = operationsApplied.find((appliedOp) => !operations.find((o) => o.id === appliedOp.id &&
+                o.index === appliedOp.index &&
+                o.skip === appliedOp.skip &&
+                o.hash === appliedOp.hash));
+            // if there are no new operations then reuses the provided source
+            // otherwise sets it to local so listeners know that there were
+            // new changes originating from this document drive server
+            const source = newOp
+                ? { type: "local" }
+                : (options?.source ?? { type: "local" });
+            // update listener cache
+            const operationSource = this.getOperationSource(source);
+            this.listenerManager
+                .updateSynchronizationRevisions(driveId, syncUnits, source, () => {
+                this.synchronizationManager.updateSyncStatus(driveId, {
+                    [operationSource]: "SYNCING",
+                });
+                for (const syncUnit of syncUnits) {
+                    this.synchronizationManager.updateSyncStatus(syncUnit.syncId, {
+                        [operationSource]: "SYNCING",
+                    });
+                }
+            }, this.handleListenerError.bind(this), options?.forceSync ?? source.type === "local")
+                .then((updates) => {
+                if (updates.length) {
+                    this.synchronizationManager.updateSyncStatus(driveId, {
+                        [operationSource]: "SUCCESS",
+                    });
+                }
+                for (const syncUnit of syncUnits) {
+                    this.synchronizationManager.updateSyncStatus(syncUnit.syncId, {
+                        [operationSource]: "SUCCESS",
+                    });
+                }
+            })
+                .catch((error) => {
+                logger.error("Non handled error updating sync revision", error);
+                this.synchronizationManager.updateSyncStatus(driveId, {
+                    [operationSource]: "ERROR",
+                }, error);
+                for (const syncUnit of syncUnits) {
+                    this.synchronizationManager.updateSyncStatus(syncUnit.syncId, {
+                        [operationSource]: "ERROR",
+                    }, error);
+                }
+            });
+            // after applying all the valid operations,throws
+            // an error if there was an invalid operation
+            if (error) {
+                throw error;
+            }
+            return {
+                status: "SUCCESS",
+                document,
+                operations: operationsApplied,
+                signals,
+            };
+        }
+        catch (error) {
+            const operationError = error instanceof OperationError
+                ? error
+                : new OperationError("ERROR", undefined, error.message, error.cause);
+            return {
+                status: operationError.status,
+                error: operationError,
+                document,
+                operations: operationsApplied,
+                signals,
+            };
+        }
+    }
+    addDriveOperation(driveId, operation, options) {
+        return this.addDriveOperations(driveId, [operation], options);
+    }
+    async clearStorage() {
+        for (const drive of await this.getDrives()) {
+            await this.deleteDrive(drive);
+        }
+        await this.storage.clearStorage?.();
+    }
+    async _addDriveOperations(driveId, callback) {
+        if (!this.storage.addDriveOperationsWithTransaction) {
+            const documentStorage = await this.storage.getDrive(driveId);
+            const result = await callback(documentStorage);
+            // saves the applied operations to storage
+            if (result.operations.length > 0) {
+                await this.storage.addDriveOperations(driveId, result.operations, result.header);
+            }
+            return result;
+        }
+        else {
+            return this.storage.addDriveOperationsWithTransaction(driveId, callback);
+        }
+    }
+    queueDriveOperation(driveId, operation, options) {
+        return this.queueDriveOperations(driveId, [operation], options);
+    }
+    async resultIfExistingDriveOperations(driveId, operations) {
+        try {
+            const drive = await this.getDrive(driveId);
+            const newOperation = operations.find((op) => !op.id ||
+                !drive.operations[op.scope].find((existingOp) => existingOp.id === op.id &&
+                    existingOp.index === op.index &&
+                    existingOp.type === op.type &&
+                    existingOp.hash === op.hash));
+            if (!newOperation) {
+                return {
+                    status: "SUCCESS",
+                    document: drive,
+                    operations: operations,
+                    signals: [],
+                };
+            }
+            else {
+                return undefined;
+            }
+        }
+        catch (error) {
+            console.error(error); // TODO error
+            return undefined;
+        }
+    }
+    async queueDriveOperations(driveId, operations, options) {
+        // if operations are already stored then returns cached document
+        const result = await this.resultIfExistingDriveOperations(driveId, operations);
+        if (result) {
+            return result;
+        }
+        try {
+            const jobId = await this.queueManager.addJob({
+                driveId: driveId,
+                operations,
+                options,
+            });
+            return new Promise((resolve, reject) => {
+                const unsubscribe = this.queueManager.on("jobCompleted", (job, result) => {
+                    if (job.jobId === jobId) {
+                        unsubscribe();
+                        unsubscribeError();
+                        resolve(result);
+                    }
+                });
+                const unsubscribeError = this.queueManager.on("jobFailed", (job, error) => {
+                    if (job.jobId === jobId) {
+                        unsubscribe();
+                        unsubscribeError();
+                        reject(error);
+                    }
+                });
+            });
+        }
+        catch (error) {
+            logger.error("Error adding drive job", error);
+            throw error;
+        }
+    }
+    async addDriveOperations(driveId, operations, options) {
+        let document;
+        const operationsApplied = [];
+        const signals = [];
+        let error;
+        // if operations are already stored then returns cached drive
+        const result = await this.resultIfExistingDriveOperations(driveId, operations);
+        if (result) {
+            return result;
+        }
+        try {
+            await this._addDriveOperations(driveId, async (documentStorage) => {
+                const result = await this._processOperations(driveId, undefined, documentStorage, operations.slice());
+                document = result.document;
+                operationsApplied.push(...result.operationsApplied);
+                signals.push(...result.signals);
+                error = result.error;
+                return {
+                    operations: result.operationsApplied,
+                    header: result.document,
+                };
+            });
+            if (!document || !isDocumentDrive(document)) {
+                throw error ?? new Error("Invalid Document Drive document");
+            }
+            this.cache.setDocument("drives", driveId, document).catch(logger.error);
+            for (const operation of operationsApplied) {
+                switch (operation.type) {
+                    case "ADD_LISTENER": {
+                        const zodListener = operation.input.listener;
+                        // create the transmitter
+                        const transmitter = this.transmitterFactory.instance(zodListener.callInfo?.transmitterType ?? "", {
+                            driveId,
+                            listenerId: zodListener.listenerId,
+                            block: zodListener.block,
+                            filter: zodListener.filter,
+                            system: zodListener.system,
+                            label: zodListener.label ?? "",
+                            callInfo: zodListener.callInfo ?? undefined,
+                        }, this);
+                        // create the listener
+                        const listener = {
+                            ...zodListener,
+                            driveId: driveId,
+                            label: zodListener.label ?? "",
+                            system: zodListener.system ?? false,
+                            filter: {
+                                branch: zodListener.filter.branch ?? [],
+                                documentId: zodListener.filter.documentId ?? [],
+                                documentType: zodListener.filter.documentType ?? [],
+                                scope: zodListener.filter.scope ?? [],
+                            },
+                            callInfo: {
+                                data: zodListener.callInfo?.data ?? "",
+                                name: zodListener.callInfo?.name ?? "PullResponder",
+                                transmitterType: zodListener.callInfo?.transmitterType ?? "PullResponder",
+                            },
+                            transmitter,
+                        };
+                        await this.addListener(driveId, listener);
+                        break;
+                    }
+                    case "REMOVE_LISTENER": {
+                        await this.removeListener(driveId, operation);
+                        break;
+                    }
+                }
+            }
+            // update listener cache
+            const lastOperation = operationsApplied
+                .filter((op) => op.scope === "global")
+                .slice()
+                .pop();
+            if (lastOperation) {
+                // checks if any of the provided operations where reshufled
+                const newOp = operationsApplied.find((appliedOp) => !operations.find((o) => o.id === appliedOp.id &&
+                    o.index === appliedOp.index &&
+                    o.skip === appliedOp.skip &&
+                    o.hash === appliedOp.hash));
+                // if there are no new operations then reuses the provided source
+                // otherwise sets it to local so listeners know that there were
+                // new changes originating from this document drive server
+                const source = newOp
+                    ? { type: "local" }
+                    : (options?.source ?? { type: "local" });
+                const operationSource = this.getOperationSource(source);
+                this.listenerManager
+                    .updateSynchronizationRevisions(driveId, [
+                    {
+                        syncId: "0",
+                        driveId: driveId,
+                        documentId: "",
+                        scope: "global",
+                        branch: "main",
+                        documentType: "powerhouse/document-drive",
+                        lastUpdated: lastOperation.timestamp,
+                        revision: lastOperation.index,
+                    },
+                ], source, () => {
+                    this.synchronizationManager.updateSyncStatus(driveId, {
+                        [operationSource]: "SYNCING",
+                    });
+                }, this.handleListenerError.bind(this), options?.forceSync ?? source.type === "local")
+                    .then((updates) => {
+                    if (updates.length) {
+                        this.synchronizationManager.updateSyncStatus(driveId, {
+                            [operationSource]: "SUCCESS",
+                        });
+                    }
+                })
+                    .catch((error) => {
+                    logger.error("Non handled error updating sync revision", error);
+                    this.synchronizationManager.updateSyncStatus(driveId, {
+                        [operationSource]: "ERROR",
+                    }, error);
+                });
+            }
+            if (this.shouldSyncRemoteDrive(document)) {
+                this.startSyncRemoteDrive(driveId);
+            }
+            else {
+                this.stopSyncRemoteDrive(driveId);
+            }
+            // after applying all the valid operations,throws
+            // an error if there was an invalid operation
+            if (error) {
+                throw error;
+            }
+            return {
+                status: "SUCCESS",
+                document,
+                operations: operationsApplied,
+                signals,
+            };
+        }
+        catch (error) {
+            const operationError = error instanceof OperationError
+                ? error
+                : new OperationError("ERROR", undefined, error.message, error.cause);
+            return {
+                status: operationError.status,
+                error: operationError,
+                document,
+                operations: operationsApplied,
+                signals,
+            };
+        }
+    }
+    _buildOperations(documentId, actions) {
+        const operations = [];
+        const { reducer } = this.getDocumentModelModule(documentId.documentType);
+        for (const action of actions) {
+            documentId = reducer(documentId, action);
+            const operation = documentId.operations[action.scope].slice().pop();
+            if (!operation) {
+                throw new Error("Error creating operations");
+            }
+            operations.push(operation);
+        }
+        return operations;
+    }
+    async addAction(driveId, documentId, action, options) {
+        return this.addActions(driveId, documentId, [action], options);
+    }
+    async addActions(driveId, documentId, actions, options) {
+        const document = await this.getDocument(driveId, documentId);
+        const operations = this._buildOperations(document, actions);
+        return this.addOperations(driveId, documentId, operations, options);
+    }
+    async addDriveAction(driveId, action, options) {
+        return this.addDriveActions(driveId, [action], options);
+    }
+    async addDriveActions(driveId, actions, options) {
+        const document = await this.getDrive(driveId);
+        const operations = this._buildOperations(document, actions);
+        const result = await this.addDriveOperations(driveId, operations, options);
+        return result;
+    }
+    async detachDrive(driveId) {
+        const documentDrive = await this.getDrive(driveId);
+        const listeners = documentDrive.state.local.listeners || [];
+        const triggers = documentDrive.state.local.triggers || [];
+        for (const listener of listeners) {
+            await this.addDriveAction(driveId, removeListener({ listenerId: listener.listenerId }));
+        }
+        for (const trigger of triggers) {
+            await this.addDriveAction(driveId, removeTrigger({ triggerId: trigger.id }));
+        }
+        await this.addDriveAction(driveId, setSharingType({ type: "LOCAL" }));
+    }
+    async addListener(driveId, listener) {
+        await this.listenerManager.setListener(driveId, listener);
+    }
+    async addInternalListener(driveId, receiver, options) {
+        const listener = {
+            callInfo: {
+                data: "",
+                name: "Interal",
+                transmitterType: "Internal",
+            },
+            system: true,
+            ...options,
+        };
+        await this.addDriveAction(driveId, addListener({ listener }));
+        const transmitter = await this.getTransmitter(driveId, options.listenerId);
+        if (!transmitter) {
+            logger.error("Internal listener not found");
+            throw new Error("Internal listener not found");
+        }
+        if (!(transmitter instanceof InternalTransmitter)) {
+            logger.error("Listener is not an internal transmitter");
+            throw new Error("Listener is not an internal transmitter");
+        }
+        transmitter.setReceiver(receiver);
+        return transmitter;
+    }
+    async removeListener(driveId, operation) {
+        const { listenerId } = operation.input;
+        await this.listenerManager.removeListener(driveId, listenerId);
+    }
+    async getTransmitter(driveId, listenerId) {
+        const listener = this.listenerManager.getListenerState(driveId, listenerId);
+        return listener.listener.transmitter;
+    }
+    getListener(driveId, listenerId) {
+        let listenerState;
+        try {
+            listenerState = this.listenerManager.getListenerState(driveId, listenerId);
+        }
+        catch {
+            return Promise.resolve(undefined);
+        }
+        return Promise.resolve(listenerState);
+    }
+    getSyncStatus(syncUnitId) {
+        return this.synchronizationManager.getSyncStatus(syncUnitId);
+    }
+    on(event, cb) {
+        return this.eventEmitter.on(event, cb);
+    }
+    emit(event, ...args) {
+        return this.eventEmitter.emit(event, ...args);
+    }
+    getSynchronizationUnit(driveId, syncId) {
+        return this.synchronizationManager.getSynchronizationUnit(driveId, syncId);
+    }
+    // Add delegated methods to properly implement ISynchronizationManager
+    updateSyncStatus(syncUnitId, status, error) {
+        this.synchronizationManager.updateSyncStatus(syncUnitId, status, error);
+    }
+    initializeDriveSyncStatus(driveId, drive) {
+        return this.synchronizationManager.initializeDriveSyncStatus(driveId, drive);
+    }
+    getCombinedSyncUnitStatus(syncUnitStatus) {
+        return this.synchronizationManager.getCombinedSyncUnitStatus(syncUnitStatus);
+    }
+    // Add back the saveStrand method that was accidentally removed
+    async saveStrand(strand, source) {
+        const operations = strand.operations.map((op) => ({
+            ...op,
+            scope: strand.scope,
+            branch: strand.branch,
+        }));
+        const result = await (!strand.documentId
+            ? this.queueDriveOperations(strand.driveId, operations, { source })
+            : this.queueOperations(strand.driveId, strand.documentId, operations, {
+                source,
+            }));
+        if (result.status === "ERROR") {
+            const syncUnits = strand.documentId !== ""
+                ? (await this.getSynchronizationUnitsIds(strand.driveId, [strand.documentId], [strand.scope], [strand.branch])).map((s) => s.syncId)
+                : [strand.driveId];
+            const operationSource = this.getOperationSource(source);
+            for (const syncUnit of syncUnits) {
+                this.synchronizationManager.updateSyncStatus(syncUnit, { [operationSource]: result.status }, result.error);
+            }
+        }
+        this.eventEmitter.emit("strandUpdate", strand);
+        return result;
+    }
+}
+export const DocumentDriveServer = ReadModeServer(BaseDocumentDriveServer);