document-drive 1.0.0-alpha.24 → 1.0.0-alpha.26

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "document-drive",
-    "version": "1.0.0-alpha.24",
+    "version": "1.0.0-alpha.26",
     "license": "AGPL-3.0-only",
     "type": "module",
     "module": "./src/index.ts",

package/src/server/error.ts

@@ -16,3 +16,20 @@ export class OperationError extends Error {
         this.operation = operation;
     }
 }
+
+export class ConflictOperationError extends OperationError {
+    constructor(existingOperation: Operation, newOperation: Operation) {
+        super(
+            'CONFLICT',
+            newOperation,
+            `Conflicting operation on index ${newOperation.index}`,
+            { existingOperation, newOperation }
+        );
+    }
+}
+
+export class MissingOperationError extends OperationError {
+    constructor(index: number, operation: Operation) {
+        super('MISSING', operation, `Missing operation on index ${index}`);
+    }
+}

package/src/server/index.ts

@@ -16,13 +16,18 @@ import {
     BaseAction,
     utils as baseUtils,
     Document,
+    DocumentHeader,
     DocumentModel,
     Operation,
     OperationScope
 } from 'document-model/document';
 import { createNanoEvents, Unsubscribe } from 'nanoevents';
 import { MemoryStorage } from '../storage/memory';
-import type { DocumentStorage, IDriveStorage } from '../storage/types';
+import type {
+    DocumentDriveStorage,
+    DocumentStorage,
+    IDriveStorage
+} from '../storage/types';
 import {
     generateUUID,
     isBefore,
@@ -30,7 +35,11 @@ import {
     isNoopUpdate
 } from '../utils';
 import { requestPublicDrive } from '../utils/graphql';
-import { OperationError } from './error';
+import {
+    ConflictOperationError,
+    MissingOperationError,
+    OperationError
+} from './error';
 import { ListenerManager } from './listener/manager';
 import {
     CancelPullLoop,
@@ -89,7 +98,7 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
     ) {
         if (status === null) {
             this.syncStatus.delete(driveId);
-        } else if (this.getSyncStatus(driveId) !== status) {
+        } else if (this.syncStatus.get(driveId) !== status) {
             this.syncStatus.set(driveId, status);
             this.emit('syncStatus', driveId, status, error);
         }
@@ -200,7 +209,6 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
     }
 
     async initialize() {
-        await this.listenerStateManager.init();
         const drives = await this.getDrives();
         for (const drive of drives) {
             await this._initializeDrive(drive);
@@ -214,22 +222,7 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
             await this.startSyncRemoteDrive(driveId);
         }
 
-        for (const listener of drive.state.local.listeners) {
-            await this.listenerStateManager.addListener({
-                driveId,
-                block: listener.block,
-                filter: {
-                    branch: listener.filter.branch ?? [],
-                    documentId: listener.filter.documentId ?? [],
-                    documentType: listener.filter.documentType ?? [],
-                    scope: listener.filter.scope ?? []
-                },
-                listenerId: listener.listenerId,
-                system: listener.system,
-                callInfo: listener.callInfo ?? undefined,
-                label: listener.label ?? ''
-            });
-        }
+        await this.listenerStateManager.initDrive(drive);
     }
 
     public async getSynchronizationUnits(
@@ -647,11 +640,7 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
             }
 
             if (op.index > nextIndex) {
-                error = new OperationError(
-                    'MISSING',
-                    op,
-                    `Missing operation on index ${nextIndex}`
-                );
+                error = new MissingOperationError(nextIndex, op);
                 continue;
             } else if (op.index < nextIndex) {
                 const existingOperation = scopeOperations
@@ -661,19 +650,10 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
                             existingOperation.index === op.index
                     );
                 if (existingOperation && existingOperation.hash !== op.hash) {
-                    error = new OperationError(
-                        'CONFLICT',
-                        op,
-                        `Conflicting operation on index ${op.index}`,
-                        { existingOperation, newOperation: op }
-                    );
+                    error = new ConflictOperationError(existingOperation, op);
                     continue;
                 } else if (!existingOperation) {
-                    error = new OperationError(
-                        'MISSING',
-                        op,
-                        `Missing operation on index ${nextIndex}`
-                    );
+                    error = new MissingOperationError(nextIndex, op);
                     continue;
                 }
             } else {
@@ -773,10 +753,42 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
         return this.addOperations(drive, id, [operation]);
     }
 
