document-drive 4.1.0-dev.12 → 4.1.0-dev.121

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

@@ -1,18 +1,17 @@
-import { removeListener, removeTrigger, setSharingType, } from "#drive-document-model/gen/creators";
-import { createDocument } from "#drive-document-model/gen/utils";
-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 { DocumentAlreadyExistsError, childLogger, } from "document-drive";
-import { attachBranch, createPresignedHeader, garbageCollect, garbageCollectDocumentOperations, groupOperationsByScope, merge, precedes, removeExistingOperations, replayDocument, reshuffleByTimestamp, skipHeaderOperations, sortOperations, validateHeader, } from "document-model";
+import { isActionJob, isDocumentJob, isOperationJob, } from "document-drive/queue/utils";
+import { ReadModeServer } from "document-drive/read-mode/server";
+import { DefaultDrivesManager } from "document-drive/utils/default-drives-manager";
+import { requestPublicDriveWithTokenFromReactor } from "document-drive/utils/graphql";
+import { childLogger } from "document-drive/utils/logger";
+import { isDocumentDrive } from "document-drive/utils/misc";
+import { runAsap, runAsapAsync } from "document-drive/utils/run-asap";
+import { attachBranch, createPresignedHeader, defaultBaseState, diffOperations, garbageCollect, garbageCollectDocumentOperations, groupOperationsByScope, hashDocumentStateForScope, merge, precedes, removeExistingOperations, replayDocument, reshuffleByTimestamp, skipHeaderOperations, sortOperations, validateHeader, } from "document-model/core";
 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 { driveCreateDocument, driveCreateState, removeListener, removeTrigger, setSharingType, } from "../drive-document-model/index.js";
