document-drive 0.0.28 → 0.0.29

package/package.json

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

package/src/server/index.ts

@@ -18,7 +18,7 @@ import {
 } from 'document-model/document';
 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';
@@ -127,7 +127,7 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
                     acknowledgeSuccess => {}
                 );
                 driveTriggers.set(trigger.id, intervalId);
-                this.triggerMap.set(trigger.id, driveTriggers);
+                this.triggerMap.set(driveId, driveTriggers);
             }
         }
     }
@@ -465,18 +465,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 +497,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 +520,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 +539,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 +552,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 +571,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;
@@ -634,6 +686,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 +700,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 +712,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 +744,16 @@ 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
+                    )
+                    .catch(error => {
+                        console.error('Error updating sync revision', error);
+                    });
             }
 
             // after applying all the valid operations,throws
@@ -759,11 +825,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 +870,16 @@ 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
+                    )
+                    .catch(error => {
+                        console.error('Error updating sync revision', error);
+                    });
             }
 
             if (this.shouldSyncRemoteDrive(document)) {

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/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
+    );
+}