-    async addOperations(drive: string, id: string, operations: Operation[]) {
-        // retrieves document from storage
-        const documentStorage = await this.storage.getDocument(drive, id);
+    private async _addOperations(
+        drive: string,
+        id: string,
+        callback: (document: DocumentStorage) => Promise<{
+            operations: Operation[];
+            header: DocumentHeader;
+            updatedOperations?: Operation[];
+        }>
+    ) {
+        if (!this.storage.addDocumentOperationsWithTransaction) {
+            const documentStorage = await this.storage.getDocument(drive, id);
+            const result = await callback(documentStorage);
+            // saves the applied operations to storage
+            if (
+                result.operations.length > 0 ||
+                (result.updatedOperations &&
+                    result.updatedOperations.length > 0)
+            ) {
+                await this.storage.addDocumentOperations(
+                    drive,
+                    id,
+                    result.operations,
+                    result.header,
+                    result.updatedOperations
+                );
+            }
+        } else {
+            await this.storage.addDocumentOperationsWithTransaction(
+                drive,
+                id,
+                callback
+            );
+        }
+    }
 
+    async addOperations(drive: string, id: string, operations: Operation[]) {
         let document: Document | undefined;
         const operationsApplied: Operation[] = [];
         const updatedOperations: Operation[] = [];
@@ -784,36 +796,29 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
         let error: Error | undefined;
 
         try {
-            // retrieves the document's document model and
-            // applies the operations using its reducer
-            const result = await this._processOperations(
-                drive,
-                documentStorage,
-                operations
-            );
-
-            document = result.document;
-
-            operationsApplied.push(...result.operationsApplied);
-            updatedOperations.push(...result.operationsUpdated);
+            await this._addOperations(drive, id, async documentStorage => {
+                const result = await this._processOperations(
+                    drive,
+                    documentStorage,
+                    operations
+                );
 
-            signals.push(...result.signals);
-            error = result.error;
+                if (!result.document) {
+                    throw result.error ?? new Error('Invalid document');
+                }
 
-            if (!document) {
-                throw error ?? new Error('Invalid document');
-            }
+                document = result.document;
+                error = result.error;
+                signals.push(...result.signals);
+                operationsApplied.push(...result.operationsApplied);
+                updatedOperations.push(...result.operationsUpdated);
 
-            // saves the applied operations to storage
-            if (operationsApplied.length > 0 || updatedOperations.length > 0) {
-                await this.storage.addDocumentOperations(
-                    drive,
-                    id,
-                    operationsApplied,
-                    document,
-                    updatedOperations
-                );
-            }
+                return {
+                    operations: result.operationsApplied,
+                    header: result.document,
+                    updatedOperations: result.operationsUpdated
+                };
+            });
 
             // gets all the different scopes and branches combinations from the operations
             const { scopes, branches } = [
@@ -908,13 +913,38 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
         await this.storage.clearStorage?.();
     }
 
+    private async _addDriveOperations(
+        drive: string,
+        callback: (document: DocumentDriveStorage) => Promise<{
+            operations: Operation<DocumentDriveAction | BaseAction>[];
+            header: DocumentHeader;
+            updatedOperations?: Operation[];
+        }>
+    ) {
+        if (!this.storage.addDriveOperationsWithTransaction) {
+            const documentStorage = await this.storage.getDrive(drive);
+            const result = await callback(documentStorage);
+            // saves the applied operations to storage
+            if (result.operations.length > 0) {
+                await this.storage.addDriveOperations(
+                    drive,
+                    result.operations,
+                    result.header
+                );
+            }
+            return result;
+        } else {
+            return this.storage.addDriveOperationsWithTransaction(
+                drive,
+                callback
+            );
+        }
+    }
+
     async addDriveOperations(
         drive: string,
         operations: Operation<DocumentDriveAction | BaseAction>[]
     ) {
-        // retrieves document from storage
-        const documentStorage = await this.storage.getDrive(drive);
-
         let document: DocumentDriveDocument | undefined;
         const operationsApplied: Operation<DocumentDriveAction | BaseAction>[] =
             [];
@@ -922,29 +952,28 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
         let error: Error | undefined;
 
         try {
-            const result = await this._processOperations<
-                DocumentDriveDocument,
-                DocumentDriveAction
-            >(drive, documentStorage, operations.slice());
+            await this._addDriveOperations(drive, async documentStorage => {
+                const result = await this._processOperations<
+                    DocumentDriveDocument,
+                    DocumentDriveAction
+                >(drive, documentStorage, operations.slice());
 
-            document = result.document;
-            operationsApplied.push(...result.operationsApplied);
-            signals.push(...result.signals);
-            error = result.error;
+                document = result.document;
+                operationsApplied.push(...result.operationsApplied);
+                signals.push(...result.signals);
+                error = result.error;
+
+                return {
+                    operations: result.operationsApplied,
+                    header: result.document,
+                    updatedOperations: result.operationsUpdated
+                };
+            });
 
             if (!document || !isDocumentDrive(document)) {
                 throw error ?? new Error('Invalid Document Drive document');
             }
 
-            // saves the applied operations to storage
-            if (operationsApplied.length > 0) {
-                await this.storage.addDriveOperations(
-                    drive,
-                    operationsApplied,
-                    document
-                );
-            }
-
             for (const operation of operationsApplied) {
                 switch (operation.type) {
                     case 'ADD_LISTENER': {

package/src/server/listener/manager.ts

@@ -1,5 +1,5 @@
 import {
-    ListenerCallInfo,
+    DocumentDriveDocument,
     ListenerFilter
 } from 'document-model-libs/document-drive';
 import { OperationScope } from 'document-model/document';
@@ -372,33 +372,28 @@ export class ListenerManager extends BaseListenerManager {
         return false;
     }
 
-    async init() {
-        const drives = await this.drive.getDrives();
-        for (const driveId of drives) {
-            const drive = await this.drive.getDrive(driveId);
-            const {
-                state: {
-                    local: { listeners }
-                }
-            } = drive;
-
-            for (const listener of listeners) {
-                this.addListener({
-                    block: listener.block,
-                    driveId,
-                    filter: {
-                        branch: listener.filter.branch ?? [],
-                        documentId: listener.filter.documentId ?? [],
-                        documentType: listener.filter.documentType,
-                        scope: listener.filter.scope ?? []
-                    },
-                    listenerId: listener.listenerId,
-                    system: listener.system,
-                    callInfo:
-                        (listener.callInfo as ListenerCallInfo) ?? undefined,
-                    label: listener.label ?? ''
-                });
+    async initDrive(drive: DocumentDriveDocument) {
+        const {
+            state: {
+                local: { listeners }
             }
+        } = drive;
+
+        for (const listener of listeners) {
+            await this.addListener({
+                block: listener.block,
+                driveId: drive.state.global.id,
+                filter: {
+                    branch: listener.filter.branch ?? [],
+                    documentId: listener.filter.documentId ?? [],
+                    documentType: listener.filter.documentType,
+                    scope: listener.filter.scope ?? []
+                },
+                listenerId: listener.listenerId,
+                system: listener.system,
+                callInfo: listener.callInfo ?? undefined,
+                label: listener.label ?? ''
+            });
         }
     }
 

package/src/server/types.ts

@@ -267,7 +267,7 @@ export abstract class BaseListenerManager {
         this.listenerState = listenerState;
     }
 
-    abstract init(): Promise<void>;
+    abstract initDrive(drive: DocumentDriveDocument): Promise<void>;
 
     abstract addListener(listener: Listener): Promise<ITransmitter>;
     abstract removeListener(

package/src/storage/prisma.ts

@@ -1,16 +1,40 @@
 import { PrismaClient, type Prisma } from '@prisma/client';
+import { PrismaClientKnownRequestError } from '@prisma/client/runtime/library';
 import {
+    DocumentDriveAction,
     DocumentDriveLocalState,
     DocumentDriveState
 } from 'document-model-libs/document-drive';
 import type {
+    BaseAction,
     DocumentHeader,
     ExtendedState,
     Operation,
     OperationScope
 } from 'document-model/document';
+import { ConflictOperationError } from '../server/error';
 import { DocumentDriveStorage, DocumentStorage, IDriveStorage } from './types';
 
+type Transaction = Omit<
+    PrismaClient<Prisma.PrismaClientOptions, never>,
+    '$connect' | '$disconnect' | '$on' | '$transaction' | '$use' | '$extends'
+>;
+
+function storageToOperation(
+    op: Prisma.$OperationPayload['scalars']
+): Operation {
+    return {
+        skip: op.skip,
+        hash: op.hash,
+        index: op.index,
+        timestamp: new Date(op.timestamp).toISOString(),
+        input: op.input,
+        type: op.type,
+        scope: op.scope as OperationScope
+        // attachments: fileRegistry
+    };
+}
+
 export class PrismaStorage implements IDriveStorage {
     private db: PrismaClient;
 
@@ -30,6 +54,21 @@ export class PrismaStorage implements IDriveStorage {
         await this.addDocumentOperations('drives', id, operations, header);
     }
 
+    async addDriveOperationsWithTransaction(
+        drive: string,
+        callback: (document: DocumentDriveStorage) => Promise<{
+            operations: Operation<DocumentDriveAction | BaseAction>[];
+            header: DocumentHeader;
+            updatedOperations?: Operation[] | undefined;
+        }>
+    ) {
+        return this.addDocumentOperationsWithTransaction(
+            'drives',
+            drive,
+            document => callback(document as DocumentDriveStorage)
+        );
+    }
+
     async createDocument(
         drive: string,
         id: string,
@@ -54,25 +93,23 @@ export class PrismaStorage implements IDriveStorage {
             }
         });
     }
-    async addDocumentOperations(
+
+    private async _addDocumentOperations(
+        tx: Transaction,
         drive: string,
         id: string,
         operations: Operation[],
         header: DocumentHeader,
         updatedOperations: Operation[] = []
     ): Promise<void> {
-        const document = await this.getDocument(drive, id);
+        const document = await this.getDocument(drive, id, tx);
         if (!document) {
             throw new Error(`Document with id ${id} not found`);
         }
 
-        const mergedOperations = [...operations, ...updatedOperations].sort(
-            (a, b) => a.index - b.index
-        );
-
         try {
-            await this.db.operation.createMany({
-                data: mergedOperations.map(op => ({
+            await tx.operation.createMany({
+                data: operations.map(op => ({
                     driveId: drive,
                     documentId: id,
                     hash: op.hash,
@@ -86,7 +123,35 @@ export class PrismaStorage implements IDriveStorage {
                 }))
             });
 
-            await this.db.document.updateMany({
+            await Promise.all(
+                updatedOperations.map(op =>
+                    tx.operation.updateMany({
+                        where: {
+                            AND: {
+                                driveId: drive,
+                                documentId: id,
+                                scope: op.scope,
+                                branch: 'main',
+                                index: op.index
+                            }
+                        },
+                        data: {
+                            driveId: drive,
+                            documentId: id,
+                            hash: op.hash,
+                            index: op.index,
+                            input: op.input as Prisma.InputJsonObject,
+                            timestamp: op.timestamp,
+                            type: op.type,
+                            scope: op.scope,
+                            branch: 'main',
+                            skip: op.skip
+                        }
+                    })
+                )
+            );
+
+            await tx.document.updateMany({
                 where: {
                     id,
                     driveId: drive
@@ -97,8 +162,103 @@ export class PrismaStorage implements IDriveStorage {
                 }
             });
         } catch (e) {
-            console.log(e);
+            // P2002: Unique constraint failed
+            // Operation with existing index
+            if (
+                e instanceof PrismaClientKnownRequestError &&
+                e.code === 'P2002'
+            ) {
+                const existingOperation = await this.db.operation.findFirst({
+                    where: {
+                        AND: operations.map(op => ({
+                            driveId: drive,
+                            documentId: id,
+                            scope: op.scope,
+                            branch: 'main',
+                            index: op.index
+                        }))
+                    }
+                });
+
+                const conflictOp = operations.find(
+                    op =>
+                        existingOperation?.index === op.index &&
+                        existingOperation.scope === op.scope
+                );
+
+                if (!existingOperation || !conflictOp) {
+                    throw e;
+                } else {
+                    throw new ConflictOperationError(
+                        storageToOperation(existingOperation),
+                        conflictOp
+                    );
+                }
+            } else {
+                throw e;
+            }
+        }
+    }
+
+    async addDocumentOperationsWithTransaction(
+        drive: string,
+        id: string,
+        callback: (document: DocumentStorage) => Promise<{
+            operations: Operation[];
+            header: DocumentHeader;
+            updatedOperations?: Operation[] | undefined;
+        }>
+    ) {
+        let result: {
+            operations: Operation[];
+            header: DocumentHeader;
+            updatedOperations?: Operation[] | undefined;
+        } | null = null;
+
+        await this.db.$transaction(async tx => {
+            const document = await this.getDocument(drive, id, tx);
+
+            if (!document) {
+                throw new Error(`Document with id ${id} not found`);
+            }
+
+            result = await callback(document);
+
+            const { operations, header, updatedOperations } = result;
+
+            return this._addDocumentOperations(
+                tx,
+                drive,
+                id,
+                operations,
+                header,
+                updatedOperations
+            );
+        });
+
+        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+        if (!result) {
+            throw new Error('No operations were provided');
         }
+
+        return result;
+    }
+
+    async addDocumentOperations(
+        drive: string,
+        id: string,
+        operations: Operation[],
+        header: DocumentHeader,
+        updatedOperations: Operation[] = []
+    ): Promise<void> {
+        return this._addDocumentOperations(
+            this.db,
+            drive,
+            id,
+            operations,
+            header,
+            updatedOperations
+        );
     }
 
     async getDocuments(drive: string) {
@@ -116,8 +276,8 @@ export class PrismaStorage implements IDriveStorage {
         return docs.map(doc => doc.id);
     }
 
-    async getDocument(driveId: string, id: string) {
-        const result = await this.db.document.findFirst({
+    async getDocument(driveId: string, id: string, tx?: Transaction) {
+        const result = await (tx ?? this.db).document.findFirst({
             where: {
                 id: id,
                 driveId: driveId
@@ -151,41 +311,14 @@ export class PrismaStorage implements IDriveStorage {
             operations: {
                 global: dbDoc.operations
                     .filter(op => op.scope === 'global' && !op.clipboard)
-                    .map(op => ({
-                        skip: op.skip,
-                        hash: op.hash,
-                        index: op.index,
-                        timestamp: new Date(op.timestamp).toISOString(),
-                        input: op.input,
-                        type: op.type,
-                        scope: op.scope as OperationScope
-                        // attachments: fileRegistry
-                    })),
+                    .map(storageToOperation),
                 local: dbDoc.operations
                     .filter(op => op.scope === 'local' && !op.clipboard)
-                    .map(op => ({
-                        skip: op.skip,
-                        hash: op.hash,
-                        index: op.index,
-                        timestamp: new Date(op.timestamp).toISOString(),
-                        input: op.input,
-                        type: op.type,
-                        scope: op.scope as OperationScope
-                        // attachments: fileRegistry
-                    }))
+                    .map(storageToOperation)
             },
             clipboard: dbDoc.operations
                 .filter(op => op.clipboard)
-                .map(op => ({
-                    skip: op.skip,
-                    hash: op.hash,
-                    index: op.index,
-                    timestamp: new Date(op.timestamp).toISOString(),
-                    input: op.input,
-                    type: op.type,
-                    scope: op.scope as OperationScope
-                    // attachments: fileRegistry
-                })),
+                .map(storageToOperation),
             revision: dbDoc.revision as Record<OperationScope, number>
         };
 
@@ -219,6 +352,7 @@ export class PrismaStorage implements IDriveStorage {
             const doc = await this.getDocument('drives', id);
             return doc as DocumentDriveStorage;
         } catch (e) {
+            console.error(e);
             throw new Error(`Drive with id ${id} not found`);
         }
     }

package/src/storage/sequelize.ts

@@ -146,7 +146,8 @@ export class SequelizeStorage 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) {
@@ -158,31 +159,48 @@ export class SequelizeStorage implements IDriveStorage {
             throw new Error('Operation model not found');
         }
 
-        await Promise.all(
-            operations.map(async op => {
-                return Operation.create({
-                    driveId: drive,
-                    documentId: id,
-                    hash: op.hash,
-                    index: op.index,
-                    input: op.input,
-                    timestamp: op.timestamp,
-                    type: op.type,
-                    scope: op.scope,
-                    branch: 'main'
-                }).then(async () => {
-                    if (op.attachments) {
-                        await this._addDocumentOperationAttachments(
-                            drive,
-                            id,
-                            op,
-                            op.attachments
-                        );
-                    }
-                });
-            })
+        await Operation.bulkCreate(
+            operations.map(op => ({
+                driveId: drive,
+                documentId: id,
+                hash: op.hash,
+                index: op.index,
+                input: op.input,
+                timestamp: op.timestamp,
+                type: op.type,
+                scope: op.scope,
+                branch: 'main'
+            }))
         );
 
+        const attachments = operations.reduce<AttachmentInput[]>((acc, op) => {
+            if (op.attachments?.length) {
+                return acc.concat(
+                    op.attachments.map(attachment => ({
+                        driveId: drive,
+                        documentId: id,
+                        scope: op.scope,
+                        branch: 'main',
+                        index: op.index,
+                        mimeType: attachment.mimeType,
+                        fileName: attachment.fileName,
+                        extension: attachment.extension,
+                        data: attachment.data,
+                        hash: attachment.hash
+                    }))
+                );
+            }
+            return acc;
+        }, []);
+        if (attachments.length) {
+            const Attachment = this.db.models.attachment;
+            if (!Attachment) {
+                throw new Error('Attachment model not found');
+            }
+
+            await Attachment.bulkCreate(attachments);
+        }
+
         const Document = this.db.models.document;
         if (!Document) {
             throw new Error('Document model not found');
@@ -213,21 +231,19 @@ export class SequelizeStorage implements IDriveStorage {
             throw new Error('Attachment model not found');
         }
 
-        await Promise.all(
-            attachments.map(async attachment => {
-                return Attachment.create({
-                    driveId: driveId,
-                    documentId: documentId,
-                    scope: operation.scope,
-                    branch: 'main',
-                    index: operation.index,
-                    mimeType: attachment.mimeType,
-                    fileName: attachment.fileName,
-                    extension: attachment.extension,
-                    data: attachment.data,
-                    hash: attachment.hash
-                });
-            })
+        return Attachment.bulkCreate(
+            attachments.map(attachment => ({
+                driveId: driveId,
+                documentId: documentId,
+                scope: operation.scope,
+                branch: 'main',
+                index: operation.index,
+                mimeType: attachment.mimeType,
+                fileName: attachment.fileName,
+                extension: attachment.extension,
+                data: attachment.data,
+                hash: attachment.hash
+            }))
         );
     }
 

package/src/storage/types.ts

@@ -30,6 +30,15 @@ export interface IStorage {
         header: DocumentHeader,
         updatedOperations?: Operation[]
     ): Promise<void>;
+    addDocumentOperationsWithTransaction?(
+        drive: string,
+        id: string,
+        callback: (document: DocumentStorage) => Promise<{
+            operations: Operation[];
+            header: DocumentHeader;
+            updatedOperations?: Operation[];
+        }>
+    ): Promise<void>;
     deleteDocument(drive: string, id: string): Promise<void>;
 }
 
@@ -44,4 +53,12 @@ export interface IDriveStorage extends IStorage {
         operations: Operation<DocumentDriveAction | BaseAction>[],
         header: DocumentHeader
     ): Promise<void>;
+    addDriveOperationsWithTransaction?(
+        drive: string,
+        callback: (document: DocumentDriveStorage) => Promise<{
+            operations: Operation[];
+            header: DocumentHeader;
+            updatedOperations?: Operation[];
+        }>
+    ): Promise<void>;
 }

package/src/utils/index.ts

@@ -10,7 +10,7 @@ import {
     DocumentOperations,
     Operation
 } from 'document-model/document';
-import { OperationError } from '../server/error';
+import { ConflictOperationError } from '../server/error';
 
 export function isDocumentDrive(
     document: Document
@@ -25,21 +25,19 @@ export function mergeOperations<A extends Action = Action>(
     currentOperations: DocumentOperations<A>,
     newOperations: Operation<A | BaseAction>[]
 ): DocumentOperations<A> {
-    const conflictOp = newOperations.find(op =>
-        currentOperations[op.scope].find(
+    let existingOperation: Operation<A | BaseAction> | null = null;
+    const conflictOp = newOperations.find(op => {
+        const result = currentOperations[op.scope].find(
             o => o.index === op.index && o.scope === op.scope
-        )
-    );
-    if (conflictOp) {
-        const existingOperation = currentOperations[conflictOp.scope].find(
-            o => o.index === conflictOp.index && o.scope === conflictOp.scope
-        );
-        throw new OperationError(
-            'CONFLICT',
-            conflictOp,
-            `Conflicting operation on index ${conflictOp.index}`,
-            { existingOperation, newOperation: conflictOp }
         );
+        if (result) {
+            existingOperation = result;
+            return true;
+        }
+    });
+    if (conflictOp) {
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        throw new ConflictOperationError(existingOperation!, conflictOp);
     }
 
     return newOperations.reduce((acc, curr) => {