+import { ConflictOperationError, DocumentAlreadyExistsError, OperationError, } from "./error.js";
+import { DefaultListenerManagerOptions } from "./listener/constants.js";
+import { PullResponderTransmitter } from "./transmitter/pull-responder.js";
+import { SwitchboardPushTransmitter } from "./transmitter/switchboard-push.js";
 import { filterOperationsByRevision, isAtRevision, resolveCreateDocumentInput, } from "./utils.js";
 export class BaseDocumentDriveServer {
     logger = childLogger(["BaseDocumentDriveServer"]);
@@ -47,18 +46,19 @@ export class BaseDocumentDriveServer {
                 ? this.processDriveActions(documentId, actions, options)
                 : this.processActions(documentId, actions, options);
         },
-        processDocumentJob: async ({ documentId, documentType, initialState, options, }) => {
+        processDocumentJob: async ({ documentId, documentType, header: inputHeader, initialState, options, }) => {
             const documentModelModule = this.getDocumentModelModule(documentType);
-            const document = documentModelModule.utils.createDocument({
-                ...initialState,
-            });
+            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;
+            if (inputHeader) {
+                document.header.meta = inputHeader.meta;
+            }
             try {
-                const createdDocument = await this.createDocument({ document }, options?.source ?? { type: "local" }, initialState?.header.meta);
+                const createdDocument = await this.createDocument({ document }, options?.source ?? { type: "local" }, document.header.meta);
                 return {
                     status: "SUCCESS",
                     operations: [],
@@ -95,6 +95,7 @@ export class BaseDocumentDriveServer {
     // internal state
     triggerMap = new Map();
     initializePromise;
+    enableDualActionCreate;
     constructor(documentModelModules, storage, documentStorage, cache, queueManager, eventEmitter, synchronizationManager, listenerManager, options) {
         this.documentModelModules = documentModelModules;
         this.legacyStorage = storage;
@@ -117,9 +118,17 @@ export class BaseDocumentDriveServer {
                 ? () => Promise.resolve("")
                 : options.jwtHandler,
             taskQueueMethod: options?.taskQueueMethod === undefined
-                ? RunAsap.runAsap
+                ? runAsap
                 : options.taskQueueMethod,
+            featureFlags: {
+                ...options?.featureFlags,
+            },
         };
+        this.enableDualActionCreate =
+            options?.featureFlags?.enableDualActionCreate ?? false;
+        if (this.enableDualActionCreate) {
+            this.logger.warn("Dual action create is enabled.");
+        }
         // todo: move to external dependencies
         this.defaultDrivesManager = new DefaultDrivesManager(this, this.defaultDrivesManagerDelegate, options);
         this.initializePromise = this._initialize();
@@ -136,7 +145,7 @@ export class BaseDocumentDriveServer {
         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);
+            // errors.push(error);
         });
         try {
             await this.defaultDrivesManager.removeOldremoteDrives();
@@ -328,7 +337,7 @@ export class BaseDocumentDriveServer {
         }
     }
     getDocumentModelModule(documentType) {
-        const documentModelModule = this.documentModelModules.find((module) => module.documentModel.id === documentType);
+        const documentModelModule = this.documentModelModules.find((module) => module.documentModel.global.id === documentType);
         if (!documentModelModule) {
             throw new Error(`Document type ${documentType} not supported`);
         }
@@ -344,13 +353,19 @@ export class BaseDocumentDriveServer {
         return this.createDocument(input, { type: "local" }, meta);
     }
     async addDrive(input, preferredEditor) {
-        const document = createDocument({
-            state: {
-                global: {
-                    icon: input.global.icon ?? null,
-                    name: input.global.name,
-                },
-                local: input.local ?? {},
+        // Create document with custom global and local state
+        const { global } = driveCreateState();
+        const document = driveCreateDocument({
+            global: {
+                ...global,
+                name: input.global.name ?? global.name,
+                icon: input.global.icon ?? global.icon,
+            },
+            local: {
+                availableOffline: input.local?.availableOffline ?? false,
+                sharingType: input.local?.sharingType ?? "public",
+                listeners: input.local?.listeners ?? [],
+                triggers: input.local?.triggers ?? [],
             },
         });
         if (input.id && input.id.length > 0) {
@@ -359,6 +374,9 @@ export class BaseDocumentDriveServer {
         if (input.slug && input.slug.length > 0) {
             document.header.slug = input.slug;
         }
+        if (input.global.name) {
+            document.header.name = input.global.name;
+        }
         const editorToUse = input.preferredEditor || preferredEditor;
         if (editorToUse) {
             document.header.meta = {
@@ -549,6 +567,14 @@ export class BaseDocumentDriveServer {
         }
     }
     async createDocument(input, source, meta) {
+        if (this.enableDualActionCreate) {
+            return this.createDocumentDualAction(input, source, meta);
+        }
+        else {
+            return this.createDocumentLegacy(input, source, meta);
+        }
+    }
+    async createDocumentLegacy(input, source, meta) {
         const { documentType, document: inputDocument } = resolveCreateDocumentInput(input);
         // if a document was provided then checks if it's valid
         let state = undefined;
@@ -562,9 +588,7 @@ export class BaseDocumentDriveServer {
         }
         // if no document was provided then create a new one
         const document = inputDocument ??
-            this.getDocumentModelModule(documentType).utils.createDocument({
-                state,
-            });
+            this.getDocumentModelModule(documentType).utils.createDocument(state);
         // get the header
         let header;
         // handle the legacy case where an id is provided
@@ -613,11 +637,9 @@ export class BaseDocumentDriveServer {
         // stores document information
         const documentStorage = {
             header,
-            history: document.history,
             operations: { global: [], local: [] },
             initialState: document.initialState,
             clipboard: [],
-            attachments: document.attachments,
             state: state ?? document.state,
         };
         await this.documentStorage.create(documentStorage);
@@ -650,7 +672,185 @@ export class BaseDocumentDriveServer {
                 await this.legacyStorage.addDocumentOperations(header.id, operations, document);
             }
         }
-        return await this.getDocument(documentStorage.header.id);
+        const addedDocument = await this.getDocument(documentStorage.header.id);
+        this.eventEmitter.emit("documentAdded", addedDocument);
+        return addedDocument;
+    }
+    async createDocumentDualAction(input, source, meta) {
+        const { documentType, document: inputDocument } = resolveCreateDocumentInput(input);
+        // if a document was provided then checks if it's valid
+        let state = undefined;
+        if (inputDocument) {
+            if ("documentType" in input &&
+                documentType !== inputDocument.header.documentType) {
+                throw new Error(`Provided document is not ${documentType}`);
+            }
+            const doc = this._buildDocument(inputDocument);
+            state = doc.state;
+        }
+        // if no document was provided then create a new one
+        const document = inputDocument ??
+            this.getDocumentModelModule(documentType).utils.createDocument(state);
+        // get the header
+        let header;
+        // handle the legacy case where an id is provided
+        let isSigned = false;
+        if ("id" in input && input.id) {
+            if (inputDocument) {
+                header = document.header;
+                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(input.id, documentType);
+            }
+        }
+        else if ("header" in input) {
+            // validate the header passed in
+            await validateHeader(input.header);
+            isSigned = true;
+            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);
+                isSigned = true;
+            }
+            header = inputDocument.header;
+        }
+        else {
+            // otherwise, generate a header
+            header = createPresignedHeader(undefined, documentType);
+            isSigned = false;
+        }
+        if (meta) {
+            header.meta = { ...header.meta, ...meta };
+        }
+        const currentVersion = "0.1.0";
+        // Get initial state from input or model's defaultState
+        const initialState = state ?? document.state;
+        // Check if the input document already has operations
+        const existingOperations = Object.values(document.operations).flat();
+        const shouldCreateOperations = existingOperations.length === 0;
+        let operations = [];
+        if (shouldCreateOperations) {
+            const timestampUtcMs = new Date().toISOString();
+            // Determine if this is a signed document
+            const signing = isSigned
+                ? {
+                    signature: header.id, // The document ID is the signature
+                    publicKey: header.sig.publicKey,
+                    nonce: header.sig.nonce,
+                    createdAtUtcIso: header.createdAtUtcIso,
+                    documentType: header.documentType,
+                }
+                : undefined;
+            // Create actions for CREATE_DOCUMENT and UPGRADE_DOCUMENT
+            const createDocumentInput = {
+                model: documentType,
+                version: "0.0.0",
+                documentId: header.id,
+                signing,
+            };
+            const createDocumentAction = {
+                id: `${header.id}-create`,
+                type: "CREATE_DOCUMENT",
+                timestampUtcMs,
+                input: createDocumentInput,
+                scope: "document",
+            };
+            const upgradeDocumentInput = {
+                model: documentType,
+                fromVersion: "0.0.0",
+                toVersion: currentVersion,
+                documentId: header.id,
+                initialState,
+            };
+            const upgradeDocumentAction = {
+                id: `${header.id}-upgrade`,
+                type: "UPGRADE_DOCUMENT",
+                timestampUtcMs,
+                input: upgradeDocumentInput,
+                scope: "document",
+            };
+            // we need to create hashes for later verification
+            const baseState = defaultBaseState();
+            const createStateForHash = {
+                state: baseState,
+            };
+            const createHash = hashDocumentStateForScope(createStateForHash, "document");
+            const upgradeStateForHash = {
+                state: initialState,
+            };
+            const upgradeHash = hashDocumentStateForScope(upgradeStateForHash, "document");
+            // Create operations from actions with computed hashes
+            operations = [
+                {
+                    index: 0,
+                    skip: 0,
+                    hash: createHash,
+                    timestampUtcMs,
+                    action: createDocumentAction,
+                },
+                {
+                    index: 1,
+                    skip: 0,
+                    hash: upgradeHash,
+                    timestampUtcMs,
+                    action: upgradeDocumentAction,
+                },
+            ];
+        }
+        else {
+            // Use existing operations from the input document
+            operations = existingOperations;
+        }
+        // Group operations by scope before storing
+        const groupedOps = groupOperationsByScope(operations);
+        // Ensure backward compatibility by initializing missing scopes
+        if (!groupedOps.header) {
+            groupedOps.header = [];
+        }
+        if (!groupedOps.document) {
+            groupedOps.document = [];
+        }
+        if (!groupedOps.global) {
+            groupedOps.global = [];
+        }
+        if (!groupedOps.local) {
+            groupedOps.local = [];
+        }
+        // After initialization, it's safe to treat as DocumentOperations
+        const operationsByScope = groupedOps;
+        // stores document information with operations
+        const documentToStore = {
+            header,
+            operations: operationsByScope,
+            initialState,
+            clipboard: [],
+            state: initialState,
+        };
+        await this.documentStorage.create(documentToStore);
+        // Force rebuild to ensure operations are properly merged
+        const addedDocument = await this.getDocument(documentToStore.header.id, {
+            checkHashes: true,
+        });
+        this.eventEmitter.emit("documentAdded", addedDocument);
+        return addedDocument;
     }
     async deleteDocument(documentId) {
         try {
@@ -669,8 +869,11 @@ export class BaseDocumentDriveServer {
         catch (error) {
             this.logger.warn("Error deleting document", error);
         }
-        await this.cache.deleteDocument(documentId);
-        await this.documentStorage.delete(documentId);
+        await Promise.allSettled([
+            this.cache.deleteDocument(documentId).catch(this.logger.warn),
+            this.documentStorage.delete(documentId).catch(this.logger.warn),
+        ]);
+        this.eventEmitter.emit("documentDeleted", documentId);
     }
     async _processOperations(documentId, documentStorage, operations) {
         const operationsApplied = [];
@@ -680,7 +883,7 @@ export class BaseDocumentDriveServer {
         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];
+            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
@@ -740,13 +943,17 @@ export class BaseDocumentDriveServer {
             : document.operations;
         const documentOperations = garbageCollectDocumentOperations(operations);
         for (const scope of Object.keys(documentOperations)) {
-            const lastRemainingOperation = documentOperations[scope].at(-1);
+            const scopeOps = documentOperations[scope];
+            if (!scopeOps) {
+                continue;
+            }
+            const lastRemainingOperation = scopeOps.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 (isDocumentDrive(document)
-                    ? this.legacyStorage.getOperationResultingState?.(documentId, lastRemainingOperation.index, lastRemainingOperation.scope, "main")
-                    : this.legacyStorage.getDriveOperationResultingState?.(documentId, lastRemainingOperation.index, lastRemainingOperation.scope, "main"));
+                    ? this.legacyStorage.getOperationResultingState?.(documentId, lastRemainingOperation.index, lastRemainingOperation.action.scope, "main")
+                    : this.legacyStorage.getDriveOperationResultingState?.(documentId, lastRemainingOperation.index, lastRemainingOperation.action.scope, "main"));
             }
         }
         return {
@@ -765,31 +972,84 @@ export class BaseDocumentDriveServer {
             ? filterOperationsByRevision(documentStorage.operations, options.revisions)
             : documentStorage.operations;
         const operations = garbageCollectDocumentOperations(revisionOperations);
-        return replayDocument(documentStorage.initialState, operations, documentModelModule.reducer, undefined, documentStorage.header, undefined, {
+        // Get all scopes from operations
+        const allScopes = Object.keys(operations);
+        // Initialize with all scopes found in operations, plus global and local for backward compatibility
+        const scopesToInitialize = new Set([...allScopes, "global", "local"]);
+        const headerOperations = {};
+        const operationsToReplay = {};
+        for (const scope of scopesToInitialize) {
+            headerOperations[scope] = [];
+            operationsToReplay[scope] = [];
+        }
+        // Filter out CREATE_DOCUMENT and UPGRADE_DOCUMENT operations
+        // (these don't currently have reducers and should not be replayed)
+        for (const [scope, scopeOps] of Object.entries(operations)) {
+            if (!scopeOps) {
+                continue;
+            }
+            for (const op of scopeOps) {
+                if (op.action.type === "CREATE_DOCUMENT" ||
+                    op.action.type === "UPGRADE_DOCUMENT") {
+                    const headerOps = headerOperations[scope];
+                    if (headerOps) {
+                        headerOps.push(op);
+                    }
+                }
+                else {
+                    const replayOps = operationsToReplay[scope];
+                    if (replayOps) {
+                        replayOps.push(op);
+                    }
+                }
+            }
+        }
+        const replayed = replayDocument(documentStorage.initialState, operationsToReplay, documentModelModule.reducer, undefined, documentStorage.header, undefined, {
             ...options,
             checkHashes: options?.checkHashes ?? true,
             reuseOperationResultingState: options?.checkHashes ?? true,
         });
+        // merge header operations back into the result
+        // Include ALL scopes from input operations, header operations, and replayed operations
+        const allScopesForMerge = new Set([
+            ...Object.keys(operations), // From input storage
+            ...Object.keys(headerOperations),
+            ...Object.keys(replayed.operations),
+        ]);
+        const finalOperations = {};
+        for (const scope of allScopesForMerge) {
+            finalOperations[scope] = [
+                ...(headerOperations[scope] || []),
+                ...(replayed.operations[scope] || []),
+            ];
+        }
+        return {
+            ...replayed,
+            operations: finalOperations,
+        };
     }
     async _performOperation(documentId, document, operation, skipHashValidation = false) {
         const documentModelModule = this.getDocumentModelModule(document.header.documentType);
         const signalResults = [];
         let newDocument = document;
-        const scope = operation.scope;
+        const scope = operation.action.scope;
+        const currentScopeOperations = document.operations[scope] || [];
         const documentOperations = garbageCollectDocumentOperations({
             ...document.operations,
-            [scope]: skipHeaderOperations(document.operations[scope], operation),
+            [scope]: skipHeaderOperations(currentScopeOperations, operation),
         });
-        const lastRemainingOperation = documentOperations[scope].at(-1);
+        const remainingScopeOps = documentOperations[scope];
+        const lastRemainingOperation = remainingScopeOps?.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 (isDocumentDrive(document)
-                ? this.legacyStorage.getOperationResultingState?.(documentId, lastRemainingOperation.index, lastRemainingOperation.scope, "main")
-                : this.legacyStorage.getDriveOperationResultingState?.(documentId, lastRemainingOperation.index, lastRemainingOperation.scope, "main"));
+                ? this.legacyStorage.getOperationResultingState?.(documentId, lastRemainingOperation.index, lastRemainingOperation.action.scope, "main")
+                : this.legacyStorage.getDriveOperationResultingState?.(documentId, lastRemainingOperation.index, lastRemainingOperation.action.scope, "main"));
         }
+        const operationsBeforeReducer = newDocument.operations[scope] || [];
         const operationSignals = [];
-        newDocument = documentModelModule.reducer(newDocument, operation, (signal) => {
+        newDocument = documentModelModule.reducer(newDocument, operation.action, (signal) => {
             let handler = undefined;
             switch (signal.type) {
                 case "CREATE_CHILD_DOCUMENT":
@@ -805,8 +1065,35 @@ export class BaseDocumentDriveServer {
             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);
+        }, {
+            skip: operation.skip,
+            reuseOperationResultingState: true,
+            replayOptions: { operation },
+        });
+        // when we have NOOP operations with skip > 0 we need to populate the
+        // clipboard with the operations that were skipped to allow redo
+        if (operation.action.type === "NOOP" &&
+            operation.skip > 0 &&
+            newDocument.clipboard.length === 0) {
+            const scopeOperationsAfter = newDocument.operations[scope] || [];
+            // Get operations AFTER garbageCollect (with NOOP)
+            const afterOperations = garbageCollect(sortOperations(scopeOperationsAfter));
+            // Get operations BEFORE the reducer ran (before NOOP was applied)
+            const beforeOperations = garbageCollect(sortOperations(operationsBeforeReducer));
+            // Calculate what was removed by comparing before vs after
+            // The diff shows operations that were in "before" but not in "after"
+            const diff = diffOperations(beforeOperations, afterOperations);
+            // Populate clipboard with skipped operations (excluding NOOPs)
+            newDocument = {
+                ...newDocument,
+                clipboard: sortOperations(diff.filter((op) => op.action.type !== "NOOP")).reverse(),
+            };
+        }
+        const newDocScopeOperations = newDocument.operations[operation.action.scope];
+        if (!newDocScopeOperations) {
+            throw new OperationError("ERROR", operation, `No operations found for scope: ${operation.action.scope}`);
+        }
+        const appliedOperations = newDocScopeOperations.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.`);
@@ -893,7 +1180,8 @@ export class BaseDocumentDriveServer {
             jobId = await this.queueManager.addJob({
                 documentId: id,
                 documentType,
-                initialState: document,
+                initialState: document?.state,
+                header: document?.header,
                 options,
             });
         }
@@ -924,11 +1212,19 @@ export class BaseDocumentDriveServer {
     async resultIfExistingOperations(id, operations) {
         try {
             const document = await this.getDocument(id);
-            const newOperation = operations.find((op) => !op.id ||
-                !document.operations[op.scope].find((existingOp) => existingOp.id === op.id &&
+            const newOperation = operations.find((op) => {
+                if (!op.id) {
+                    return true;
+                }
+                const scopeOps = document.operations[op.action.scope];
+                if (!scopeOps) {
+                    return true;
+                }
+                return !scopeOps.find((existingOp) => existingOp.id === op.id &&
                     existingOp.index === op.index &&
-                    existingOp.type === op.type &&
-                    existingOp.hash === op.hash));
+                    existingOp.action.type === op.action.type &&
+                    existingOp.hash === op.hash);
+            });
             if (!newOperation) {
                 return {
                     status: "SUCCESS",
@@ -1159,10 +1455,10 @@ export class BaseDocumentDriveServer {
                     const syncUnit = {
                         documentId,
                         documentType: document.header.documentType,
-                        scope: operation.scope,
+                        scope: operation.action.scope,
                         branch: "main", // TODO: handle branches
                         revision: operation.index + 1,
-                        lastUpdated: operation.timestamp,
+                        lastUpdated: operation.timestampUtcMs,
                     };
                     // checks if this sync unit was already added
                     const exists = syncUnits.some((unit) => unit.documentId === syncUnit.documentId &&
@@ -1280,11 +1576,19 @@ export class BaseDocumentDriveServer {
     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 &&
+            const newOperation = operations.find((op) => {
+                if (!op.id) {
+                    return true;
+                }
+                const scopeOps = drive.operations[op.action.scope];
+                if (!scopeOps) {
+                    return true;
+                }
+                return !scopeOps.find((existingOp) => existingOp.id === op.id &&
                     existingOp.index === op.index &&
-                    existingOp.type === op.type &&
-                    existingOp.hash === op.hash));
+                    existingOp.action.type === op.action.type &&
+                    existingOp.hash === op.hash);
+            });
             if (!newOperation) {
                 return {
                     status: "SUCCESS",
@@ -1374,7 +1678,7 @@ export class BaseDocumentDriveServer {
             this.cache.setDrive(driveId, document).catch(this.logger.error);
             // update listener cache
             const lastOperation = operationsApplied
-                .filter((op) => op.scope === "global")
+                .filter((op) => op.action.scope === "global")
                 .slice()
                 .pop();
             if (lastOperation) {
@@ -1397,7 +1701,7 @@ export class BaseDocumentDriveServer {
                         documentType: document.header.documentType,
                         scope: "global",
                         branch: "main",
-                        lastUpdated: lastOperation.timestamp,
+                        lastUpdated: lastOperation.timestampUtcMs,
                         revision: lastOperation.index,
                     },
                 ], source, () => {
@@ -1457,7 +1761,11 @@ export class BaseDocumentDriveServer {
         const { reducer } = this.getDocumentModelModule(documentId.header.documentType);
         for (const action of actions) {
             documentId = reducer(documentId, action);
-            const operation = documentId.operations[action.scope].slice().pop();
+            const scopeOps = documentId.operations[action.scope];
+            if (!scopeOps) {
+                throw new Error(`No operations found for scope: ${action.scope}`);
+            }
+            const operation = scopeOps.slice().pop();
             if (!operation) {
                 throw new Error("Error creating operations");
             }
@@ -1520,7 +1828,7 @@ export class BaseDocumentDriveServer {
     }
     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 });
+        const document = this.getDocumentModelModule(action.input.documentType).utils.createDocument(action.input.document?.state || undefined);
         document.header.id = action.input.id;
         document.header.name = action.input.name;
         document.header.documentType = action.input.documentType;
@@ -1591,6 +1899,14 @@ export class BaseDocumentDriveServer {
         }
         const operations = strand.operations.map((op) => ({
             ...op,
+            action: {
+                id: op.actionId,
+                timestampUtcMs: op.timestampUtcMs,
+                type: op.type,
+                input: op.input,
+                context: op.context,
+                scope: strand.scope,
+            },
             scope: strand.scope,
             branch: strand.branch,
         }));