document-drive 0.0.28 → 0.0.30

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "document-drive",
-    "version": "0.0.28",
+    "version": "0.0.30",
     "license": "AGPL-3.0-only",
     "type": "module",
     "module": "./src/index.ts",
@@ -29,7 +29,7 @@
     },
     "peerDependencies": {
         "@prisma/client": "5.8.1",
-        "document-model": "^1.0.28",
+        "document-model": "^1.0.29",
         "document-model-libs": "^1.1.44",
         "localforage": "^1.10.0",
         "sequelize": "^6.35.2",
@@ -39,6 +39,7 @@
         "graphql": "^16.8.1",
         "graphql-request": "^6.1.0",
         "json-stringify-deterministic": "^1.0.12",
+        "nanoevents": "^9.0.0",
         "sanitize-filename": "^1.6.3"
     },
     "devDependencies": {
@@ -48,7 +49,7 @@
         "@typescript-eslint/eslint-plugin": "^6.18.1",
         "@typescript-eslint/parser": "^6.18.1",
         "@vitest/coverage-v8": "^0.34.6",
-        "document-model": "^1.0.28",
+        "document-model": "^1.0.29",
         "document-model-libs": "^1.1.44",
         "eslint": "^8.56.0",
         "eslint-config-prettier": "^9.1.0",

package/src/server/index.ts

@@ -3,22 +3,23 @@ import {
     DocumentDriveDocument,
     DocumentDriveState,
     FileNode,
-    Trigger,
     isFileNode,
+    Trigger,
     utils
 } from 'document-model-libs/document-drive';
 import {
     Action,
     BaseAction,
+    utils as baseUtils,
     Document,
     DocumentModel,
     Operation,
-    OperationScope,
-    utils as baseUtils
+    OperationScope
 } from 'document-model/document';
+import { createNanoEvents, Unsubscribe } from 'nanoevents';
 import { MemoryStorage } from '../storage/memory';
 import type { DocumentStorage, IDriveStorage } from '../storage/types';
-import { generateUUID, isDocumentDrive } from '../utils';
+import { generateUUID, isDocumentDrive, isNoopUpdate } from '../utils';
 import { requestPublicDrive } from '../utils/graphql';
 import { OperationError } from './error';
 import { ListenerManager } from './listener/manager';
@@ -26,7 +27,9 @@ import { PullResponderTransmitter } from './listener/transmitter';
 import type { ITransmitter } from './listener/transmitter/types';
 import {
     BaseDocumentDriveServer,
+    DriveEvents,
     IOperationResult,
+    ListenerState,
     RemoteDriveOptions,
     StrandUpdate,
     SyncStatus,
@@ -43,6 +46,7 @@ export type * from './types';
 export const PULL_DRIVE_INTERVAL = 5000;
 
 export class DocumentDriveServer extends BaseDocumentDriveServer {
+    private emitter = createNanoEvents<DriveEvents>();
     private documentModels: DocumentModel[];
     private storage: IDriveStorage;
     private listenerStateManager: ListenerManager;
@@ -62,6 +66,15 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
         this.storage = storage;
     }
 
+    private updateSyncStatus(
+        driveId: string,
+        status: SyncStatus,
+        error?: Error
+    ) {
+        this.syncStatus.set(driveId, status);
+        this.emit('syncStatus', driveId, status, error);
+    }
+
     private async saveStrand(strand: StrandUpdate) {
         const operations: Operation[] = strand.operations.map(
             ({ index, type, hash, input, skip, timestamp }) => ({
@@ -86,10 +99,27 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
                   strand.documentId,
                   operations
               ));
-        this.syncStatus.set(strand.driveId, result.status);
+
+        this.updateSyncStatus(strand.driveId, result.status);
+        this.emit('strandUpdate', strand);
         return result;
     }
 
+    private handleListenerError(
+        error: Error,
+        driveId: string,
+        listener: ListenerState
+    ) {
+        console.error(
+            `Listener ${listener.listener.label ?? listener.listener.listenerId} error: ${error.message}`
+        );
+        this.updateSyncStatus(
+            driveId,
+            error instanceof OperationError ? error.status : 'ERROR',
+            error
+        );
+    }
+
     private shouldSyncRemoteDrive(drive: DocumentDriveDocument) {
         return (
             drive.state.local.availableOffline &&
@@ -108,7 +138,7 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
 
             if (!driveTriggers) {
                 driveTriggers = new Map();
-                this.syncStatus.set(driveId, 'SYNCING');
+                this.updateSyncStatus(driveId, 'SYNCING');
             }
 
             if (PullResponderTransmitter.isPullResponderTrigger(trigger)) {
@@ -117,7 +147,7 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
                     trigger,
                     this.saveStrand.bind(this),
                     error => {
-                        this.syncStatus.set(
+                        this.updateSyncStatus(
                             driveId,
                             error instanceof OperationError
                                 ? error.status
@@ -127,7 +157,7 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
                     acknowledgeSuccess => {}
                 );
                 driveTriggers.set(trigger.id, intervalId);
-                this.triggerMap.set(trigger.id, driveTriggers);
+                this.triggerMap.set(driveId, driveTriggers);
             }
         }
     }
@@ -265,7 +295,7 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
                 (filter.since !== undefined &&
                     filter.since <= operation.timestamp) ||
                 (filter.fromRevision !== undefined &&
-                    operation.index >= filter.fromRevision)
+                    operation.index > filter.fromRevision)
         );
 
         return filteredOperations.map(operation => ({
@@ -456,6 +486,12 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
     }
 
     async deleteDocument(driveId: string, id: string) {
+        try {
+            const syncUnits = await this.getSynchronizationUnits(driveId, [id]);
+            this.listenerStateManager.removeSyncUnits(syncUnits);
+        } catch {
+            /* empty */
+        }
         return this.storage.deleteDocument(driveId, id);
     }
 
@@ -465,18 +501,27 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
         operations: Operation<A | BaseAction>[]
     ) {
         const operationsApplied: Operation<A | BaseAction>[] = [];
+        const operationsUpdated: Operation<A | BaseAction>[] = [];
         let document: T | undefined;
         const signals: SignalResult[] = [];
 
         // eslint-disable-next-line prefer-const
-        let [operationsToApply, error] = this._validateOperations(
-            operations,
-            documentStorage
-        );
+        let [operationsToApply, error, updatedOperations] =
+            this._validateOperations(operations, documentStorage);
+
+        const unregisteredOps = [
+            ...operationsToApply.map(operation => ({ operation, type: 'new' })),
+            ...updatedOperations.map(operation => ({
+                operation,
+                type: 'update'
+            }))
+        ].sort((a, b) => a.operation.index - b.operation.index);
 
         // retrieves the document's document model and
         // applies the operations using its reducer
-        for (const operation of operationsToApply) {
+        for (const unregisteredOp of unregisteredOps) {
+            const { operation, type } = unregisteredOp;
+
             try {
                 const {
                     document: newDocument,
@@ -488,7 +533,13 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
                     operation
                 );
                 document = newDocument;
-                operationsApplied.push(appliedOperation);
+
+                if (type === 'new') {
+                    operationsApplied.push(appliedOperation);
+                } else {
+                    operationsUpdated.push(appliedOperation);
+                }
+
                 signals.push(...signals);
             } catch (e) {
                 if (!error) {
@@ -505,7 +556,18 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
                 break;
             }
         }
-        return { document, operationsApplied, signals, error } as const;
+
+        if (!document) {
+            document = this._buildDocument(documentStorage);
+        }
+
+        return {
+            document,
+            operationsApplied,
+            signals,
+            error,
+            operationsUpdated
+        } as const;
     }
 
     private _validateOperations<T extends Document, A extends Action>(
@@ -513,6 +575,7 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
         documentStorage: DocumentStorage<T>
     ) {
         const operationsToApply: Operation<A | BaseAction>[] = [];
+        const updatedOperations: Operation<A | BaseAction>[] = [];
         let error: OperationError | undefined;
 
         // sort operations so from smaller index to biggest
@@ -525,7 +588,17 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
                 .slice(0, i);
             const scopeOperations = documentStorage.operations[op.scope];
 
-            const nextIndex = scopeOperations.length + pastOperations.length;
+            // get latest operation
+            const ops = [...scopeOperations, ...pastOperations];
+            const latestOperation = ops.slice().pop();
+
+            const noopUpdate = isNoopUpdate(op, latestOperation);
+
+            let nextIndex = scopeOperations.length + pastOperations.length;
+            if (noopUpdate) {
+                nextIndex = nextIndex - 1;
+            }
+
             if (op.index > nextIndex) {
                 error = new OperationError(
                     'MISSING',
@@ -534,39 +607,54 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
                 );
                 continue;
             } else if (op.index < nextIndex) {
-                const existingOperation =
-                    scopeOperations.concat(pastOperations)[op.index];
+                const existingOperation = scopeOperations.find(
+                    existingOperation => existingOperation.index === op.index
+                );
                 if (existingOperation && existingOperation.hash !== op.hash) {
                     error = new OperationError(
                         'CONFLICT',
                         op,
-                        `Conflicting operation on index ${op.index}`
+                        `Conflicting operation on index ${op.index}`,
+                        { existingOperation, newOperation: op }
                     );
                     continue;
                 }
             } else {
-                operationsToApply.push(op);
+                if (noopUpdate) {
+                    updatedOperations.push(op);
+                } else {
+                    operationsToApply.push(op);
+                }
             }
         }
 
-        return [operationsToApply, error] as const;
+        return [operationsToApply, error, updatedOperations] as const;
     }
 
-    private async _performOperation<T extends Document, A extends Action>(
-        drive: string,
-        documentStorage: DocumentStorage<T>,
-        operation: Operation<A | BaseAction>
-    ) {
+    private _buildDocument<T extends Document>(
+        documentStorage: DocumentStorage<T>
+    ): T {
         const documentModel = this._getDocumentModel(
             documentStorage.documentType
         );
-        const document = baseUtils.replayDocument(
+        return baseUtils.replayDocument(
             documentStorage.initialState,
             documentStorage.operations,
             documentModel.reducer,
             undefined,
             documentStorage
         ) as T;
+    }
+
+    private async _performOperation<T extends Document, A extends Action>(
+        drive: string,
+        documentStorage: DocumentStorage<T>,
+        operation: Operation<A | BaseAction>
+    ) {
+        const documentModel = this._getDocumentModel(
+            documentStorage.documentType
+        );
+        const document = this._buildDocument(documentStorage);
 
         const signalResults: SignalResult[] = [];
         let newDocument = document;
@@ -612,10 +700,10 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
             );
         }
 
-        const results = await Promise.all(
-            operationSignals.map(handler => handler())
-        );
-        signalResults.push(...results);
+        for (const signalHandler of operationSignals) {
+            const result = await signalHandler();
+            signalResults.push(result);
+        }
 
         return {
             document: newDocument,
@@ -634,6 +722,7 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
 
         let document: Document | undefined;
         const operationsApplied: Operation[] = [];
+        const updatedOperations: Operation[] = [];
         const signals: SignalResult[] = [];
         let error: Error | undefined;
 
@@ -647,7 +736,10 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
             );
 
             document = result.document;
+
             operationsApplied.push(...result.operationsApplied);
+            updatedOperations.push(...result.operationsUpdated);
+
             signals.push(...result.signals);
             error = result.error;
 
@@ -656,15 +748,21 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
             }
 
             // saves the applied operations to storage
-            await this.storage.addDocumentOperations(
-                drive,
-                id,
-                operationsApplied,
-                document
-            );
+            if (operationsApplied.length > 0 || updatedOperations.length > 0) {
+                await this.storage.addDocumentOperations(
+                    drive,
+                    id,
+                    operationsApplied,
+                    document,
+                    updatedOperations
+                );
+            }
 
             // gets all the different scopes and branches combinations from the operations
-            const { scopes, branches } = operationsApplied.reduce(
+            const { scopes, branches } = [
+                ...operationsApplied,
+                ...updatedOperations
+            ].reduce(
                 (acc, operation) => {
                     if (!acc.scopes.includes(operation.scope)) {
                         acc.scopes.push(operation.scope);
@@ -682,12 +780,21 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
             );
             // update listener cache
             for (const syncUnit of syncUnits) {
-                await this.listenerStateManager.updateSynchronizationRevision(
-                    drive,
-                    syncUnit.syncId,
-                    syncUnit.revision,
-                    syncUnit.lastUpdated
-                );
+                this.listenerStateManager
+                    .updateSynchronizationRevision(
+                        drive,
+                        syncUnit.syncId,
+                        syncUnit.revision,
+                        syncUnit.lastUpdated,
+                        this.handleListenerError.bind(this)
+                    )
+                    .catch(error => {
+                        console.error(
+                            'Non handled error updating sync revision',
+                            error
+                        );
+                        this.updateSyncStatus(drive, 'ERROR', error as Error);
+                    });
             }
 
             // after applying all the valid operations,throws
@@ -759,11 +866,13 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
             }
 
             // saves the applied operations to storage
-            await this.storage.addDriveOperations(
-                drive,
-                operationsApplied,
-                document
-            );
+            if (operationsApplied.length > 0) {
+                await this.storage.addDriveOperations(
+                    drive,
+                    operationsApplied,
+                    document
+                );
+            }
 
             for (const operation of operationsApplied) {
                 if (operation.type === 'ADD_LISTENER') {
@@ -802,12 +911,21 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
                 .slice()
                 .pop();
             if (lastOperation) {
-                await this.listenerStateManager.updateSynchronizationRevision(
-                    drive,
-                    '0',
-                    lastOperation.index,
-                    lastOperation.timestamp
-                );
+                this.listenerStateManager
+                    .updateSynchronizationRevision(
+                        drive,
+                        '0',
+                        lastOperation.index,
+                        lastOperation.timestamp,
+                        this.handleListenerError.bind(this)
+                    )
+                    .catch(error => {
+                        console.error(
+                            'Non handled error updating sync revision',
+                            error
+                        );
+                        this.updateSyncStatus(drive, 'ERROR', error as Error);
+                    });
             }
 
             if (this.shouldSyncRemoteDrive(document)) {
@@ -863,4 +981,15 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
         }
         return status;
     }
+
+    on<K extends keyof DriveEvents>(event: K, cb: DriveEvents[K]): Unsubscribe {
+        return this.emitter.on(event, cb);
+    }
+
+    protected emit<K extends keyof DriveEvents>(
+        event: K,
+        ...args: Parameters<DriveEvents[K]>
+    ): void {
+        return this.emitter.emit(event, ...args);
+    }
 }

package/src/server/listener/manager.ts

@@ -9,6 +9,7 @@ import {
     ErrorStatus,
     Listener,
     ListenerState,
+    OperationUpdate,
     StrandUpdate,
     SynchronizationUnit
 } from '../types';
@@ -120,7 +121,12 @@ export class ListenerManager extends BaseListenerManager {
         driveId: string,
         syncId: string,
         syncRev: number,
-        lastUpdated: string
+        lastUpdated: string,
+        onError?: (
+            error: Error,
+            driveId: string,
+            listener: ListenerState
+        ) => void
     ) {
         const drive = this.listenerState.get(driveId);
         if (!drive) {
@@ -148,7 +154,7 @@ export class ListenerManager extends BaseListenerManager {
         }
 
         if (newRevision) {
-            return this.triggerUpdate();
+            return this.triggerUpdate(onError);
         }
     }
 
@@ -202,6 +208,19 @@ export class ListenerManager extends BaseListenerManager {
         }
     }
 
+    removeSyncUnits(syncUnits: SynchronizationUnit[]) {
+        for (const [driveId, drive] of this.listenerState) {
+            const syncIds = syncUnits
+                .filter(s => s.driveId === driveId)
+                .map(s => s.syncId);
+            for (const [, listenerState] of drive) {
+                listenerState.syncUnits = listenerState.syncUnits.filter(
+                    s => !syncIds.includes(s.syncId)
+                );
+            }
+        }
+    }
+
     async updateListenerRevision(
         listenerId: string,
         driveId: string,
@@ -225,7 +244,13 @@ export class ListenerManager extends BaseListenerManager {
         }
     }
 
-    async triggerUpdate() {
+    async triggerUpdate(
+        onError?: (
+            error: Error,
+            driveId: string,
+            listener: ListenerState
+        ) => void
+    ) {
         for (const [driveId, drive] of this.listenerState) {
             for (const [id, listener] of drive) {
                 const transmitter = await this.getTransmitter(driveId, id);
@@ -248,13 +273,19 @@ export class ListenerManager extends BaseListenerManager {
                         continue;
                     }
 
-                    const opData = await this.drive.getOperationData(
-                        driveId,
-                        syncId,
-                        {
-                            fromRevision: listenerRev
-                        }
-                    );
+                    const opData: OperationUpdate[] = [];
+                    try {
+                        const data = await this.drive.getOperationData(
+                            driveId,
+                            syncId,
+                            {
+                                fromRevision: listenerRev
+                            }
+                        );
+                        opData.push(...data);
+                    } catch (e) {
+                        console.error(e);
+                    }
 
                     if (!opData.length) {
                         continue;
@@ -309,9 +340,9 @@ export class ListenerManager extends BaseListenerManager {
                     listener.listenerStatus = 'SUCCESS';
                 } catch (e) {
                     // TODO: Handle error based on listener params (blocking, retry, etc)
+                    onError?.(e as Error, driveId, listener);
                     listener.listenerStatus =
                         e instanceof OperationError ? e.status : 'ERROR';
-                    throw e;
                 }
             }
         }

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

@@ -76,6 +76,11 @@ export class PullResponderTransmitter implements ITransmitter {
                     fromRevision: entry.listenerRev
                 }
             );
+
+            if (!operations.length) {
+                continue;
+            }
+
             strands.push({
                 driveId,
                 documentId,
@@ -94,12 +99,18 @@ export class PullResponderTransmitter implements ITransmitter {
         revisions: ListenerRevision[]
     ): Promise<boolean> {
         const listener = this.manager.getListener(driveId, listenerId);
+
         let success = true;
         for (const revision of revisions) {
-            const syncId = listener.syncUnits.find(
-                s => s.scope === revision.scope && s.branch === revision.branch && s.documentId === revision.documentId && s.driveId === driveId
-            )?.syncId;
-            if (!syncId) {
+            const syncUnit = listener.syncUnits.find(
+                s =>
+                    s.scope === revision.scope &&
+                    s.branch === revision.branch &&
+                    s.driveId === revision.driveId &&
+                    s.documentId == revision.documentId
+            );
+            if (!syncUnit) {
+                console.log('Sync unit not found', revision);
                 success = false;
                 continue;
             }
@@ -107,7 +118,7 @@ export class PullResponderTransmitter implements ITransmitter {
             await this.manager.updateListenerRevision(
                 listenerId,
                 driveId,
-                syncId,
+                syncUnit.syncId,
                 revision.revision
             );
         }
@@ -235,6 +246,12 @@ export class PullResponderTransmitter implements ITransmitter {
                     listenerId
                     // since ?
                 );
+
+                // if there are no new strands then do nothing
+                if (!strands.length) {
+                    return;
+                }
+
                 const listenerRevisions: ListenerRevision[] = [];
 
                 for (const strand of strands) {

package/src/server/types.ts

@@ -15,6 +15,7 @@ import type {
     Signal,
     State
 } from 'document-model/document';
+import { Unsubscribe } from 'nanoevents';
 import { OperationError } from './error';
 import { ITransmitter } from './listener/transmitter/types';
 
@@ -114,6 +115,11 @@ export type StrandUpdate = {
 
 export type SyncStatus = 'SYNCING' | UpdateStatus;
 
+export interface DriveEvents {
+    syncStatus: (driveId: string, status: SyncStatus, error?: Error) => void;
+    strandUpdate: (update: StrandUpdate) => void;
+}
+
 export abstract class BaseDocumentDriveServer {
     /** Public methods **/
     abstract getDrives(): Promise<string[]>;
@@ -132,12 +138,12 @@ export abstract class BaseDocumentDriveServer {
         drive: string,
         id: string,
         operation: Operation
-    ): Promise<IOperationResult<Document>>;
+    ): Promise<IOperationResult>;
     abstract addOperations(
         drive: string,
         id: string,
         operations: Operation[]
-    ): Promise<IOperationResult<Document>>;
+    ): Promise<IOperationResult>;
 
     abstract addDriveOperation(
         drive: string,
@@ -183,12 +189,23 @@ export abstract class BaseDocumentDriveServer {
         driveId: string,
         listenerId: string
     ): Promise<ITransmitter | undefined>;
+
+    /** Event methods **/
+    protected abstract emit<K extends keyof DriveEvents>(
+        this: this,
+        event: K,
+        ...args: Parameters<DriveEvents[K]>
+    ): void;
+    abstract on<K extends keyof DriveEvents>(
+        this: this,
+        event: K,
+        cb: DriveEvents[K]
+    ): Unsubscribe;
 }
 
 export abstract class BaseListenerManager {
     protected drive: BaseDocumentDriveServer;
-    protected listenerState: Map<string, Map<string, ListenerState>> =
-        new Map();
+    protected listenerState = new Map<string, Map<string, ListenerState>>();
     protected transmitters: Record<
         DocumentDriveState['id'],
         Record<Listener['listenerId'], ITransmitter>
@@ -196,7 +213,7 @@ export abstract class BaseListenerManager {
 
     constructor(
         drive: BaseDocumentDriveServer,
-        listenerState: Map<string, Map<string, ListenerState>> = new Map()
+        listenerState = new Map<string, Map<string, ListenerState>>()
     ) {
         this.drive = drive;
         this.listenerState = listenerState;

package/src/storage/browser.ts

@@ -5,7 +5,7 @@ import {
     DocumentHeader,
     Operation
 } from 'document-model/document';
-import { mergeOperations } from '..';
+import { applyUpdatedOperations, mergeOperations } from '..';
 import { DocumentDriveStorage, DocumentStorage, IDriveStorage } from './types';
 
 export class BrowserStorage implements IDriveStorage {
@@ -57,7 +57,8 @@ export class BrowserStorage implements IDriveStorage {
         drive: string,
         id: string,
         operations: Operation[],
-        header: DocumentHeader
+        header: DocumentHeader,
+        updatedOperations: Operation[] = []
     ): Promise<void> {
         const document = await this.getDocument(drive, id);
         if (!document) {
@@ -69,12 +70,17 @@ export class BrowserStorage implements IDriveStorage {
             operations
         );
 
+        const mergedUpdatedOperations = applyUpdatedOperations(
+            mergedOperations,
+            updatedOperations
+        );
+
         await (
             await this.db
         ).setItem(this.buildKey(drive, id), {
             ...document,
             ...header,
-            operations: mergedOperations
+            operations: mergedUpdatedOperations
         });
     }
 

package/src/storage/filesystem.ts

@@ -12,7 +12,7 @@ import fs from 'fs/promises';
 import stringify from 'json-stringify-deterministic';
 import path from 'path';
 import sanitize from 'sanitize-filename';
-import { mergeOperations } from '..';
+import { applyUpdatedOperations, mergeOperations } from '..';
 import { DocumentDriveStorage, DocumentStorage, IDriveStorage } from './types';
 
 type FSError = {
@@ -104,7 +104,8 @@ export class FilesystemStorage implements IDriveStorage {
         drive: string,
         id: string,
         operations: Operation[],
-        header: DocumentHeader
+        header: DocumentHeader,
+        updatedOperations: Operation[] = []
     ) {
         const document = await this.getDocument(drive, id);
         if (!document) {
@@ -116,10 +117,15 @@ export class FilesystemStorage implements IDriveStorage {
             operations
         );
 
+        const mergedUpdatedOperations = applyUpdatedOperations(
+            mergedOperations,
+            updatedOperations
+        );
+
         this.createDocument(drive, id, {
             ...document,
             ...header,
-            operations: mergedOperations
+            operations: mergedUpdatedOperations
         });
     }
 

package/src/storage/memory.ts

@@ -5,7 +5,7 @@ import {
     DocumentHeader,
     Operation
 } from 'document-model/document';
-import { mergeOperations } from '..';
+import { applyUpdatedOperations, mergeOperations } from '..';
 import { DocumentDriveStorage, DocumentStorage, IDriveStorage } from './types';
 
 export class MemoryStorage implements IDriveStorage {
@@ -67,7 +67,8 @@ export class MemoryStorage implements IDriveStorage {
         drive: string,
         id: string,
         operations: Operation[],
-        header: DocumentHeader
+        header: DocumentHeader,
+        updatedOperations: Operation[] = []
     ): Promise<void> {
         const document = await this.getDocument(drive, id);
         if (!document) {
@@ -79,10 +80,15 @@ export class MemoryStorage implements IDriveStorage {
             operations
         );
 
+        const mergedUpdatedOperations = applyUpdatedOperations(
+            mergedOperations,
+            updatedOperations
+        );
+
         this.documents[drive]![id] = {
             ...document,
             ...header,
-            operations: mergedOperations
+            operations: mergedUpdatedOperations
         };
     }
 

package/src/storage/prisma.ts

@@ -1,9 +1,9 @@
-import { type Prisma } from '@prisma/client';
+import { PrismaClient, type Prisma } from '@prisma/client';
 import {
     DocumentDriveLocalState,
     DocumentDriveState
 } from 'document-model-libs/document-drive';
-import {
+import type {
     DocumentHeader,
     ExtendedState,
     Operation,
@@ -12,16 +12,16 @@ import {
 import { DocumentDriveStorage, DocumentStorage, IDriveStorage } from './types';
 
 export class PrismaStorage implements IDriveStorage {
-    private db: Prisma.TransactionClient;
+    private db: PrismaClient;
 
-    constructor(db: Prisma.TransactionClient) {
+    constructor(db: PrismaClient) {
         this.db = db;
     }
 
     async createDrive(id: string, drive: DocumentDriveStorage): Promise<void> {
+        // drive for all drive documents
         await this.createDocument('drives', id, drive as DocumentStorage);
     }
-
     async addDriveOperations(
         id: string,
         operations: Operation[],
@@ -166,6 +166,9 @@ export class PrismaStorage implements IDriveStorage {
             },
             include: {
                 operations: {
+                    orderBy: {
+                        index: 'asc'
+                    },
                     include: {
                         attachments: true
                     }
@@ -225,7 +228,7 @@ export class PrismaStorage implements IDriveStorage {
                     scope: op.scope as OperationScope
                     // attachments: fileRegistry
                 })),
-            revision: dbDoc.revision as Required<Record<OperationScope, number>>
+            revision: dbDoc.revision as Record<OperationScope, number>
         };
 
         return doc;
@@ -281,7 +284,12 @@ export class PrismaStorage implements IDriveStorage {
     }
 
     async getDrive(id: string) {
-        return this.getDocument('drives', id) as Promise<DocumentDriveStorage>;
+        try {
+            const doc = await this.getDocument('drives', id);
+            return doc as DocumentDriveStorage;
+        } catch (e) {
+            throw new Error(`Drive with id ${id} not found`);
+        }
     }
 
     async deleteDrive(id: string) {

package/src/storage/types.ts

@@ -27,7 +27,8 @@ export interface IStorage {
         drive: string,
         id: string,
         operations: Operation[],
-        header: DocumentHeader
+        header: DocumentHeader,
+        updatedOperations?: Operation[]
     ): Promise<void>;
     deleteDocument(drive: string, id: string): Promise<void>;
 }

package/src/utils/index.ts

@@ -38,3 +38,40 @@ export function generateUUID(): string {
     // eslint-disable-next-line @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
     return crypto.randomUUID() as string;
 }
+
+export function applyUpdatedOperations<A extends Action = Action>(
+    currentOperations: DocumentOperations<A>,
+    updatedOperations: Operation<A | BaseAction>[]
+): DocumentOperations<A> {
+    return updatedOperations.reduce(
+        (acc, curr) => {
+            const operations = acc[curr.scope] ?? [];
+            acc[curr.scope] = operations.map(op => {
+                return op.index === curr.index ? curr : op;
+            });
+            return acc;
+        },
+        { ...currentOperations }
+    );
+}
+
+export function isNoopUpdate(
+    operation: Operation,
+    latestOperation?: Operation
+) {
+    if (!latestOperation) {
+        return false;
+    }
+
+    const isNoopOp = operation.type === 'NOOP';
+    const isNoopLatestOp = latestOperation.type === 'NOOP';
+    const isSameIndexOp = operation.index === latestOperation.index;
+    const isSkipOpGreaterThanLatestOp = operation.skip > latestOperation.skip;
+
+    return (
+        isNoopOp &&
+        isNoopLatestOp &&
+        isSameIndexOp &&
+        isSkipOpGreaterThanLatestOp
+    );
+}