document-drive 4.0.1 → 4.1.0-dev.2

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

@@ -1,19 +1,19 @@
 import { removeListener, removeTrigger, setSharingType, } from "#drive-document-model/gen/creators";
 import { createDocument } from "#drive-document-model/gen/utils";
-import { isActionJob, isOperationJob, } from "#queue/types";
+import { isActionJob, isDocumentJob, isOperationJob, } from "#queue/types";
 import { ReadModeServer } from "#read-mode/server";
 import { DefaultDrivesManager, } from "#utils/default-drives-manager";
 import { requestPublicDriveWithTokenFromReactor } from "#utils/graphql";
 import { isDocumentDrive, runAsapAsync } from "#utils/misc";
 import { RunAsap } from "#utils/run-asap";
-import { childLogger, } from "document-drive";
+import { DocumentAlreadyExistsError, childLogger, } from "document-drive";
 import { attachBranch, createPresignedHeader, garbageCollect, garbageCollectDocumentOperations, groupOperationsByScope, merge, precedes, removeExistingOperations, replayDocument, reshuffleByTimestamp, skipHeaderOperations, sortOperations, validateHeader, } from "document-model";
 import { ClientError } from "graphql-request";
 import { ConflictOperationError, OperationError, } from "./error.js";
 import { PullResponderTransmitter, } from "./listener/transmitter/pull-responder.js";
 import { SwitchboardPushTransmitter } from "./listener/transmitter/switchboard-push.js";
 import { DefaultListenerManagerOptions, } from "./types.js";
