document-drive 1.0.0-alpha.2 → 1.0.0-alpha.21

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "document-drive",
-    "version": "1.0.0-alpha.2",
+    "version": "1.0.0-alpha.21",
     "license": "AGPL-3.0-only",
     "type": "module",
     "module": "./src/index.ts",
@@ -30,8 +30,8 @@
     },
     "peerDependencies": {
         "@prisma/client": "5.8.1",
-        "document-model": "^1.0.29",
-        "document-model-libs": "^1.1.44",
+        "document-model": "^1.0.34",
+        "document-model-libs": "^1.1.51",
         "localforage": "^1.10.0",
         "sequelize": "^6.35.2",
         "sqlite3": "^5.1.7"
@@ -54,8 +54,8 @@
         "@typescript-eslint/eslint-plugin": "^6.18.1",
         "@typescript-eslint/parser": "^6.18.1",
         "@vitest/coverage-v8": "^0.34.6",
-        "document-model": "^1.0.29",
-        "document-model-libs": "^1.1.48",
+        "document-model": "^1.0.34",
+        "document-model-libs": "^1.17.1",
         "eslint": "^8.56.0",
         "eslint-config-prettier": "^9.1.0",
         "fake-indexeddb": "^5.0.1",

package/src/server/index.ts

@@ -1,9 +1,13 @@
 import {
+    actions,
+    AddListenerInput,
     DocumentDriveAction,
     DocumentDriveDocument,
     DocumentDriveState,
     FileNode,
     isFileNode,
+    ListenerFilter,
+    RemoveListenerInput,
     Trigger,
     utils
 } from 'document-model-libs/document-drive';
@@ -19,18 +23,26 @@ import {
 import { createNanoEvents, Unsubscribe } from 'nanoevents';
 import { MemoryStorage } from '../storage/memory';
 import type { DocumentStorage, IDriveStorage } from '../storage/types';
-import { generateUUID, isDocumentDrive, isNoopUpdate } from '../utils';
+import {
+    generateUUID,
+    isBefore,
+    isDocumentDrive,
+    isNoopUpdate
+} from '../utils';
 import { requestPublicDrive } from '../utils/graphql';
 import { OperationError } from './error';
 import { ListenerManager } from './listener/manager';
 import {
     CancelPullLoop,
+    InternalTransmitter,
+    IReceiver,
     ITransmitter,
     PullResponderTransmitter
 } from './listener/transmitter';
 import {
     BaseDocumentDriveServer,
     DriveEvents,
+    GetDocumentOptions,
     IOperationResult,
     ListenerState,
     RemoteDriveOptions,
@@ -42,6 +54,7 @@ import {
     type SignalResult,
     type SynchronizationUnit
 } from './types';
+import { filterOperationsByRevision } from './utils';
 
 export * from './listener';
 export type * from './types';
@@ -71,11 +84,15 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
 
     private updateSyncStatus(
         driveId: string,
-        status: SyncStatus,
+        status: SyncStatus | null,
         error?: Error
     ) {
-        this.syncStatus.set(driveId, status);
-        this.emit('syncStatus', driveId, status, error);
+        if (status === null) {
+            this.syncStatus.delete(driveId);
+        } else if (this.getSyncStatus(driveId) !== status) {
+            this.syncStatus.set(driveId, status);
+            this.emit('syncStatus', driveId, status, error);
+        }
     }
 
     private async saveStrand(strand: StrandUpdate) {
@@ -178,17 +195,40 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
     private async stopSyncRemoteDrive(driveId: string) {
         const triggers = this.triggerMap.get(driveId);
         triggers?.forEach(cancel => cancel());
+        this.updateSyncStatus(driveId, null);
         return this.triggerMap.delete(driveId);
     }
 
     async initialize() {
         await this.listenerStateManager.init();
         const drives = await this.getDrives();
-        for (const id of drives) {
-            const drive = await this.getDrive(id);
-            if (this.shouldSyncRemoteDrive(drive)) {
-                this.startSyncRemoteDrive(id);
-            }
+        for (const drive of drives) {
+            await this._initializeDrive(drive);
+        }
+    }
+
+    private async _initializeDrive(driveId: string) {
+        const drive = await this.getDrive(driveId);
+
+        if (this.shouldSyncRemoteDrive(drive)) {
+            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 ?? ''
+            });
         }
     }
 
@@ -203,13 +243,38 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
         const nodes = drive.state.global.nodes.filter(
             node =>
                 isFileNode(node) &&
-                (!documentId?.length || documentId.includes(node.id)) // TODO support * as documentId
-        ) as FileNode[];
+                (!documentId?.length ||
+                    documentId.includes(node.id) ||
+                    documentId.includes('*'))
+        ) as Pick<
+            FileNode,
+            'id' | 'documentType' | 'scopes' | 'synchronizationUnits'
+        >[];
 
         if (documentId && !nodes.length) {
             throw new Error('File node not found');
         }
 
+        // checks if document drive synchronization unit should be added
+        if (
+            !documentId ||
+            documentId.includes('*') ||
+            documentId.includes('')
+        ) {
+            nodes.unshift({
+                id: '',
+                documentType: 'powerhouse/document-drive',
+                scopes: ['global'],
+                synchronizationUnits: [
+                    {
+                        syncId: '0',
+                        scope: 'global',
+                        branch: 'main'
+                    }
+                ]
+            });
+        }
+
         const synchronizationUnits: SynchronizationUnit[] = [];
 
         for (const node of nodes) {
@@ -225,7 +290,9 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
                 continue;
             }
 
-            const document = await this.getDocument(driveId, node.id);
+            const document = await (node.id
+                ? this.getDocument(driveId, node.id)
+                : this.getDrive(driveId));
 
             for (const { syncId, scope, branch } of nodeUnits) {
                 const operations =
@@ -305,10 +372,10 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
         const filteredOperations = operations.filter(
             operation =>
                 Object.keys(filter).length === 0 ||
-                (filter.since !== undefined &&
-                    filter.since <= operation.timestamp) ||
-                (filter.fromRevision !== undefined &&
-                    operation.index > filter.fromRevision)
+                ((filter.since === undefined ||
+                    isBefore(filter.since, operation.timestamp)) &&
+                    (filter.fromRevision === undefined ||
+                        operation.index > filter.fromRevision))
         );
 
         return filteredOperations.map(operation => ({
@@ -349,30 +416,7 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
         });
 
         await this.storage.createDrive(id, document);
-
-        // add listeners to state manager
-        for (const listener of drive.local.listeners) {
-            await this.listenerStateManager.addListener({
-                block: listener.block,
-                driveId: 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 ?? ''
-            });
-        }
-
-        // if it is a remote drive that should be available offline, starts
-        // the sync process to pull changes from remote every 30 seconds
-        if (this.shouldSyncRemoteDrive(document)) {
-            await this.startSyncRemoteDrive(id);
-        }
+        await this._initializeDrive(id);
     }
 
     async addRemoteDrive(url: string, options: RemoteDriveOptions) {
@@ -385,26 +429,12 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
             listeners,
             triggers
         } = options;
-        const listenerId = await PullResponderTransmitter.registerPullResponder(
-            id,
-            url,
-            pullFilter ?? {
-                documentId: ['*'],
-                documentType: ['*'],
-                branch: ['*'],
-                scope: ['*']
-            }
-        );
 
-        const pullTrigger: Trigger = {
-            id: generateUUID(),
-            type: 'PullResponder',
-            data: {
-                url,
-                listenerId,
-                interval: pullInterval?.toString() ?? ''
-            }
-        };
+        const pullTrigger =
+            await PullResponderTransmitter.createPullResponderTrigger(id, url, {
+                pullFilter,
+                pullInterval
+            });
 
         return await this.addDrive({
             global: {
@@ -431,12 +461,15 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
         return this.storage.getDrives();
     }
 
-    async getDrive(drive: string) {
+    async getDrive(drive: string, options?: GetDocumentOptions) {
         const driveStorage = await this.storage.getDrive(drive);
         const documentModel = this._getDocumentModel(driveStorage.documentType);
         const document = baseUtils.replayDocument(
             driveStorage.initialState,
-            driveStorage.operations,
+            filterOperationsByRevision(
+                driveStorage.operations,
+                options?.revisions
+            ),
             documentModel.reducer,
             undefined,
             driveStorage
@@ -450,7 +483,7 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
         }
     }
 
-    async getDocument(drive: string, id: string) {
+    async getDocument(drive: string, id: string, options?: GetDocumentOptions) {
         const { initialState, operations, ...header } =
             await this.storage.getDocument(drive, id);
 
@@ -458,7 +491,7 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
 
         return baseUtils.replayDocument(
             initialState,
-            operations,
+            filterOperationsByRevision(operations, options?.revisions),
             documentModel.reducer,
             undefined,
             header
@@ -859,6 +892,14 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
         return this.addDriveOperations(drive, [operation]);
     }
 
+    async clearStorage() {
+        for (const drive of await this.getDrives()) {
+            await this.deleteDrive(drive);
+        }
+
+        await this.storage.clearStorage?.();
+    }
+
     async addDriveOperations(
         drive: string,
         operations: Operation<DocumentDriveAction | BaseAction>[]
@@ -897,33 +938,15 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
             }
 
             for (const operation of operationsApplied) {
-                if (operation.type === 'ADD_LISTENER') {
-                    const { listener } = operation.input;
-                    await this.listenerStateManager.addListener({
-                        ...listener,
-                        driveId: drive,
-                        label: listener.label ?? '',
-                        system: listener.system ?? false,
-                        filter: {
-                            branch: listener.filter.branch ?? [],
-                            documentId: listener.filter.documentId ?? [],
-                            documentType: listener.filter.documentType ?? [],
-                            scope: listener.filter.scope ?? []
-                        },
-                        callInfo: {
-                            data: listener.callInfo?.data ?? '',
-                            name: listener.callInfo?.name ?? 'PullResponder',
-                            transmitterType:
-                                listener.callInfo?.transmitterType ??
-                                'PullResponder'
-                        }
-                    });
-                } else if (operation.type === 'REMOVE_LISTENER') {
-                    const { listenerId } = operation.input;
-                    await this.listenerStateManager.removeListener(
-                        drive,
-                        listenerId
-                    );
+                switch (operation.type) {
+                    case 'ADD_LISTENER': {
+                        await this.addListener(drive, operation);
+                        break;
+                    }
+                    case 'REMOVE_LISTENER': {
+                        await this.removeListener(drive, operation);
+                        break;
+                    }
                 }
             }
 
@@ -995,6 +1018,149 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
         }
     }
 
+    private _buildOperation<T extends Action>(
+        documentStorage: DocumentStorage,
+        action: T | BaseAction
+    ): Operation<T | BaseAction> {
+        const [operation] = this._buildOperations(documentStorage, [action]);
+        if (!operation) {
+            throw new Error('Error creating operation');
+        }
+        return operation;
+    }
+
+    private _buildOperations<T extends Action>(
+        documentStorage: DocumentStorage,
+        actions: (T | BaseAction)[]
+    ): Operation<T | BaseAction>[] {
+        const operations: Operation<T | BaseAction>[] = [];
+        const { reducer } = this._getDocumentModel(
+            documentStorage.documentType
+        );
+        let document = baseUtils.replayDocument(
+            documentStorage.initialState,
+            documentStorage.operations,
+            reducer,
+            undefined,
+            documentStorage
+        );
+        for (const action of actions) {
+            document = reducer(document, action);
+            const operation = document.operations[action.scope].slice().pop();
+            if (!operation) {
+                throw new Error('Error creating operations');
+            }
+            operations.push(operation);
+        }
+        return operations;
+    }
+
+    async addAction(
+        drive: string,
+        id: string,
+        action: Action
+    ): Promise<IOperationResult> {
+        const documentStorage = await this.storage.getDocument(drive, id);
+        const operation = this._buildOperation(documentStorage, action);
+        return this.addOperation(drive, id, operation);
+    }
+
+    async addActions(
+        drive: string,
+        id: string,
+        actions: Action[]
+    ): Promise<IOperationResult> {
+        const documentStorage = await this.storage.getDocument(drive, id);
+        const operations = this._buildOperations(documentStorage, actions);
+        return this.addOperations(drive, id, operations);
+    }
+
+    async addDriveAction(
+        drive: string,
+        action: DocumentDriveAction | BaseAction
+    ): Promise<IOperationResult<DocumentDriveDocument>> {
+        const documentStorage = await this.storage.getDrive(drive);
+        const operation = this._buildOperation(documentStorage, action);
+        return this.addDriveOperation(drive, operation);
+    }
+
+    async addDriveActions(
+        drive: string,
+        actions: (DocumentDriveAction | BaseAction)[]
+    ): Promise<IOperationResult<DocumentDriveDocument>> {
+        const documentStorage = await this.storage.getDrive(drive);
+        const operations = this._buildOperations(documentStorage, actions);
+        return this.addDriveOperations(drive, operations);
+    }
+
+    async addInternalListener(
+        driveId: string,
+        receiver: IReceiver,
+        options: {
+            listenerId: string;
+            label: string;
+            block: boolean;
+            filter: ListenerFilter;
+        }
+    ) {
+        const listener: AddListenerInput['listener'] = {
+            callInfo: {
+                data: '',
+                name: 'Interal',
+                transmitterType: 'Internal'
+            },
+            system: true,
+            ...options
+        };
+        await this.addDriveAction(driveId, actions.addListener({ listener }));
+        const transmitter = await this.getTransmitter(
+            driveId,
+            options.listenerId
+        );
+        if (!transmitter) {
+            throw new Error('Internal listener not found');
+        }
+        if (!(transmitter instanceof InternalTransmitter)) {
+            throw new Error('Listener is not an internal transmitter');
+        }
+
+        transmitter.setReceiver(receiver);
+        return transmitter;
+    }
+
+    private async addListener(
+        driveId: string,
+        operation: Operation<Action<'ADD_LISTENER', AddListenerInput>>
+    ) {
+        const { listener } = operation.input;
+        await this.listenerStateManager.addListener({
+            ...listener,
+            driveId,
+            label: listener.label ?? '',
+            system: listener.system ?? false,
+            filter: {
+                branch: listener.filter.branch ?? [],
+                documentId: listener.filter.documentId ?? [],
+                documentType: listener.filter.documentType ?? [],
+                scope: listener.filter.scope ?? []
+            },
+            callInfo: {
+                data: listener.callInfo?.data ?? '',
+                name: listener.callInfo?.name ?? 'PullResponder',
+                transmitterType:
+                    listener.callInfo?.transmitterType ?? 'PullResponder'
+            }
+        });
+    }
+
+    private async removeListener(
+        driveId: string,
+        operation: Operation<Action<'REMOVE_LISTENER', RemoveListenerInput>>
+    ) {
+        const { listenerId } = operation.input;
+        await this.listenerStateManager.removeListener(driveId, listenerId);
+    }
+
     getTransmitter(
         driveId: string,
         listenerId: string

package/src/server/listener/manager.ts

@@ -15,6 +15,7 @@ import {
     SynchronizationUnit
 } from '../types';
 import { PullResponderTransmitter } from './transmitter';
+import { InternalTransmitter } from './transmitter/internal';
 import { SwitchboardPushTransmitter } from './transmitter/switchboard-push';
 import { ITransmitter } from './transmitter/types';
 
@@ -42,41 +43,17 @@ export class ListenerManager extends BaseListenerManager {
         }
 
         const driveMap = this.listenerState.get(drive)!;
-
-        const driveDocument = await this.drive.getDrive(drive);
-
-        const lastDriveOperation = driveDocument.operations.global
-            .slice()
-            .pop();
-
         driveMap.set(listener.listenerId, {
             block: listener.block,
             driveId: listener.driveId,
             pendingTimeout: '0',
             listener,
             listenerStatus: 'CREATED',
-            syncUnits: [
-                {
-                    syncId: '0',
-                    driveId: listener.driveId,
-                    documentId: '',
-                    documentType: driveDocument.documentType,
-                    scope: 'global',
-                    branch: 'main',
-                    lastUpdated:
-                        lastDriveOperation?.timestamp ??
-                        driveDocument.lastModified,
-                    revision: lastDriveOperation?.index ?? 0,
-                    listenerRev: -1,
-                    syncRev: lastDriveOperation?.index ?? 0
-                }
-            ].concat(
-                filteredSyncUnits.map(e => ({
-                    ...e,
-                    listenerRev: -1,
-                    syncRev: e.revision
-                }))
-            )
+            syncUnits: filteredSyncUnits.map(e => ({
+                ...e,
+                listenerRev: -1,
+                syncRev: e.revision
+            }))
         });
 
         let transmitter: ITransmitter | undefined;
@@ -96,6 +73,11 @@ export class ListenerManager extends BaseListenerManager {
                     this.drive,
                     this
                 );
+                break;
+            }
+            case 'Internal': {
+                transmitter = new InternalTransmitter(listener, this.drive);
+                break;
             }
         }
 

package/src/server/listener/transmitter/index.ts

@@ -1,3 +1,4 @@
 export * from './pull-responder';
 export * from './switchboard-push';
+export * from './internal';
 export * from './types';

package/src/server/listener/transmitter/internal.ts

@@ -0,0 +1,90 @@
+import { Document, OperationScope } from 'document-model/document';
+import {
+    BaseDocumentDriveServer,
+    Listener,
+    ListenerRevision,
+    OperationUpdate,
+    StrandUpdate
+} from '../../types';
+import { buildRevisionsFilter } from '../../utils';
+import { ITransmitter } from './types';
+
+export interface IReceiver {
+    transmit: (strands: InternalTransmitterUpdate[]) => Promise<void>;
+}
+
+export type InternalTransmitterUpdate<
+    T extends Document = Document,
+    S extends OperationScope = OperationScope
+> = {
+    driveId: string;
+    documentId: string;
+    scope: S;
+    branch: string;
+    operations: OperationUpdate[];
+    state: T['state'][S];
+};
+
+export class InternalTransmitter implements ITransmitter {
+    private drive: BaseDocumentDriveServer;
+    private listener: Listener;
+    private receiver: IReceiver | undefined;
+
+    constructor(listener: Listener, drive: BaseDocumentDriveServer) {
+        this.listener = listener;
+        this.drive = drive;
+    }
+
+    async transmit(strands: StrandUpdate[]): Promise<ListenerRevision[]> {
+        if (!this.receiver) {
+            return [];
+        }
+
+        const retrievedDocuments = new Map<string, Document>();
+        const updates: InternalTransmitterUpdate[] = [];
+        for (const strand of strands) {
+            let document = retrievedDocuments.get(
+                `${strand.driveId}:${strand.documentId}`
+            );
+            if (!document) {
+                const revisions = buildRevisionsFilter(
+                    strands,
+                    strand.driveId,
+                    strand.documentId
+                );
+                document = await (strand.documentId
+                    ? this.drive.getDocument(
+                          strand.driveId,
+                          strand.documentId,
+                          { revisions }
+                      )
+                    : this.drive.getDrive(strand.driveId, { revisions }));
+                retrievedDocuments.set(
+                    `${strand.driveId}:${strand.documentId}`,
+                    document
+                );
+            }
+            updates.push({ ...strand, state: document.state[strand.scope] });
+        }
+        try {
+            await this.receiver.transmit(updates);
+            return strands.map(({ operations, ...s }) => ({
+                ...s,
+                status: 'SUCCESS',
+                revision: operations[operations.length - 1]?.index ?? -1
+            }));
+        } catch (error) {
+            console.error(error);
+            // TODO check which strand caused an error
+            return strands.map(({ operations, ...s }) => ({
+                ...s,
+                status: 'ERROR',
+                revision: (operations[0]?.index ?? 0) - 1
+            }));
+        }
+    }
+
+    setReceiver(receiver: IReceiver) {
+        this.receiver = receiver;
+    }
+}

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

@@ -1,6 +1,7 @@
 import { ListenerFilter, Trigger, z } from 'document-model-libs/document-drive';
 import { Operation, OperationScope } from 'document-model/document';
 import { PULL_DRIVE_INTERVAL } from '../..';
+import { generateUUID } from '../../../utils';
 import { gql, requestGraphql } from '../../../utils/graphql';
 import { OperationError } from '../../error';
 import {
@@ -10,6 +11,7 @@ import {
     ListenerRevision,
     ListenerRevisionWithError,
     OperationUpdate,
+    RemoteDriveOptions,
     StrandUpdate
 } from '../../types';
 import { ListenerManager } from '../manager';
@@ -208,6 +210,7 @@ export class PullResponderTransmitter implements IPullResponderTransmitter {
 
             // if there are no new strands then do nothing
             if (!strands.length) {
+                onRevisions?.([]);
                 return;
             }
 
@@ -329,6 +332,35 @@ export class PullResponderTransmitter implements IPullResponderTransmitter {
         };
     }
 
+    static async createPullResponderTrigger(
+        driveId: string,
+        url: string,
+        options: Pick<RemoteDriveOptions, 'pullInterval' | 'pullFilter'>
+    ): Promise<PullResponderTrigger> {
+        const { pullFilter, pullInterval } = options;
+        const listenerId = await PullResponderTransmitter.registerPullResponder(
+            driveId,
+            url,
+            pullFilter ?? {
+                documentId: ['*'],
+                documentType: ['*'],
+                branch: ['*'],
+                scope: ['*']
+            }
+        );
+
+        const pullTrigger: PullResponderTrigger = {
+            id: generateUUID(),
+            type: 'PullResponder',
+            data: {
+                url,
+                listenerId,
+                interval: pullInterval?.toString() ?? ''
+            }
+        };
+        return pullTrigger;
+    }
+
     static isPullResponderTrigger(
         trigger: Trigger
     ): trigger is PullResponderTrigger {

package/src/server/types.ts

@@ -7,6 +7,7 @@ import type {
     ListenerFilter
 } from 'document-model-libs/document-drive';
 import type {
+    Action,
     BaseAction,
     CreateChildDocumentInput,
     Document,
@@ -127,6 +128,17 @@ export interface DriveEvents {
     strandUpdate: (update: StrandUpdate) => void;
 }
 
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export type PartialRecord<K extends keyof any, T> = {
+    [P in K]?: T;
+};
+
+export type RevisionsFilter = PartialRecord<OperationScope, number>;
+
+export type GetDocumentOptions = {
+    revisions?: RevisionsFilter;
+};
+
 export abstract class BaseDocumentDriveServer {
     /** Public methods **/
     abstract getDrives(): Promise<string[]>;
@@ -136,10 +148,17 @@ export abstract class BaseDocumentDriveServer {
         options: RemoteDriveOptions
     ): Promise<void>;
     abstract deleteDrive(id: string): Promise<void>;
-    abstract getDrive(id: string): Promise<DocumentDriveDocument>;
+    abstract getDrive(
+        id: string,
+        options?: GetDocumentOptions
+    ): Promise<DocumentDriveDocument>;
 
     abstract getDocuments(drive: string): Promise<string[]>;
-    abstract getDocument(drive: string, id: string): Promise<Document>;
+    abstract getDocument(
+        drive: string,
+        id: string,
+        options?: GetDocumentOptions
+    ): Promise<Document>;
 
     abstract addOperation(
         drive: string,
@@ -161,6 +180,26 @@ export abstract class BaseDocumentDriveServer {
         operations: Operation<DocumentDriveAction | BaseAction>[]
     ): Promise<IOperationResult<DocumentDriveDocument>>;
 
+    abstract addAction(
+        drive: string,
+        id: string,
+        action: Action
+    ): Promise<IOperationResult>;
+    abstract addActions(
+        drive: string,
+        id: string,
+        actions: Action[]
+    ): Promise<IOperationResult>;
+
+    abstract addDriveAction(
+        drive: string,
+        action: DocumentDriveAction | BaseAction
+    ): Promise<IOperationResult<DocumentDriveDocument>>;
+    abstract addDriveActions(
+        drive: string,
+        actions: (DocumentDriveAction | BaseAction)[]
+    ): Promise<IOperationResult<DocumentDriveDocument>>;
+
     abstract getSyncStatus(drive: string): SyncStatus;
 
     /** Synchronization methods */
@@ -208,6 +247,8 @@ export abstract class BaseDocumentDriveServer {
         driveId: string,
         listenerId: string
     ): Promise<ITransmitter | undefined>;
+
+    abstract clearStorage(): Promise<void>;
 }
 
 export abstract class BaseListenerManager {

package/src/server/utils.ts

@@ -0,0 +1,34 @@
+import type { Document, OperationScope } from 'document-model/document';
+import { RevisionsFilter, StrandUpdate } from './types';
+
+export function buildRevisionsFilter(
+    strands: StrandUpdate[],
+    driveId: string,
+    documentId: string
+): RevisionsFilter {
+    return strands.reduce<RevisionsFilter>((acc, s) => {
+        if (!(s.driveId === driveId && s.documentId === documentId)) {
+            return acc;
+        }
+        acc[s.scope] = s.operations[s.operations.length - 1]?.index ?? -1;
+        return acc;
+    }, {});
+}
+
+export function filterOperationsByRevision(
+    operations: Document['operations'],
+    revisions?: RevisionsFilter
+): Document['operations'] {
+    if (!revisions) {
+        return operations;
+    }
+    return (Object.keys(operations) as OperationScope[]).reduce<
+        Document['operations']
+    >((acc, scope) => {
+        const revision = revisions[scope];
+        if (revision !== undefined) {
+            acc[scope] = operations[scope].filter(op => op.index <= revision);
+        }
+        return acc;
+    }, operations);
+}

package/src/storage/browser.ts

@@ -53,6 +53,10 @@ export class BrowserStorage implements IDriveStorage {
         await (await this.db).removeItem(this.buildKey(drive, id));
     }
 
+    async clearStorage(): Promise<void> {
+        return (await this.db).clear();
+    }
+
     async addDocumentOperations(
         drive: string,
         id: string,

package/src/storage/filesystem.ts

@@ -96,6 +96,44 @@ export class FilesystemStorage implements IDriveStorage {
         });
     }
 
+    async clearStorage() {
+        const drivesPath = path.join(
+            this.basePath,
+            FilesystemStorage.DRIVES_DIR
+        );
+
+        // delete content of drives directory
+        const drives = (
+            await fs.readdir(drivesPath, {
+                withFileTypes: true,
+                recursive: true
+            })
+        ).filter(dirent => !!dirent.name);
+
+        await Promise.all(
+            drives.map(async dirent => {
+                await fs.rm(path.join(drivesPath, dirent.name), {
+                    recursive: true
+                });
+            })
+        );
+
+        // delete files in basePath
+        const files = (
+            await fs.readdir(this.basePath, { withFileTypes: true })
+        ).filter(
+            file => file.name !== FilesystemStorage.DRIVES_DIR && !!file.name
+        );
+
+        await Promise.all(
+            files.map(async dirent => {
+                await fs.rm(path.join(this.basePath, dirent.name), {
+                    recursive: true
+                });
+            })
+        );
+    }
+
     async deleteDocument(drive: string, id: string) {
         return fs.rm(this._buildDocumentPath(drive, id));
     }

package/src/storage/memory.ts

@@ -39,6 +39,11 @@ export class MemoryStorage implements IDriveStorage {
         this.documents[drive]![id] = document;
     }
 
+    async clearStorage(): Promise<void> {
+        this.documents = {};
+        this.drives = {};
+    }
+
     async createDocument(drive: string, id: string, document: DocumentStorage) {
         this.documents[drive] = this.documents[drive] ?? {};
         const {

package/src/storage/prisma.ts

@@ -58,53 +58,33 @@ export class PrismaStorage 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) {
             throw new Error(`Document with id ${id} not found`);
         }
 
+        const mergedOperations = [...operations, ...updatedOperations].sort(
+            (a, b) => a.index - b.index
+        );
+
         try {
-            await Promise.all(
-                operations.map(async op => {
-                    return this.db.operation.upsert({
-                        where: {
-                            driveId_documentId_scope_branch_index: {
-                                driveId: drive,
-                                documentId: id,
-                                scope: op.scope,
-                                branch: 'main',
-                                index: op.index
-                            }
-                        },
-                        create: {
-                            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
-                        },
-                        update: {
-                            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 this.db.operation.createMany({
+                data: mergedOperations.map(op => ({
+                    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 this.db.document.updateMany({
                 where: {
@@ -213,48 +193,21 @@ export class PrismaStorage implements IDriveStorage {
     }
 
     async deleteDocument(drive: string, id: string) {
-        await this.db.attachment.deleteMany({
-            where: {
-                driveId: drive,
-                documentId: id
-            }
-        });
-
-        await this.db.operation.deleteMany({
-            where: {
-                driveId: drive,
-                documentId: id
-            }
-        });
-
         await this.db.document.delete({
             where: {
                 id_driveId: {
                     driveId: drive,
                     id: id
                 }
+            },
+            include: {
+                operations: {
+                    include: {
+                        attachments: true
+                    }
+                }
             }
         });
-
-        if (drive === 'drives') {
-            await this.db.attachment.deleteMany({
-                where: {
-                    driveId: id
-                }
-            });
-
-            await this.db.operation.deleteMany({
-                where: {
-                    driveId: id
-                }
-            });
-
-            await this.db.document.deleteMany({
-                where: {
-                    driveId: id
-                }
-            });
-        }
     }
 
     async getDrives() {
@@ -271,6 +224,12 @@ export class PrismaStorage implements IDriveStorage {
     }
 
     async deleteDrive(id: string) {
+        const docs = await this.getDocuments(id);
+        await Promise.all(
+            docs.map(async doc => {
+                return this.deleteDocument(id, doc);
+            })
+        );
         await this.deleteDocument('drives', id);
     }
 }

package/src/storage/types.ts

@@ -38,6 +38,7 @@ export interface IDriveStorage extends IStorage {
     getDrive(id: string): Promise<DocumentDriveStorage>;
     createDrive(id: string, drive: DocumentDriveStorage): Promise<void>;
     deleteDrive(id: string): Promise<void>;
+    clearStorage?(): Promise<void>;
     addDriveOperations(
         id: string,
         operations: Operation<DocumentDriveAction | BaseAction>[],

package/src/utils/index.ts

@@ -75,3 +75,8 @@ export function isNoopUpdate(
         isSkipOpGreaterThanLatestOp
     );
 }
+
+// return true if dateA is before dateB
+export function isBefore(dateA: Date | string, dateB: Date | string) {
+    return new Date(dateA) < new Date(dateB);
+}