-import { filterOperationsByRevision, isAtRevision } from "./utils.js";
+import { filterOperationsByRevision, isAtRevision, resolveCreateDocumentInput, } from "./utils.js";
 export class BaseDocumentDriveServer {
     logger = childLogger(["BaseDocumentDriveServer"]);
     // external dependencies
@@ -35,15 +35,47 @@ export class BaseDocumentDriveServer {
     };
     queueDelegate = {
         exists: (documentId) => this.documentStorage.exists(documentId),
-        processOperationJob: async ({ driveId, documentId, operations, options, }) => {
-            return !documentId || driveId === documentId
-                ? this.processDriveOperations(driveId, operations, options)
-                : this.processOperations(driveId, documentId, operations, options);
+        processOperationJob: async ({ documentId, operations, options, }) => {
+            const document = await this.getDocument(documentId);
+            return isDocumentDrive(document)
+                ? this.processDriveOperations(documentId, operations, options)
+                : this.processOperations(documentId, operations, options);
         },
-        processActionJob: async ({ driveId, documentId, actions, options, }) => {
-            return documentId
-                ? this.processActions(driveId, documentId, actions, options)
-                : this.processDriveActions(driveId, actions, options);
+        processActionJob: async ({ documentId, actions, options }) => {
+            const document = await this.getDocument(documentId);
+            return isDocumentDrive(document)
+                ? this.processDriveActions(documentId, actions, options)
+                : this.processActions(documentId, actions, options);
+        },
+        processDocumentJob: async ({ documentId, documentType, initialState, options, }) => {
+            const documentModelModule = this.getDocumentModelModule(documentType);
+            const document = documentModelModule.utils.createDocument({
+                ...initialState,
+            });
+            // TODO: header must be included
+            const header = createPresignedHeader(documentId, documentType);
+            document.header.id = documentId;
+            document.header.sig = header.sig;
+            document.header.documentType = documentType;
+            try {
+                const createdDocument = await this.createDocument({ document }, options?.source ?? { type: "local" }, initialState?.header.meta);
+                return {
+                    status: "SUCCESS",
+                    operations: [],
+                    document: createdDocument,
+                    signals: [],
+                };
+            }
+            catch (error) {
+                const cause = error instanceof Error ? error : new Error(JSON.stringify(error));
+                return {
+                    status: "ERROR",
+                    error: new OperationError("ERROR", undefined, `Error creating document: ${cause.message}`, cause),
+                    operations: [],
+                    document: undefined,
+                    signals: [],
+                };
+            }
         },
         processJob: async (job) => {
             if (isOperationJob(job)) {
@@ -52,6 +84,9 @@ export class BaseDocumentDriveServer {
             else if (isActionJob(job)) {
                 return this.queueDelegate.processActionJob(job);
             }
+            else if (isDocumentJob(job)) {
+                return this.queueDelegate.processDocumentJob(job);
+            }
             else {
                 throw new Error("Unknown job type", job);
             }
@@ -98,7 +133,7 @@ export class BaseDocumentDriveServer {
         return this.initializePromise;
     }
     async _initialize() {
-        await this.listenerManager.initialize(this.handleListenerError);
+        await this.listenerManager.initialize(this.handleListenerError.bind(this));
         await this.queueManager.init(this.queueDelegate, (error) => {
             this.logger.error(`Error initializing queue manager`, error);
             errors.push(error);
@@ -153,7 +188,7 @@ export class BaseDocumentDriveServer {
     }
     async startSyncRemoteDrive(driveId) {
         let driveTriggers = this.triggerMap.get(driveId);
-        const syncUnits = await this.getSynchronizationUnitsIds(driveId);
+        const syncUnits = await this.synchronizationManager.getSynchronizationUnitsIds(driveId);
         const drive = await this.getDrive(driveId);
         for (const trigger of drive.state.local.triggers) {
             if (driveTriggers?.get(trigger.id)) {
@@ -166,7 +201,7 @@ export class BaseDocumentDriveServer {
                 pull: "SYNCING",
             });
             for (const syncUnit of syncUnits) {
-                this.synchronizationManager.updateSyncStatus(syncUnit.syncId, {
+                this.synchronizationManager.updateSyncStatus(syncUnit, {
                     pull: "SYNCING",
                 });
             }
@@ -178,46 +213,43 @@ export class BaseDocumentDriveServer {
                     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) {
+                }, async (revisions) => {
+                    const errorRevisions = revisions.filter((r) => r.status !== "SUCCESS");
+                    if (errorRevisions.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);
+                    for (const revision of revisions) {
+                        const { documentId, scope, branch, status, error } = revision;
+                        this.synchronizationManager.updateSyncStatus({ documentId, scope, branch }, { pull: status }, error);
+                    }
                     // if it is the first pull and returns empty
-                    // then updates corresponding push transmitter
+                    // then updates drive documents to "SUCCESS" and
+                    // updates corresponding push transmitter
                     if (firstPull) {
                         firstPull = false;
+                        const syncUnitsIds = await this.synchronizationManager.getSynchronizationUnitsIds(driveId);
+                        const unchangedSyncUnits = syncUnitsIds.filter((syncUnit) => {
+                            return !revisions.find((revision) => {
+                                return (revision.documentId === syncUnit.documentId &&
+                                    revision.scope === syncUnit.scope &&
+                                    revision.branch === syncUnit.branch);
+                            });
+                        });
+                        unchangedSyncUnits.forEach((syncUnit) => {
+                            this.synchronizationManager.updateSyncStatus(syncUnit, {
+                                pull: "SUCCESS",
+                            });
+                        });
                         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(this.logger.error);
-                                }
-                            })
-                                .catch(this.logger.error);
+                            for (const revision of revisions) {
+                                const { documentId, scope, branch } = revision;
+                                this.listenerManager
+                                    .updateListenerRevision(pushListener.listenerId, driveId, { documentId, scope, branch }, revision.revision)
+                                    .catch(this.logger.error);
+                            }
                         }
                     }
                 }, undefined, this.listeners);
@@ -227,15 +259,12 @@ export class BaseDocumentDriveServer {
         }
     }
     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);
+        const syncUnits = await this.synchronizationManager.getSynchronizationUnitsIds(driveId);
+        for (const syncUnit of syncUnits) {
+            this.synchronizationManager.updateSyncStatus(syncUnit, null);
         }
         return this.triggerMap.delete(driveId);
     }
@@ -298,19 +327,6 @@ export class BaseDocumentDriveServer {
             }
         }
     }
-    // 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) {
@@ -321,6 +337,9 @@ export class BaseDocumentDriveServer {
     getDocumentModelModules() {
         return [...this.documentModelModules];
     }
+    addDocument(document, meta) {
+        return this.createDocument({ document }, { type: "local" }, meta);
+    }
     async addDrive(input, preferredEditor) {
         const document = createDocument({
             state: {
@@ -428,6 +447,7 @@ export class BaseDocumentDriveServer {
         }
         else {
             if (!options?.revisions) {
+                this.cache.setDocument(driveId, result).catch(this.logger.error);
                 this.cache.setDrive(driveId, result).catch(this.logger.error);
             }
             return result;
@@ -466,7 +486,12 @@ export class BaseDocumentDriveServer {
         const driveStorage = await this.documentStorage.getBySlug(slug);
         return driveStorage.header.id;
     }
-    async getDocument(driveId, documentId, options) {
+    getDocument(driveId, documentId, options) {
+        const id = typeof documentId === "string" ? documentId : driveId;
+        const resolvedOptions = typeof documentId === "object" ? documentId : options;
+        return this._getDocument(id, resolvedOptions);
+    }
+    async _getDocument(documentId, options) {
         let cachedDocument;
         try {
             cachedDocument = await this.cache.getDocument(documentId); // TODO support GetDocumentOptions
@@ -487,115 +512,166 @@ export class BaseDocumentDriveServer {
     getDocuments(driveId) {
         return this.documentStorage.getChildren(driveId);
     }
-    async createDocument(driveId, input) {
+    async addChild(parentId, documentId) {
+        // TODO: check if document exists? Should that be a concern here?
+        try {
+            await this.documentStorage.addChild(parentId, documentId);
+            // TODO: update listener manager?
+        }
+        catch (e) {
+            this.logger.error("Error adding child document", e);
+            throw e;
+        }
+    }
+    async removeChild(parentId, documentId) {
+        // TODO: check if document exists? Should that be a concern here?
+        // cleanup child sync units state from the parent listeners
+        try {
+            const childSynUnits = await this.synchronizationManager.getSynchronizationUnitsIds(parentId, [
+                documentId,
+            ]);
+            await this.listenerManager.removeSyncUnits(parentId, childSynUnits);
+        }
+        catch (e) {
+            this.logger.warn("Error removing sync units of child", e);
+        }
+        // remove child relationship from storage
+        try {
+            await this.documentStorage.removeChild(parentId, documentId);
+        }
+        catch (e) {
+            this.logger.error("Error adding child document", e);
+            throw e;
+        }
+    }
+    async createDocument(input, source, meta) {
+        const { documentType, document: inputDocument } = resolveCreateDocumentInput(input);
         // if a document was provided then checks if it's valid
         let state = undefined;
-        if (input.document) {
-            if (input.documentType !== input.document.header.documentType) {
-                throw new Error(`Provided document is not ${input.documentType}`);
+        if (inputDocument) {
+            if ("documentType" in input &&
+                documentType !== inputDocument.header.documentType) {
+                throw new Error(`Provided document is not ${documentType}`);
             }
-            const doc = this._buildDocument(input.document);
+            const doc = this._buildDocument(inputDocument);
             state = doc.state;
         }
         // if no document was provided then create a new one
-        const document = input.document ??
-            this.getDocumentModelModule(input.documentType).utils.createDocument();
+        const document = inputDocument ??
+            this.getDocumentModelModule(documentType).utils.createDocument({
+                state,
+            });
         // get the header
         let header;
         // handle the legacy case where an id is provided
-        // eslint-disable-next-line
-        if (input.id && input.id.length > 0) {
-            if (input.document) {
+        if ("id" in input && input.id) {
+            if (inputDocument) {
                 header = document.header;
-                // eslint-disable-next-line
                 document.header.id = input.id;
                 this.logger.warn("Assigning an id to a document is deprecated. Use the header field instead.");
             }
             else {
                 this.logger.warn("Creating a document with an id is deprecated. Use the header field instead.");
-                header = createPresignedHeader();
-                // eslint-disable-next-line
-                header.id = input.id;
-                header.documentType = input.documentType;
+                header = createPresignedHeader(input.id, documentType);
             }
         }
-        else if (input.header) {
+        else if ("header" in input) {
             // validate the header passed in
             await validateHeader(input.header);
             header = input.header;
         }
+        else if (inputDocument?.header) {
+            if (!inputDocument.header.id) {
+                throw new Error("Document header id is required");
+            }
+            if (!inputDocument.header.documentType) {
+                throw new Error("Document header documentType is required");
+            }
+            if (!inputDocument.header.createdAtUtcIso) {
+                throw new Error("Document header createdAtUtcIso is required");
+            }
+            if (!inputDocument.header.sig.nonce) {
+                this.logger.warn("Creating a document with an unsigned id is deprecated. Use createSignedHeaderForSigner.");
+                // throw new Error("Document header sig nonce is required"); TODO: uncomment when ready to enforce signed documents
+            }
+            else {
+                await validateHeader(inputDocument.header);
+            }
+            header = inputDocument.header;
+        }
         else {
             // otherwise, generate a header
-            header = createPresignedHeader();
-            header.documentType = input.documentType;
+            header = createPresignedHeader(undefined, documentType);
+        }
+        if (meta) {
+            header.meta = { ...header.meta, ...meta };
         }
         // stores document information
         const documentStorage = {
             header,
             history: document.history,
-            operations: document.operations,
+            operations: { global: [], local: [] },
             initialState: document.initialState,
             clipboard: [],
+            attachments: document.attachments,
             state: state ?? document.state,
         };
         await this.documentStorage.create(documentStorage);
-        try {
-            await this.documentStorage.addChild(driveId, header.id);
-        }
-        catch (e) {
-            this.logger.error("Error adding child document", e);
-            // revert the document creation
-            try {
-                await this.documentStorage.delete(header.id);
-            }
-            catch (e) {
-                this.logger.error("FATAL: Could not revert document creation. This means that we created a document but failed to add it to the drive..", e);
-            }
-            throw e;
-        }
-        // 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,
-            });
-        }
+        // TODO set initial state for document sync units
+        // if (source.type === "trigger") {
+        //   for (const scope of Object.keys(document.state)) {
+        //     this.synchronizationManager.updateSyncStatus(
+        //       {
+        //         documentId: document.id,
+        //         scope,
+        //         branch: "main" /* TODO handle branches */,
+        //       },
+        //       {
+        //         pull: "INITIAL_SYNC",
+        //         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.legacyStorage.addDriveOperations(driveId, operations, document);
+                await this.legacyStorage.addDriveOperations(header.id, operations, document);
             }
             else {
-                await this.legacyStorage.addDocumentOperations(driveId, header.id, operations, document);
+                await this.legacyStorage.addDocumentOperations(header.id, operations, document);
             }
         }
         return document;
     }
-    async deleteDocument(driveId, documentId) {
+    async deleteDocument(documentId) {
         try {
-            const syncUnits = await this.getSynchronizationUnitsIds(driveId, [
-                documentId,
-            ]);
+            const syncUnits = await this.synchronizationManager.getSynchronizationUnitsIds(undefined, [documentId]);
             // remove document sync units status when a document is deleted
             for (const syncUnit of syncUnits) {
-                this.synchronizationManager.updateSyncStatus(syncUnit.syncId, null);
+                this.synchronizationManager.updateSyncStatus(syncUnit, null);
+            }
+            const parents = await this.documentStorage.getParents(documentId);
+            for (const parent of parents) {
+                this.listenerManager
+                    .removeSyncUnits(parent, syncUnits)
+                    .catch(this.logger.warn);
             }
-            await this.listenerManager.removeSyncUnits(driveId, syncUnits);
         }
         catch (error) {
             this.logger.warn("Error deleting document", error);
         }
         await this.cache.deleteDocument(documentId);
-        return this.documentStorage.delete(documentId);
+        await this.documentStorage.delete(documentId);
     }
-    async _processOperations(driveId, documentId, documentStorage, operations) {
+    async _processOperations(documentId, documentStorage, operations) {
         const operationsApplied = [];
         const signals = [];
-        const documentStorageWithState = await this._addDocumentResultingStage(documentStorage, driveId, documentId);
+        const documentStorageWithState = await this._addDocumentResultingStage(documentStorage, documentId);
         let document = this._buildDocument(documentStorageWithState);
         let error; // TODO: replace with an array of errors/consistency issues
         const operationsByScope = groupOperationsByScope(operations);
@@ -627,7 +703,7 @@ export class BaseDocumentDriveServer {
                 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 task = () => this._performOperation(documentId, document, nextOperation, skipHashValidation);
                     const appliedResult = await (taskQueueMethod
                         ? runAsapAsync(task, taskQueueMethod)
                         : task());
@@ -653,7 +729,7 @@ export class BaseDocumentDriveServer {
             error,
         };
     }
-    async _addDocumentResultingStage(document, driveId, documentId, options) {
+    async _addDocumentResultingStage(document, documentId, options) {
         // apply skip header operations to all scopes
         const operations = options?.revisions !== undefined
             ? filterOperationsByRevision(document.operations, options.revisions)
@@ -664,9 +740,9 @@ export class BaseDocumentDriveServer {
             // 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.legacyStorage.getOperationResultingState?.(driveId, documentId, lastRemainingOperation.index, lastRemainingOperation.scope, "main")
-                    : this.legacyStorage.getDriveOperationResultingState?.(driveId, lastRemainingOperation.index, lastRemainingOperation.scope, "main"));
+                lastRemainingOperation.resultingState = await (isDocumentDrive(document)
+                    ? this.legacyStorage.getOperationResultingState?.(documentId, lastRemainingOperation.index, lastRemainingOperation.scope, "main")
+                    : this.legacyStorage.getDriveOperationResultingState?.(documentId, lastRemainingOperation.index, lastRemainingOperation.scope, "main"));
             }
         }
         return {
@@ -691,7 +767,7 @@ export class BaseDocumentDriveServer {
             reuseOperationResultingState: options?.checkHashes ?? true,
         });
     }
-    async _performOperation(driveId, documentId, document, operation, skipHashValidation = false) {
+    async _performOperation(documentId, document, operation, skipHashValidation = false) {
         const documentModelModule = this.getDocumentModelModule(document.header.documentType);
         const signalResults = [];
         let newDocument = document;
@@ -704,36 +780,22 @@ export class BaseDocumentDriveServer {
         // 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.legacyStorage.getOperationResultingState?.(driveId, documentId, lastRemainingOperation.index, lastRemainingOperation.scope, "main")
-                : this.legacyStorage.getDriveOperationResultingState?.(driveId, lastRemainingOperation.index, lastRemainingOperation.scope, "main"));
+            lastRemainingOperation.resultingState = await (isDocumentDrive(document)
+                ? this.legacyStorage.getOperationResultingState?.(documentId, lastRemainingOperation.index, lastRemainingOperation.scope, "main")
+                : this.legacyStorage.getDriveOperationResultingState?.(documentId, 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);
+                    handler = () => this.addChild(documentId, signal.input.id);
                     break;
                 case "DELETE_CHILD_DOCUMENT":
-                    handler = () => this.deleteDocument(driveId, signal.input.id);
+                    handler = () => this.removeChild(documentId, signal.input.id);
                     break;
                 case "COPY_CHILD_DOCUMENT":
-                    handler = () => this.getDocument(driveId, signal.input.id).then((documentToCopy) => {
-                        const doc = {
-                            ...documentToCopy,
-                            header: {
-                                ...documentToCopy.header,
-                                slug: signal.input.newId,
-                            },
-                        };
-                        return this.createDocument(driveId, {
-                            id: signal.input.newId,
-                            documentType: documentToCopy.header.documentType,
-                            document: doc,
-                            synchronizationUnits: signal.input.synchronizationUnits,
-                        });
-                    });
+                    handler = () => this.addChild(documentId, signal.input.newId);
                     break;
             }
             if (handler) {
@@ -748,6 +810,7 @@ export class BaseDocumentDriveServer {
         if (!appliedOperation.error &&
             appliedOperation.hash !== operation.hash &&
             !skipHashValidation) {
+            this.logger.warn(JSON.stringify(appliedOperation, null, 2));
             throw new ConflictOperationError(operation, appliedOperation);
         }
         for (const signalHandler of operationSignals) {
@@ -760,28 +823,103 @@ export class BaseDocumentDriveServer {
             operation: appliedOperation,
         };
     }
-    addOperation(driveId, documentId, operation, options) {
-        return this.addOperations(driveId, documentId, [operation], options);
+    addOperation(driveIdOrDocumentId, documentIdOrOperation, operationOrOptions, maybeOptions) {
+        let documentId;
+        let operation;
+        let options;
+        if (typeof documentIdOrOperation === "string") {
+            // Deprecated overload: (driveId, documentId, operation, options)
+            documentId = documentIdOrOperation;
+            operation = operationOrOptions;
+            options = maybeOptions;
+        }
+        else {
+            // Standard overload: (documentId, operation, options)
+            documentId = driveIdOrDocumentId;
+            operation = documentIdOrOperation;
+            options = operationOrOptions;
+        }
+        return this.addOperations(documentId, [operation], options);
     }
-    async _addOperations(driveId, documentId, callback) {
+    async _addOperations(documentId, callback) {
         if (!this.legacyStorage.addDocumentOperationsWithTransaction) {
             const documentStorage = await this.documentStorage.get(documentId);
             const result = await callback(documentStorage);
             // saves the applied operations to storage
             if (result.operations.length > 0) {
-                await this.legacyStorage.addDocumentOperations(driveId, documentId, result.operations, result.document);
+                await this.legacyStorage.addDocumentOperations(documentId, result.operations, result.document);
             }
         }
         else {
-            await this.legacyStorage.addDocumentOperationsWithTransaction(driveId, documentId, callback);
+            await this.legacyStorage.addDocumentOperationsWithTransaction(documentId, callback);
+        }
+    }
+    async queueDocument(input, options) {
+        const { id, documentType, document } = resolveCreateDocumentInput(input);
+        if (!id) {
+            throw new Error("Document id is required", { cause: input });
+        }
+        if (!documentType) {
+            throw new Error("Document type is required", { cause: input });
+        }
+        const exists = await this.documentStorage.exists(id);
+        if (exists) {
+            throw new DocumentAlreadyExistsError(id);
+        }
+        // add listeners first
+        let jobId;
+        const promise = 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);
+                }
+            });
+        });
+        // now queue the job
+        try {
+            jobId = await this.queueManager.addJob({
+                documentId: id,
+                documentType,
+                initialState: document,
+                options,
+            });
+        }
+        catch (error) {
+            this.logger.error("Error adding job", error);
+            throw error;
         }
+        return promise;
     }
-    queueOperation(driveId, documentId, operation, options) {
-        return this.queueOperations(driveId, documentId, [operation], options);
+    queueOperation(driveIdOrDocumentId, documentIdOrOperation, operationOrOptions, maybeOptions) {
+        let documentId;
+        let operation;
+        let options;
+        if (typeof documentIdOrOperation === "string") {
+            // Deprecated overload: (driveId, documentId, operation, options)
+            documentId = documentIdOrOperation;
+            operation = operationOrOptions;
+            options = maybeOptions;
+        }
+        else {
+            // Standard overload: (documentId, operation, options)
+            documentId = driveIdOrDocumentId;
+            operation = documentIdOrOperation;
+            options = operationOrOptions;
+        }
+        return this._queueOperations(documentId, [operation], options);
     }
-    async resultIfExistingOperations(drive, id, operations) {
+    async resultIfExistingOperations(id, operations) {
         try {
-            const document = await this.getDocument(drive, id);
+            const document = await this.getDocument(id);
             const newOperation = operations.find((op) => !op.id ||
                 !document.operations[op.scope].find((existingOp) => existingOp.id === op.id &&
                     existingOp.index === op.index &&
@@ -806,9 +944,27 @@ export class BaseDocumentDriveServer {
             return undefined;
         }
     }
-    async queueOperations(driveId, documentId, operations, options) {
+    queueOperations(driveIdOrDocumentId, documentIdOrOperations, operationsOrOptions, maybeOptions) {
+        let documentId;
+        let operations;
+        let options;
+        if (typeof documentIdOrOperations === "string") {
+            // Deprecated overload: (driveId, documentId, operations, options)
+            documentId = documentIdOrOperations;
+            operations = operationsOrOptions;
+            options = maybeOptions;
+        }
+        else {
+            // Standard overload: (documentId, operations, options)
+            documentId = driveIdOrDocumentId;
+            operations = documentIdOrOperations;
+            options = operationsOrOptions;
+        }
+        return this._queueOperations(documentId, operations, options);
+    }
+    async _queueOperations(documentId, operations, options) {
         // if operations are already stored then returns cached document
-        const result = await this.resultIfExistingOperations(driveId, documentId, operations);
+        const result = await this.resultIfExistingOperations(documentId, operations);
         if (result) {
             return result;
         }
@@ -833,8 +989,7 @@ export class BaseDocumentDriveServer {
         // now queue the job
         try {
             jobId = await this.queueManager.addJob({
-                driveId: driveId,
-                documentId: documentId,
+                documentId,
                 operations,
                 options,
             });
@@ -845,14 +1000,46 @@ export class BaseDocumentDriveServer {
         }
         return promise;
     }
-    async queueAction(driveId, documentId, action, options) {
-        return this.queueActions(driveId, documentId, [action], options);
+    queueAction(driveIdOrDocumentId, documentIdOrAction, actionOrOptions, maybeOptions) {
+        let documentId;
+        let action;
+        let options;
+        if (typeof documentIdOrAction === "string") {
+            // Deprecated overload: (driveId, documentId, action, options)
+            documentId = documentIdOrAction;
+            action = actionOrOptions;
+            options = maybeOptions;
+        }
+        else {
+            // Standard overload: (documentId, action, options)
+            documentId = driveIdOrDocumentId;
+            action = documentIdOrAction;
+            options = actionOrOptions;
+        }
+        return this._queueActions(documentId, [action], options);
+    }
+    queueActions(driveIdOrDocumentId, documentIdOrActions, actionsOrOptions, maybeOptions) {
+        let documentId;
+        let actions;
+        let options;
+        if (typeof documentIdOrActions === "string") {
+            // Deprecated overload: (driveId, documentId, actions, options)
+            documentId = documentIdOrActions;
+            actions = actionsOrOptions;
+            options = maybeOptions;
+        }
+        else {
+            // Standard overload: (documentId, actions, options)
+            documentId = driveIdOrDocumentId;
+            actions = documentIdOrActions;
+            options = actionsOrOptions;
+        }
+        return this._queueActions(documentId, actions, options);
     }
-    async queueActions(driveId, documentId, actions, options) {
+    async _queueActions(documentId, actions, options) {
         try {
             const jobId = await this.queueManager.addJob({
-                driveId: driveId,
-                documentId: documentId,
+                documentId,
                 actions,
                 options,
             });
@@ -878,13 +1065,19 @@ export class BaseDocumentDriveServer {
             throw error;
         }
     }
+    /**
+     * @deprecated Use the {@link queueAction} method instead.
+     */
     async queueDriveAction(driveId, action, options) {
         return this.queueDriveActions(driveId, [action], options);
     }
+    /**
+     * @deprecated Use the {@link queueActions} method instead.
+     */
     async queueDriveActions(driveId, actions, options) {
         try {
             const jobId = await this.queueManager.addJob({
-                driveId: driveId,
+                documentId: driveId,
                 actions,
                 options,
             });
@@ -910,12 +1103,27 @@ export class BaseDocumentDriveServer {
             throw error;
         }
     }
-    async addOperations(driveId, documentId, operations, options) {
-        return this.queueOperations(driveId, documentId, operations, options);
+    addOperations(driveIdOrDocumentId, documentIdOrOperations, operationsOrOptions, maybeOptions) {
+        let documentId;
+        let operations;
+        let options;
+        if (typeof documentIdOrOperations === "string") {
+            // Deprecated overload: (driveId, documentId, operations, options)
+            documentId = documentIdOrOperations;
+            operations = operationsOrOptions;
+            options = maybeOptions;
+        }
+        else {
+            // Standard overload: (documentId, operations, options)
+            documentId = driveIdOrDocumentId;
+            operations = documentIdOrOperations;
+            options = operationsOrOptions;
+        }
+        return this._queueOperations(documentId, operations, options);
     }
-    async processOperations(driveId, documentId, operations, options) {
+    async processOperations(documentId, operations, options) {
         // if operations are already stored then returns the result
-        const result = await this.resultIfExistingOperations(driveId, documentId, operations);
+        const result = await this.resultIfExistingOperations(documentId, operations);
         if (result) {
             return result;
         }
@@ -924,8 +1132,8 @@ export class BaseDocumentDriveServer {
         const signals = [];
         let error;
         try {
-            await this._addOperations(driveId, documentId, async (documentStorage) => {
-                const result = await this._processOperations(driveId, documentId, documentStorage, operations);
+            await this._addOperations(documentId, async (documentStorage) => {
+                const result = await this._processOperations(documentId, documentStorage, operations);
                 if (!result.document) {
                     this.logger.error("Invalid document");
                     throw result.error ?? new Error("Invalid document");
@@ -939,17 +1147,28 @@ export class BaseDocumentDriveServer {
                     document: result.document,
                 };
             });
+            const syncUnits = new Array();
             if (document) {
                 this.cache.setDocument(documentId, document).catch(this.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);
+                // creates array of unique sync units from the applied operations
+                for (const operation of operationsApplied) {
+                    const syncUnit = {
+                        documentId,
+                        documentType: document.header.documentType,
+                        scope: operation.scope,
+                        branch: "main", // TODO: handle branches
+                        revision: operation.index + 1,
+                        lastUpdated: operation.timestamp,
+                    };
+                    // checks if this sync unit was already added
+                    const exists = syncUnits.some((unit) => unit.documentId === syncUnit.documentId &&
+                        unit.scope === syncUnit.scope &&
+                        unit.branch === syncUnit.branch);
+                    if (!exists) {
+                        syncUnits.push(syncUnit);
+                    }
                 }
-                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 &&
@@ -963,47 +1182,51 @@ export class BaseDocumentDriveServer {
                 : (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, {
+            // TODO Decouple the operation processing from syncing it to the listeners?
+            // Listener manager should be the one keeping the sync status since it depends on the listeners
+            if (syncUnits.length) {
+                this.listenerManager
+                    .updateSynchronizationRevisions(syncUnits, source, () => {
+                    this.synchronizationManager.updateSyncStatus(documentId, {
                         [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) => {
-                this.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, {
+                    for (const syncUnit of syncUnits) {
+                        this.synchronizationManager.updateSyncStatus(syncUnit, {
+                            [operationSource]: "SYNCING",
+                        });
+                    }
+                }, this.handleListenerError.bind(this), options?.forceSync ?? source.type === "local")
+                    .then((updates) => {
+                    if (updates.length) {
+                        this.synchronizationManager.updateSyncStatus(documentId, {
+                            [operationSource]: "SUCCESS",
+                        });
+                    }
+                    for (const syncUnit of syncUnits) {
+                        this.synchronizationManager.updateSyncStatus(syncUnit, {
+                            [operationSource]: "SUCCESS",
+                        });
+                    }
+                })
+                    .catch((error) => {
+                    this.logger.error("Non handled error updating sync revision", error);
+                    this.synchronizationManager.updateSyncStatus(documentId, {
                         [operationSource]: "ERROR",
                     }, error);
-                }
-            });
+                    for (const syncUnit of syncUnits) {
+                        this.synchronizationManager.updateSyncStatus(syncUnit, {
+                            [operationSource]: "ERROR",
+                        }, error);
+                    }
+                });
+            }
             // after applying all the valid operations,throws
             // an error if there was an invalid operation
             if (error) {
                 throw error;
             }
-            this.eventEmitter.emit("documentOperationsAdded", driveId, documentId, operations);
-            this.eventEmitter.emit("operationsAdded", driveId, documentId, operations);
+            this.eventEmitter.emit("documentOperationsAdded", documentId, operations);
+            this.eventEmitter.emit("operationsAdded", documentId, operations);
             return {
                 status: "SUCCESS",
                 document,
@@ -1024,6 +1247,9 @@ export class BaseDocumentDriveServer {
             };
         }
     }
+    /**
+     * @deprecated Use the {@link addOperation} method instead.
+     */
     addDriveOperation(driveId, operation, options) {
         return this.addDriveOperations(driveId, [operation], options);
     }
@@ -1041,6 +1267,9 @@ export class BaseDocumentDriveServer {
             return this.legacyStorage.addDriveOperationsWithTransaction(driveId, callback);
         }
     }
+    /**
+     * @deprecated Use the {@link queueOperation} method instead.
+     */
     queueDriveOperation(driveId, operation, options) {
         return this.queueDriveOperations(driveId, [operation], options);
     }
@@ -1069,6 +1298,9 @@ export class BaseDocumentDriveServer {
             return undefined;
         }
     }
+    /**
+     * @deprecated Use the {@link queueOperations} method instead.
+     */
     async queueDriveOperations(driveId, operations, options) {
         // if operations are already stored then returns cached document
         const result = await this.resultIfExistingDriveOperations(driveId, operations);
@@ -1077,7 +1309,7 @@ export class BaseDocumentDriveServer {
         }
         try {
             const jobId = await this.queueManager.addJob({
-                driveId: driveId,
+                documentId: driveId,
                 operations,
                 options,
             });
@@ -1103,6 +1335,9 @@ export class BaseDocumentDriveServer {
             throw error;
         }
     }
+    /**
+     * @deprecated Use the {@link addOperations} method instead.
+     */
     async addDriveOperations(driveId, operations, options) {
         return this.queueDriveOperations(driveId, operations, options);
     }
@@ -1118,7 +1353,7 @@ export class BaseDocumentDriveServer {
         }
         try {
             await this._addDriveOperations(driveId, async (documentStorage) => {
-                const result = await this._processOperations(driveId, undefined, documentStorage, operations.slice());
+                const result = await this._processOperations(driveId, documentStorage, operations.slice());
                 document = result.document;
                 operationsApplied.push(...result.operationsApplied);
                 signals.push(...result.signals);
@@ -1131,6 +1366,7 @@ export class BaseDocumentDriveServer {
             if (!document || !isDocumentDrive(document)) {
                 throw error ?? new Error("Invalid Document Drive document");
             }
+            this.cache.setDocument(driveId, document).catch(this.logger.error);
             this.cache.setDrive(driveId, document).catch(this.logger.error);
             // update listener cache
             const lastOperation = operationsApplied
@@ -1151,13 +1387,12 @@ export class BaseDocumentDriveServer {
                     : (options?.source ?? { type: "local" });
                 const operationSource = this.getOperationSource(source);
                 this.listenerManager
-                    .updateSynchronizationRevisions(driveId, [
+                    .updateSynchronizationRevisions([
                     {
-                        syncId: "0",
-                        documentId: "",
+                        documentId: driveId,
+                        documentType: document.header.documentType,
                         scope: "global",
                         branch: "main",
-                        documentType: "powerhouse/document-drive",
                         lastUpdated: lastOperation.timestamp,
                         revision: lastOperation.index,
                     },
@@ -1181,10 +1416,10 @@ export class BaseDocumentDriveServer {
                 });
             }
             if (this.shouldSyncRemoteDrive(document)) {
-                this.startSyncRemoteDrive(driveId);
+                this.startSyncRemoteDrive(driveId).catch(this.logger.error);
             }
             else {
-                this.stopSyncRemoteDrive(driveId);
+                this.stopSyncRemoteDrive(driveId).catch(this.logger.error);
             }
             // after applying all the valid operations,throws
             // an error if there was an invalid operation
@@ -1192,7 +1427,7 @@ export class BaseDocumentDriveServer {
                 throw error;
             }
             this.eventEmitter.emit("driveOperationsAdded", driveId, operations);
-            this.eventEmitter.emit("operationsAdded", driveId, null, operations);
+            this.eventEmitter.emit("operationsAdded", driveId, operations);
             return {
                 status: "SUCCESS",
                 document,
@@ -1226,20 +1461,81 @@ export class BaseDocumentDriveServer {
         }
         return operations;
     }
-    async addAction(driveId, documentId, action, options) {
-        return this.addActions(driveId, documentId, [action], options);
-    }
-    async addActions(driveId, documentId, actions, options) {
-        return this.queueActions(driveId, documentId, actions, options);
+    addAction(driveIdOrDocumentId, documentIdOrAction, actionOrOptions, maybeOptions) {
+        let documentId;
+        let action;
+        let options;
+        if (typeof documentIdOrAction === "string") {
+            // Deprecated overload: (driveId, documentId, action, options)
+            documentId = documentIdOrAction;
+            action = actionOrOptions;
+            options = maybeOptions;
+        }
+        else {
+            // Standard overload: (documentId, action, options)
+            documentId = driveIdOrDocumentId;
+            action = documentIdOrAction;
+            options = actionOrOptions;
+        }
+        return this._addAction(documentId, action, options);
+    }
+    async _addAction(documentId, action, options) {
+        return this.addActions(documentId, [action], options);
+    }
+    addActions(driveIdOrDocumentId, documentIdOrActions, actionsOrOptions, maybeOptions) {
+        let documentId;
+        let actions;
+        let options;
+        if (typeof documentIdOrActions === "string") {
+            // Deprecated overload: (driveId, documentId, actions, options)
+            documentId = documentIdOrActions;
+            actions = actionsOrOptions;
+            options = maybeOptions;
+        }
+        else {
+            // Standard overload: (documentId, actions, options)
+            documentId = driveIdOrDocumentId;
+            actions = documentIdOrActions;
+            options = actionsOrOptions;
+        }
+        return this._queueActions(documentId, actions, options);
     }
-    async processActions(driveId, documentId, actions, options) {
-        const document = await this.getDocument(driveId, documentId);
+    async processActions(documentId, actions, options) {
+        const document = await this.getDocument(documentId);
         const operations = this._buildOperations(document, actions);
-        return this.processOperations(driveId, documentId, operations, options);
+        return this.processOperations(documentId, operations, options);
     }
+    /**
+     * @deprecated Use the {@link addAction} method instead.
+     */
     async addDriveAction(driveId, action, options) {
+        if ("synchronizationUnits" in action.input) {
+            return this._legacyAddFileAction(driveId, action, options);
+        }
         return this.addDriveActions(driveId, [action], options);
     }
+    async _legacyAddFileAction(driveId, action, options) {
+        // create document before adding it to the drive
+        const document = this.getDocumentModelModule(action.input.documentType).utils.createDocument({ ...action.input.document });
+        document.header.id = action.input.id;
+        document.header.name = action.input.name;
+        document.header.documentType = action.input.documentType;
+        await this.queueDocument({ document }, { source: options?.source || { type: "local" } });
+        // create updated version of the ADD_FILE action
+        const newAction = {
+            ...action,
+            input: {
+                id: action.input.id,
+                documentType: document.header.documentType,
+                name: action.input.name,
+                parentFolder: action.input.parentFolder,
+            },
+        };
+        return (await this.addAction(driveId, newAction, options));
+    }
+    /**
+     * @deprecated Use the {@link addActions} method instead.
+     */
     async addDriveActions(driveId, actions, options) {
         return this.queueDriveActions(driveId, actions, options);
     }
@@ -1260,8 +1556,8 @@ export class BaseDocumentDriveServer {
         }
         await this.addDriveAction(driveId, setSharingType({ type: "LOCAL" }));
     }
-    getSyncStatus(syncUnitId) {
-        return this.synchronizationManager.getSyncStatus(syncUnitId);
+    getSyncStatus(documentId, scope, branch) {
+        return this.synchronizationManager.getSyncStatus(documentId, scope, branch);
     }
     on(event, cb) {
         return this.eventEmitter.on(event, cb);
@@ -1269,9 +1565,6 @@ export class BaseDocumentDriveServer {
     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);
@@ -1284,15 +1577,24 @@ export class BaseDocumentDriveServer {
     }
     // Add back the saveStrand method that was accidentally removed
     async saveStrand(strand, source) {
+        const isNewDocument = !(await this.documentStorage.exists(strand.documentId));
+        let result = undefined;
+        if (isNewDocument) {
+            result = await this.queueDocument({
+                id: strand.documentId,
+                documentType: strand.documentType,
+            });
+        }
         const operations = strand.operations.map((op) => ({
             ...op,
             scope: strand.scope,
             branch: strand.branch,
         }));
-        let result;
-        if (strand.documentId) {
+        // if document already existed or queueDocument
+        // was successful, queues the operations
+        if ((!isNewDocument || result?.status === "SUCCESS") && operations.length) {
             try {
-                result = await this.queueOperations(strand.driveId, strand.documentId, operations, {
+                result = await this.queueOperations(strand.documentId, operations, {
                     source,
                 });
             }
@@ -1301,25 +1603,22 @@ export class BaseDocumentDriveServer {
                 throw error;
             }
         }
-        else {
-            try {
-                result = await this.queueDriveOperations(strand.driveId, operations, {
-                    source,
-                });
-            }
-            catch (error) {
-                this.logger.error("Error queueing operations", error);
-                throw error;
-            }
+        if (!result) {
+            this.logger.debug(`Document ${strand.documentId} already exists`);
+            return {
+                status: "SUCCESS",
+                document: await this.getDocument(strand.documentId),
+                operations: [],
+                signals: [],
+            };
         }
         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.synchronizationManager.updateSyncStatus({
+                documentId: strand.documentId || strand.driveId,
+                scope: strand.scope,
+                branch: strand.branch,
+            }, { [operationSource]: result.status }, result.error);
         }
         this.eventEmitter.emit("strandUpdate", strand);
         return result;