document-drive 1.0.0-experimental.9 → 1.0.0-websockets

package/src/server/index.ts

@@ -18,18 +18,27 @@ import {
     Document,
     DocumentHeader,
     DocumentModel,
+    utils as DocumentUtils,
     Operation,
-    OperationScope,
-    State
+    OperationScope
 } from 'document-model/document';
 import { createNanoEvents, Unsubscribe } from 'nanoevents';
 import { ICache } from '../cache';
 import InMemoryCache from '../cache/memory';
+import { BaseQueueManager } from '../queue/base';
+import {
+    ActionJob,
+    IQueueManager,
+    isActionJob,
+    isOperationJob,
+    Job,
+    OperationJob
+} from '../queue/types';
 import { MemoryStorage } from '../storage/memory';
 import type {
     DocumentDriveStorage,
     DocumentStorage,
-    IDriveStorage,
+    IDriveStorage
 } from '../storage/types';
 import { generateUUID, isBefore, isDocumentDrive } from '../utils';
 import {
@@ -51,7 +60,8 @@ import {
     InternalTransmitter,
     IReceiver,
     ITransmitter,
-    PullResponderTransmitter
+    PullResponderTransmitter,
+    SubscriptionTransmitter
 } from './listener/transmitter';
 import {
     BaseDocumentDriveServer,
@@ -61,6 +71,7 @@ import {
     ListenerState,
     RemoteDriveOptions,
     StrandUpdate,
+    SynchronizationUnitQuery,
     SyncStatus,
     type CreateDocumentInput,
     type DriveInput,
@@ -69,8 +80,6 @@ import {
     type SynchronizationUnit
 } from './types';
 import { filterOperationsByRevision } from './utils';
-import { BaseQueueManager } from '../queue/base';
-import { IQueueManager } from '../queue/types';
 
 export * from './listener';
 export type * from './types';
@@ -87,7 +96,7 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
         DocumentDriveState['id'],
         Map<Trigger['id'], CancelPullLoop>
     >();
-    private syncStatus = new Map<DocumentDriveState['id'], SyncStatus>();
+    private syncStatus = new Map<string, SyncStatus>();
 
     private queueManager: IQueueManager;
 
@@ -95,7 +104,7 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
         documentModels: DocumentModel[],
         storage: IDriveStorage = new MemoryStorage(),
         cache: ICache = new InMemoryCache(),
-        queueManager: IQueueManager = new BaseQueueManager(),
+        queueManager: IQueueManager = new BaseQueueManager()
     ) {
         super();
         this.listenerStateManager = new ListenerManager(this);
@@ -103,6 +112,18 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
         this.storage = storage;
         this.cache = cache;
         this.queueManager = queueManager;
+
+        this.storage.setStorageDelegate?.({
+            getCachedOperations: async (drive, id) => {
+                try {
+                    const document = await this.cache.getDocument(drive, id);
+                    return document?.operations;
+                } catch (error) {
+                    logger.error(error);
+                    return undefined;
+                }
+            }
+        });
     }
 
     private updateSyncStatus(
@@ -119,31 +140,30 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
     }
 
     private async saveStrand(strand: StrandUpdate) {
-        const operations: Operation[] = strand.operations.map(
-            (op) => ({
-                ...op,
-                scope: strand.scope,
-                branch: strand.branch
-            })
-        );
+        const operations: Operation[] = strand.operations.map(op => ({
+            ...op,
+            scope: strand.scope,
+            branch: strand.branch
+        }));
 
         const result = await (!strand.documentId
             ? this.queueDriveOperations(
-                strand.driveId,
-                operations as Operation<DocumentDriveAction | BaseAction>[],
-                false
-            )
+                  strand.driveId,
+                  operations as Operation<DocumentDriveAction | BaseAction>[],
+                  false
+              )
             : this.queueOperations(
-                strand.driveId,
-                strand.documentId,
-                operations,
-                false
-            ));
+                  strand.driveId,
+                  strand.documentId,
+                  operations,
+                  false
+              ));
 
         if (result.status === 'ERROR') {
             this.updateSyncStatus(strand.driveId, result.status, result.error);
+        } else {
+            this.emit('strandUpdate', strand);
         }
-        this.emit('strandUpdate', strand);
         return result;
     }
 
@@ -174,6 +194,8 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
         const drive = await this.getDrive(driveId);
         let driveTriggers = this.triggerMap.get(driveId);
 
+        const syncUnits = await this.getSynchronizationUnitsIds(driveId);
+
         for (const trigger of drive.state.local.triggers) {
             if (driveTriggers?.get(trigger.id)) {
                 continue;
@@ -184,8 +206,56 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
             }
 
             this.updateSyncStatus(driveId, 'SYNCING');
+
+            for (const syncUnit of syncUnits) {
+                this.updateSyncStatus(syncUnit.syncId, 'SYNCING');
+            }
+
+            let cancelTrigger: (() => void) | undefined = undefined;
             if (PullResponderTransmitter.isPullResponderTrigger(trigger)) {
-                const cancelPullLoop = PullResponderTransmitter.setupPull(
+                cancelTrigger = PullResponderTransmitter.setupPull(
+                    driveId,
+                    trigger,
+                    this.saveStrand.bind(this),
+                    error => {
+                        this.updateSyncStatus(
+                            driveId,
+                            error instanceof OperationError
+                                ? error.status
+                                : 'ERROR',
+                            error
+                        );
+                    },
+                    revisions => {
+                        const errorRevision = revisions.filter(
+                            r => r.status !== 'SUCCESS'
+                        );
+                        if (errorRevision.length < 1) {
+                            this.updateSyncStatus(driveId, 'SUCCESS');
+                        }
+
+                        for (const syncUnit of syncUnits) {
+                            const fileErrorRevision = errorRevision.find(
+                                r => r.documentId === syncUnit.documentId
+                            );
+
+                            if (fileErrorRevision) {
+                                this.updateSyncStatus(
+                                    syncUnit.syncId,
+                                    fileErrorRevision.status,
+                                    fileErrorRevision.error
+                                );
+                            } else {
+                                this.updateSyncStatus(
+                                    syncUnit.syncId,
+                                    'SUCCESS'
+                                );
+                            }
+                        }
+                    }
+                );
+            } else if (SubscriptionTransmitter.isTrigger(trigger)) {
+                cancelTrigger = SubscriptionTransmitter.setup(
                     driveId,
                     trigger,
                     this.saveStrand.bind(this),
@@ -207,19 +277,78 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
                         }
                     }
                 );
-                driveTriggers.set(trigger.id, cancelPullLoop);
+            }
+
+            if (cancelTrigger) {
+                driveTriggers.set(trigger.id, cancelTrigger);
                 this.triggerMap.set(driveId, driveTriggers);
             }
         }
     }
 
     private async stopSyncRemoteDrive(driveId: string) {
+        const syncUnits = await this.getSynchronizationUnitsIds(driveId);
+        const fileNodes = syncUnits
+            .filter(syncUnit => syncUnit.documentId !== '')
+            .map(syncUnit => syncUnit.documentId);
+
         const triggers = this.triggerMap.get(driveId);
         triggers?.forEach(cancel => cancel());
         this.updateSyncStatus(driveId, null);
+
+        for (const fileNode of fileNodes) {
+            this.updateSyncStatus(fileNode, null);
+        }
         return this.triggerMap.delete(driveId);
     }
 
+    private queueDelegate = {
+        checkDocumentExists: (
+            driveId: string,
+            documentId: string
+        ): Promise<boolean> =>
+            this.storage.checkDocumentExists(driveId, documentId),
+        processOperationJob: async ({
+            driveId,
+            documentId,
+            operations,
+            forceSync
+        }: OperationJob) => {
+            return documentId
+                ? this.addOperations(driveId, documentId, operations, forceSync)
+                : this.addDriveOperations(
+                      driveId,
+                      operations as Operation<
+                          DocumentDriveAction | BaseAction
+                      >[],
+                      forceSync
+                  );
+        },
+        processActionJob: async ({
+            driveId,
+            documentId,
+            actions,
+            forceSync
+        }: ActionJob) => {
+            return documentId
+                ? this.addActions(driveId, documentId, actions, forceSync)
+                : this.addDriveActions(
+                      driveId,
+                      actions as Operation<DocumentDriveAction | BaseAction>[],
+                      forceSync
+                  );
+        },
+        processJob: async (job: Job) => {
+            if (isOperationJob(job)) {
+                return this.queueDelegate.processOperationJob(job);
+            } else if (isActionJob(job)) {
+                return this.queueDelegate.processActionJob(job);
+            } else {
+                throw new Error('Unknown job type', job);
+            }
+        }
+    };
+
     async initialize() {
         const errors: Error[] = [];
         const drives = await this.getDrives();
@@ -230,16 +359,10 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
             });
         }
 
-        await this.queueManager.init({
-            checkDocumentExists: (driveId: string, documentId: string): Promise<boolean> => this.storage.checkDocumentExists(driveId, documentId),
-            processOperationJob: ({ driveId, documentId, operations, forceSync }) => documentId ?
-                this.addOperations(driveId, documentId, operations, forceSync)
-                : this.addDriveOperations(driveId, operations as Operation<DocumentDriveAction | BaseAction>[], forceSync)
-
-        }, error => {
+        await this.queueManager.init(this.queueDelegate, error => {
             logger.error(`Error initializing queue manager`, error);
             errors.push(error);
-        })
+        });
 
         // if network connect comes online then
         // triggers the listeners update
@@ -278,6 +401,49 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
     ) {
         const drive = await this.getDrive(driveId);
 
+        const synchronizationUnitsQuery = await this.getSynchronizationUnitsIds(
+            driveId,
+            documentId,
+            scope,
+            branch,
+            documentType,
+            drive
+        );
+        const revisions = await this.storage.getSynchronizationUnitsRevision(
+            synchronizationUnitsQuery
+        );
+
+        const synchronizationUnits: SynchronizationUnit[] =
+            synchronizationUnitsQuery.map(s => ({
+                ...s,
+                lastUpdated: drive.created,
+                revision: -1
+            }));
+        for (const revision of revisions) {
+            const syncUnit = synchronizationUnits.find(
+                s =>
+                    revision.driveId === s.driveId &&
+                    revision.documentId === s.documentId &&
+                    revision.scope === s.scope &&
+                    revision.branch === s.branch
+            );
+            if (syncUnit) {
+                syncUnit.revision = revision.revision;
+                syncUnit.lastUpdated = revision.lastUpdated;
+            }
+        }
+        return synchronizationUnits;
+    }
+
+    public async getSynchronizationUnitsIds(
+        driveId: string,
+        documentId?: string[],
+        scope?: string[],
+        branch?: string[],
+        documentType?: string[],
+        loadedDrive?: DocumentDriveDocument
+    ): Promise<SynchronizationUnitQuery[]> {
+        const drive = loadedDrive ?? (await this.getDrive(driveId));
         const nodes = drive.state.global.nodes.filter(
             node =>
                 isFileNode(node) &&
@@ -311,53 +477,44 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
             });
         }
 
-        const synchronizationUnits: SynchronizationUnit[] = [];
-
+        const synchronizationUnitsQuery: Omit<
+            SynchronizationUnit,
+            'revision' | 'lastUpdated'
+        >[] = [];
         for (const node of nodes) {
             const nodeUnits =
                 scope?.length || branch?.length
                     ? node.synchronizationUnits.filter(
-                        unit =>
-                            (!scope?.length ||
-                                scope.includes(unit.scope) ||
-                                scope.includes('*')) &&
-                            (!branch?.length ||
-                                branch.includes(unit.branch) ||
-                                branch.includes('*'))
-                    )
+                          unit =>
+                              (!scope?.length ||
+                                  scope.includes(unit.scope) ||
+                                  scope.includes('*')) &&
+                              (!branch?.length ||
+                                  branch.includes(unit.branch) ||
+                                  branch.includes('*'))
+                      )
                     : node.synchronizationUnits;
             if (!nodeUnits.length) {
                 continue;
             }
-
-            const document = await (node.id
-                ? this.getDocument(driveId, node.id)
-                : this.getDrive(driveId));
-
-            for (const { syncId, scope, branch } of nodeUnits) {
-                const operations =
-                    document.operations[scope as OperationScope] ?? [];
-                const lastOperation = operations[operations.length - 1];
-                synchronizationUnits.push({
-                    syncId,
-                    scope,
-                    branch,
+            synchronizationUnitsQuery.push(
+                ...nodeUnits.map(n => ({
                     driveId,
                     documentId: node.id,
+                    syncId: n.syncId,
                     documentType: node.documentType,
-                    lastUpdated:
-                        lastOperation?.timestamp ?? document.lastModified,
-                    revision: lastOperation?.index ?? 0
-                });
-            }
+                    scope: n.scope,
+                    branch: n.branch
+                }))
+            );
         }
-        return synchronizationUnits;
+        return synchronizationUnitsQuery;
     }
 
-    public async getSynchronizationUnit(
+    public async getSynchronizationUnitIdInfo(
         driveId: string,
         syncId: string
-    ): Promise<SynchronizationUnit> {
+    ): Promise<SynchronizationUnitQuery | undefined> {
         const drive = await this.getDrive(driveId);
         const node = drive.state.global.nodes.find(
             node =>
@@ -366,14 +523,43 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
         );
 
         if (!node || !isFileNode(node)) {
-            throw new Error('Synchronization unit not found');
+            return undefined;
         }
 
-        const { scope, branch } = node.synchronizationUnits.find(
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        const syncUnit = node.synchronizationUnits.find(
             unit => unit.syncId === syncId
-        )!;
+        );
+        if (!syncUnit) {
+            return undefined;
+        }
 
-        const documentId = node.id;
+        return {
+            syncId,
+            scope: syncUnit.scope,
+            branch: syncUnit.branch,
+            driveId,
+            documentId: node.id,
+            documentType: node.documentType
+        };
+    }
+
+    public async getSynchronizationUnit(
+        driveId: string,
+        syncId: string
+    ): Promise<SynchronizationUnit | undefined> {
+        const syncUnit = await this.getSynchronizationUnitIdInfo(
+            driveId,
+            syncId
+        );
+
+        if (!syncUnit) {
+            return undefined;
+        }
+
+        const { scope, branch, documentId, documentType } = syncUnit;
+
+        // TODO: REPLACE WITH GET DOCUMENT OPERATIONS
         const document = await this.getDocument(driveId, documentId);
         const operations = document.operations[scope as OperationScope] ?? [];
         const lastOperation = operations[operations.length - 1];
@@ -384,7 +570,7 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
             branch,
             driveId,
             documentId,
-            documentType: node.documentType,
+            documentType,
             lastUpdated: lastOperation?.timestamp ?? document.lastModified,
             revision: lastOperation?.index ?? 0
         };
@@ -398,17 +584,22 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
             fromRevision?: number | undefined;
         }
     ): Promise<OperationUpdate[]> {
-        const { documentId, scope } =
+        const syncUnit =
             syncId === '0'
                 ? { documentId: '', scope: 'global' }
-                : await this.getSynchronizationUnit(driveId, syncId);
+                : await this.getSynchronizationUnitIdInfo(driveId, syncId);
+
+        if (!syncUnit) {
+            throw new Error(`Invalid Sync Id ${syncId} in drive ${driveId}`);
+        }
 
         const document =
             syncId === '0'
                 ? await this.getDrive(driveId)
-                : await this.getDocument(driveId, documentId); // TODO replace with getDocumentOperations
+                : await this.getDocument(driveId, syncUnit.documentId); // TODO replace with getDocumentOperations
 
-        const operations = document.operations[scope as OperationScope] ?? []; // TODO filter by branch also
+        const operations =
+            document.operations[syncUnit.scope as OperationScope] ?? []; // TODO filter by branch also
         const filteredOperations = operations.filter(
             operation =>
                 Object.keys(filter).length === 0 ||
@@ -425,7 +616,8 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
             type: operation.type,
             input: operation.input as object,
             skip: operation.skip,
-            context: operation.context
+            context: operation.context,
+            id: operation.id
         }));
     }
 
@@ -455,12 +647,20 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
         });
 
         await this.storage.createDrive(id, document);
+
+        if (drive.global.slug) {
+            await this.cache.deleteDocument('drives-slug', drive.global.slug);
+        }
+
         await this._initializeDrive(id);
 
         return document;
     }
 
-    async addRemoteDrive(url: string, options: RemoteDriveOptions): Promise<DocumentDriveDocument> {
+    async addRemoteDrive(
+        url: string,
+        options: RemoteDriveOptions
+    ): Promise<DocumentDriveDocument> {
         const { id, name, slug, icon } = await requestPublicDrive(url);
         const {
             pullFilter,
@@ -471,11 +671,9 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
             triggers
         } = options;
 
-        const pullTrigger =
-            await PullResponderTransmitter.createPullResponderTrigger(id, url, {
-                pullFilter,
-                pullInterval
-            });
+        const trigger = await SubscriptionTransmitter.createTrigger(id, url, {
+            pullFilter
+        });
 
         return await this.addDrive({
             global: {
@@ -485,7 +683,7 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
                 icon: icon ?? null
             },
             local: {
-                triggers: [...triggers, pullTrigger],
+                triggers: [...triggers, trigger],
                 listeners: listeners,
                 availableOffline,
                 sharingType
@@ -494,9 +692,18 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
     }
 
     async deleteDrive(id: string) {
-        this.stopSyncRemoteDrive(id);
-        await this.cache.deleteDocument('drives', id);
-        return this.storage.deleteDrive(id);
+        const result = await Promise.allSettled([
+            this.stopSyncRemoteDrive(id),
+            this.listenerStateManager.removeDrive(id),
+            this.cache.deleteDocument('drives', id),
+            this.storage.deleteDrive(id)
+        ]);
+
+        result.forEach(r => {
+            if (r.status === 'rejected') {
+                throw r.reason;
+            }
+        });
     }
 
     getDrives() {
@@ -505,7 +712,7 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
 
     async getDrive(drive: string, options?: GetDocumentOptions) {
         try {
-            const document = await this.cache.getDocument('drives', drive);
+            const document = await this.cache.getDocument('drives', drive); // TODO support GetDocumentOptions
             if (document && isDocumentDrive(document)) {
                 return document;
             }
@@ -528,7 +735,7 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
 
     async getDriveBySlug(slug: string, options?: GetDocumentOptions) {
         try {
-            const document = await this.cache.getDocument('drives', slug);
+            const document = await this.cache.getDocument('drives-slug', slug);
             if (document && isDocumentDrive(document)) {
                 return document;
             }
@@ -544,7 +751,7 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
             );
         } else {
             this.cache
-                .setDocument('drives', slug, document)
+                .setDocument('drives-slug', slug, document)
                 .catch(logger.error);
             return document;
         }
@@ -552,16 +759,15 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
 
     async getDocument(drive: string, id: string, options?: GetDocumentOptions) {
         try {
-            const document = await this.cache.getDocument(drive, id);
+            const document = await this.cache.getDocument(drive, id); // TODO support GetDocumentOptions
             if (document) {
                 return document;
             }
         } catch (e) {
             logger.error('Error getting document from cache', e);
         }
-        const documentStorage =
-            await this.storage.getDocument(drive, id);
-        const document = this._buildDocument(documentStorage, options)
+        const documentStorage = await this.storage.getDocument(drive, id);
+        const document = this._buildDocument(documentStorage, options);
 
         this.cache.setDocument(drive, id, document).catch(logger.error);
         return document;
@@ -579,14 +785,17 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
         let state = undefined;
         if (input.document) {
             if (input.documentType !== input.document.documentType) {
-                throw new Error(`Provided document is not ${input.documentType}`);
+                throw new Error(
+                    `Provided document is not ${input.documentType}`
+                );
             }
             const doc = this._buildDocument(input.document);
             state = doc.state;
         }
 
         // if no document was provided then create a new one
-        const document = input.document ??
+        const document =
+            input.document ??
             this._getDocumentModel(input.documentType).utils.createDocument();
 
         // stores document information
@@ -608,9 +817,18 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
         const operations = Object.values(document.operations).flat();
         if (operations.length) {
             if (isDocumentDrive(document)) {
-                await this.storage.addDriveOperations(driveId, operations as Operation<DocumentDriveAction>[], document);
+                await this.storage.addDriveOperations(
+                    driveId,
+                    operations as Operation<DocumentDriveAction>[],
+                    document
+                );
             } else {
-                await this.storage.addDocumentOperations(driveId, input.id, operations, document)
+                await this.storage.addDocumentOperations(
+                    driveId,
+                    input.id,
+                    operations,
+                    document
+                );
             }
         }
 
@@ -619,7 +837,9 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
 
     async deleteDocument(driveId: string, id: string) {
         try {
-            const syncUnits = await this.getSynchronizationUnits(driveId, [id]);
+            const syncUnits = await this.getSynchronizationUnitsIds(driveId, [
+                id
+            ]);
             await this.listenerStateManager.removeSyncUnits(driveId, syncUnits);
         } catch (error) {
             logger.warn('Error deleting document', error);
@@ -630,6 +850,7 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
 
     async _processOperations<T extends Document, A extends Action>(
         drive: string,
+        documentId: string | undefined,
         storageDocument: DocumentStorage<T>,
         operations: Operation<A | BaseAction>[]
     ) {
@@ -667,7 +888,7 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
                     : merge(trunk, invertedTrunk, reshuffleByTimestamp);
 
             const newOperations = newHistory.filter(
-                (op: any) => trunk.length < 1 || precedes(trunk[trunk.length - 1]!, op)
+                op => trunk.length < 1 || precedes(trunk[trunk.length - 1]!, op)
             );
 
             for (const nextOperation of newOperations) {
@@ -676,15 +897,20 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
                 // when dealing with a merge (tail.length > 0) we have to skip hash validation
                 // for the operations that were re-indexed (previous hash becomes invalid due the new position in the history)
                 if (tail.length > 0) {
-                    skipHashValidation = [...invertedTrunk, ...tail].some(
-                        invertedTrunkOp =>
-                            invertedTrunkOp.hash === nextOperation.hash
+                    const sourceOperation = operations.find(
+                        op => op.hash === nextOperation.hash
                     );
+
+                    skipHashValidation =
+                        !sourceOperation ||
+                        sourceOperation.index !== nextOperation.index ||
+                        sourceOperation.skip !== nextOperation.skip;
                 }
 
                 try {
                     const appliedResult = await this._performOperation(
                         drive,
+                        documentId,
                         document,
                         nextOperation,
                         skipHashValidation
@@ -697,11 +923,11 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
                         e instanceof OperationError
                             ? e
                             : new OperationError(
-                                'ERROR',
-                                nextOperation,
-                                (e as Error).message,
-                                (e as Error).cause
-                            );
+                                  'ERROR',
+                                  nextOperation,
+                                  (e as Error).message,
+                                  (e as Error).cause
+                              );
 
                     // TODO: don't break on errors...
                     break;
@@ -713,26 +939,36 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
             document,
             operationsApplied,
             signals,
-            error,
+            error
         } as const;
     }
 
     private _buildDocument<T extends Document>(
-        documentStorage: DocumentStorage<T>, options?: GetDocumentOptions
+        documentStorage: DocumentStorage<T>,
+        options?: GetDocumentOptions
     ): T {
+        if (
+            documentStorage.state &&
+            (!options || options.checkHashes === false)
+        ) {
+            return documentStorage as T;
+        }
+
         const documentModel = this._getDocumentModel(
             documentStorage.documentType
         );
 
-        const revisionOperations = options?.revisions !== undefined ? filterOperationsByRevision(
-            documentStorage.operations,
-            options.revisions
-        ) : documentStorage.operations;
-        const operations = baseUtils.documentHelpers.grabageCollectDocumentOperations(revisionOperations);
-
-        if (documentStorage.state && (!options || options.checkHashes === false)) {
-            return documentStorage as T;
-        }
+        const revisionOperations =
+            options?.revisions !== undefined
+                ? filterOperationsByRevision(
+                      documentStorage.operations,
+                      options.revisions
+                  )
+                : documentStorage.operations;
+        const operations =
+            baseUtils.documentHelpers.garbageCollectDocumentOperations(
+                revisionOperations
+            );
 
         return baseUtils.replayDocument(
             documentStorage.initialState,
@@ -741,12 +977,17 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
             undefined,
             documentStorage,
             undefined,
-            { checkHashes: options?.checkHashes ?? true }
+            {
+                ...options,
+                checkHashes: options?.checkHashes ?? true,
+                reuseOperationResultingState: options?.checkHashes ?? true
+            }
         ) as T;
     }
 
     private async _performOperation<T extends Document>(
         drive: string,
+        id: string | undefined,
         document: T,
         operation: Operation,
         skipHashValidation = false
@@ -756,6 +997,36 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
         const signalResults: SignalResult[] = [];
         let newDocument = document;
 
+        const scope = operation.scope;
+        const documentOperations =
+            DocumentUtils.documentHelpers.garbageCollectDocumentOperations({
+                ...document.operations,
+                [scope]: DocumentUtils.documentHelpers.skipHeaderOperations(
+                    document.operations[scope],
+                    operation
+                )
+            });
+
+        const lastRemainingOperation = documentOperations[scope].at(-1);
+        // if the latest operation doesn't have a resulting state then tries
+        // to retrieve it from the db to avoid rerunning all the operations
+        if (lastRemainingOperation && !lastRemainingOperation.resultingState) {
+            lastRemainingOperation.resultingState = await (id
+                ? this.storage.getOperationResultingState?.(
+                      drive,
+                      id,
+                      lastRemainingOperation.index,
+                      lastRemainingOperation.scope,
+                      'main'
+                  )
+                : this.storage.getDriveOperationResultingState?.(
+                      drive,
+                      lastRemainingOperation.index,
+                      lastRemainingOperation.scope,
+                      'main'
+                  ));
+        }
+
         const operationSignals: (() => Promise<SignalResult>)[] = [];
         newDocument = documentModel.reducer(
             newDocument,
@@ -792,7 +1063,7 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
                     );
                 }
             },
-            { skip: operation.skip }
+            { skip: operation.skip, reuseOperationResultingState: true }
         ) as T;
 
         const appliedOperation = newDocument.operations[operation.scope].filter(
@@ -803,16 +1074,13 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
             throw new OperationError(
                 'ERROR',
                 operation,
-                `Operation with index ${operation.index}:${operation.skip} was not applied.`
+                `Operation with index ${operation.index}:${operation.skip || 0} was not applied.`
             );
         } else if (
             appliedOperation[0]!.hash !== operation.hash &&
             !skipHashValidation
         ) {
-            throw new ConflictOperationError(
-                operation,
-                appliedOperation[0]!
-            );
+            throw new ConflictOperationError(operation, appliedOperation[0]!);
         }
 
         for (const signalHandler of operationSignals) {
@@ -827,7 +1095,12 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
         };
     }
 
-    addOperation(drive: string, id: string, operation: Operation, forceSync = true): Promise<IOperationResult> {
+    addOperation(
+        drive: string,
+        id: string,
+        operation: Operation,
+        forceSync = true
+    ): Promise<IOperationResult> {
         return this.addOperations(drive, id, [operation], forceSync);
     }
 
@@ -837,21 +1110,18 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
         callback: (document: DocumentStorage) => Promise<{
             operations: Operation[];
             header: DocumentHeader;
-            newState: State<any, any> | undefined;
         }>
     ) {
         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
-            ) {
+            if (result.operations.length > 0) {
                 await this.storage.addDocumentOperations(
                     drive,
                     id,
                     result.operations,
-                    result.header,
+                    result.header
                 );
             }
         } else {
@@ -863,47 +1133,213 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
         }
     }
 
-    queueOperation(drive: string, id: string, operation: Operation, forceSync = true): Promise<IOperationResult> {
+    queueOperation(
+        drive: string,
+        id: string,
+        operation: Operation,
+        forceSync = true
+    ): Promise<IOperationResult> {
         return this.queueOperations(drive, id, [operation], forceSync);
     }
 
-    async queueOperations(drive: string,
+    private async resultIfExistingOperations(
+        drive: string,
+        id: string,
+        operations: Operation[]
+    ): Promise<IOperationResult | undefined> {
+        try {
+            const document = await this.getDocument(drive, id);
+            const newOperation = operations.find(
+                op =>
+                    !op.id ||
+                    !document.operations[op.scope].find(
+                        existingOp =>
+                            existingOp.id === op.id &&
+                            existingOp.index === op.index &&
+                            existingOp.type === op.type &&
+                            existingOp.hash === op.hash
+                    )
+            );
+            if (!newOperation) {
+                return {
+                    status: 'SUCCESS',
+                    document,
+                    operations,
+                    signals: []
+                };
+            } else {
+                return undefined;
+            }
+        } catch (error) {
+            console.error(error); // TODO error
+            return undefined;
+        }
+    }
+
+    async queueOperations(
+        drive: string,
         id: string,
         operations: Operation[],
-        forceSync = true) {
+        forceSync = true
+    ) {
+        // if operations are already stored then returns cached document
+        const result = await this.resultIfExistingOperations(
+            drive,
+            id,
+            operations
+        );
+        if (result) {
+            console.log('Duplicated operations!');
+            return result;
+        }
+        try {
+            const jobId = await this.queueManager.addJob({
+                driveId: drive,
+                documentId: id,
+                operations,
+                forceSync
+            });
+
+            return new Promise<IOperationResult>((resolve, reject) => {
+                const unsubscribe = this.queueManager.on(
+                    'jobCompleted',
+                    (job, result) => {
+                        if (job.jobId === jobId) {
+                            unsubscribe();
+                            unsubscribeError();
+                            resolve(result);
+                        }
+                    }
+                );
+                const unsubscribeError = this.queueManager.on(
+                    'jobFailed',
+                    (job, error) => {
+                        if (job.jobId === jobId) {
+                            unsubscribe();
+                            unsubscribeError();
+                            reject(error);
+                        }
+                    }
+                );
+            });
+        } catch (error) {
+            logger.error('Error adding job', error);
+            throw error;
+        }
+    }
+
+    async queueAction(
+        drive: string,
+        id: string,
+        action: Action,
+        forceSync?: boolean | undefined
+    ): Promise<IOperationResult> {
+        return this.queueActions(drive, id, [action], forceSync);
+    }
 
+    async queueActions(
+        drive: string,
+        id: string,
+        actions: Action[],
+        forceSync?: boolean | undefined
+    ): Promise<IOperationResult> {
         try {
-            const jobId = await this.queueManager.addJob({ driveId: drive, documentId: id, operations, forceSync });
+            const jobId = await this.queueManager.addJob({
+                driveId: drive,
+                documentId: id,
+                actions,
+                forceSync
+            });
 
             return new Promise<IOperationResult>((resolve, reject) => {
-                const unsubscribe = this.queueManager.on('jobCompleted', (job, result) => {
-                    if (job.jobId === jobId) {
-                        unsubscribe();
-                        unsubscribeError();
-                        resolve(result);
+                const unsubscribe = this.queueManager.on(
+                    'jobCompleted',
+                    (job, result) => {
+                        if (job.jobId === jobId) {
+                            unsubscribe();
+                            unsubscribeError();
+                            resolve(result);
+                        }
                     }
-                });
-                const unsubscribeError = this.queueManager.on('jobFailed', (job, error) => {
-                    console.log("test")
-                    if (job.jobId === jobId) {
-                        unsubscribe();
-                        unsubscribeError();
-                        reject(error);
+                );
+                const unsubscribeError = this.queueManager.on(
+                    'jobFailed',
+                    (job, error) => {
+                        if (job.jobId === jobId) {
+                            unsubscribe();
+                            unsubscribeError();
+                            reject(error);
+                        }
                     }
-                });
-            })
+                );
+            });
         } catch (error) {
             logger.error('Error adding job', error);
             throw error;
         }
     }
 
+    async queueDriveAction(
+        drive: string,
+        action: DocumentDriveAction | BaseAction,
+        forceSync?: boolean | undefined
+    ): Promise<IOperationResult<DocumentDriveDocument>> {
+        return this.queueDriveActions(drive, [action], forceSync);
+    }
+
+    async queueDriveActions(
+        drive: string,
+        actions: (DocumentDriveAction | BaseAction)[],
+        forceSync?: boolean | undefined
+    ): Promise<IOperationResult<DocumentDriveDocument>> {
+        const jobId = await this.queueManager.addJob({
+            driveId: drive,
+            actions,
+            forceSync
+        });
+        return new Promise<IOperationResult<DocumentDriveDocument>>(
+            (resolve, reject) => {
+                const unsubscribe = this.queueManager.on(
+                    'jobCompleted',
+                    (job, result) => {
+                        if (job.jobId === jobId) {
+                            unsubscribe();
+                            unsubscribeError();
+                            resolve(
+                                result as IOperationResult<DocumentDriveDocument>
+                            );
+                        }
+                    }
+                );
+                const unsubscribeError = this.queueManager.on(
+                    'jobFailed',
+                    (job, error) => {
+                        if (job.jobId === jobId) {
+                            unsubscribe();
+                            unsubscribeError();
+                            reject(error);
+                        }
+                    }
+                );
+            }
+        );
+    }
+
     async addOperations(
         drive: string,
         id: string,
         operations: Operation[],
         forceSync = true
     ) {
+        // if operations are already stored then returns the result
+        const result = await this.resultIfExistingOperations(
+            drive,
+            id,
+            operations
+        );
+        if (result) {
+            return result;
+        }
         let document: Document | undefined;
         const operationsApplied: Operation[] = [];
         const signals: SignalResult[] = [];
@@ -913,6 +1349,7 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
             await this._addOperations(drive, id, async documentStorage => {
                 const result = await this._processOperations(
                     drive,
+                    id,
                     documentStorage,
                     operations
                 );
@@ -960,21 +1397,37 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
                 .updateSynchronizationRevisions(
                     drive,
                     syncUnits,
-                    () => this.updateSyncStatus(drive, 'SYNCING'),
+                    () => {
+                        this.updateSyncStatus(drive, 'SYNCING');
+
+                        for (const syncUnit of syncUnits) {
+                            this.updateSyncStatus(syncUnit.syncId, 'SYNCING');
+                        }
+                    },
                     this.handleListenerError.bind(this),
                     forceSync
                 )
-                .then(
-                    updates =>
-                        updates.length &&
-                        this.updateSyncStatus(drive, 'SUCCESS')
-                )
+                .then(updates => {
+                    updates.length && this.updateSyncStatus(drive, 'SUCCESS');
+
+                    for (const syncUnit of syncUnits) {
+                        this.updateSyncStatus(syncUnit.syncId, 'SUCCESS');
+                    }
+                })
                 .catch(error => {
                     logger.error(
                         'Non handled error updating sync revision',
                         error
                     );
                     this.updateSyncStatus(drive, 'ERROR', error as Error);
+
+                    for (const syncUnit of syncUnits) {
+                        this.updateSyncStatus(
+                            syncUnit.syncId,
+                            'ERROR',
+                            error as Error
+                        );
+                    }
                 });
 
             // after applying all the valid operations,throws
@@ -994,11 +1447,11 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
                 error instanceof OperationError
                     ? error
                     : new OperationError(
-                        'ERROR',
-                        undefined,
-                        (error as Error).message,
-                        (error as Error).cause
-                    );
+                          'ERROR',
+                          undefined,
+                          (error as Error).message,
+                          (error as Error).cause
+                      );
 
             return {
                 status: operationError.status,
@@ -1053,33 +1506,92 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
         }
     }
 
-    queueDriveOperation(drive: string, operation: Operation<DocumentDriveAction | BaseAction>, forceSync = true): Promise<IOperationResult<DocumentDriveDocument>> {
+    queueDriveOperation(
+        drive: string,
+        operation: Operation<DocumentDriveAction | BaseAction>,
+        forceSync = true
+    ): Promise<IOperationResult<DocumentDriveDocument>> {
         return this.queueDriveOperations(drive, [operation], forceSync);
     }
 
+    private async resultIfExistingDriveOperations(
+        driveId: string,
+        operations: Operation<DocumentDriveAction | BaseAction>[]
+    ): Promise<IOperationResult<DocumentDriveDocument> | undefined> {
+        try {
+            const drive = await this.getDrive(driveId);
+            const newOperation = operations.find(
+                op =>
+                    !op.id ||
+                    !drive.operations[op.scope].find(
+                        existingOp =>
+                            existingOp.id === op.id &&
+                            existingOp.index === op.index &&
+                            existingOp.type === op.type &&
+                            existingOp.hash === op.hash
+                    )
+            );
+            if (!newOperation) {
+                return {
+                    status: 'SUCCESS',
+                    document: drive,
+                    operations: operations,
+                    signals: []
+                } as IOperationResult<DocumentDriveDocument>;
+            } else {
+                return undefined;
+            }
+        } catch (error) {
+            console.error(error); // TODO error
+            return undefined;
+        }
+    }
+
     async queueDriveOperations(
         drive: string,
         operations: Operation<DocumentDriveAction | BaseAction>[],
         forceSync = true
     ): Promise<IOperationResult<DocumentDriveDocument>> {
-        const jobId = await this.queueManager.addJob({ driveId: drive, operations, forceSync });
-        return new Promise<IOperationResult<DocumentDriveDocument>>((resolve, reject) => {
-            const unsubscribe = this.queueManager.on('jobCompleted', (job, result) => {
-                if (job.jobId === jobId) {
-                    unsubscribe();
-                    unsubscribeError();
-                    resolve(result as IOperationResult<DocumentDriveDocument>);
-                }
-            });
-            const unsubscribeError = this.queueManager.on('jobFailed', (job, error) => {
-                if (job.jobId === jobId) {
-                    unsubscribe();
-                    unsubscribeError();
-                    reject(error);
-                }
-            });
+        // if operations are already stored then returns cached document
+        const result = await this.resultIfExistingDriveOperations(
+            drive,
+            operations
+        );
+        if (result) {
+            return result;
+        }
 
-        })
+        const jobId = await this.queueManager.addJob({
+            driveId: drive,
+            operations,
+            forceSync
+        });
+        return new Promise<IOperationResult<DocumentDriveDocument>>(
+            (resolve, reject) => {
+                const unsubscribe = this.queueManager.on(
+                    'jobCompleted',
+                    (job, result) => {
+                        if (job.jobId === jobId) {
+                            unsubscribe();
+                            unsubscribeError();
+                            resolve(
+                                result as IOperationResult<DocumentDriveDocument>
+                            );
+                        }
+                    }
+                );
+                const unsubscribeError = this.queueManager.on(
+                    'jobFailed',
+                    (job, error) => {
+                        if (job.jobId === jobId) {
+                            unsubscribe();
+                            unsubscribeError();
+                            reject(error);
+                        }
+                    }
+                );
+            }
+        );
     }
 
     async addDriveOperations(
@@ -1093,12 +1605,23 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
         const signals: SignalResult[] = [];
         let error: Error | undefined;
 
+        // if operations are already stored then returns cached drive
+        const result = await this.resultIfExistingDriveOperations(
+            drive,
+            operations
+        );
+        if (result) {
+            return result;
+        }
+
+        const prevSyncUnits = await this.getSynchronizationUnitsIds(drive);
+
         try {
             await this._addDriveOperations(drive, async documentStorage => {
                 const result = await this._processOperations<
                     DocumentDriveDocument,
                     DocumentDriveAction
-                >(drive, documentStorage, operations.slice());
+                >(drive, undefined, documentStorage, operations.slice());
 
                 document = result.document;
                 operationsApplied.push(...result.operationsApplied);
@@ -1107,7 +1630,7 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
 
                 return {
                     operations: result.operationsApplied,
-                    header: result.document,
+                    header: result.document
                 };
             });
 
@@ -1132,6 +1655,19 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
                 }
             }
 
+            const syncUnits = await this.getSynchronizationUnitsIds(drive);
+
+            const prevSyncUnitsIds = prevSyncUnits.map(unit => unit.syncId);
+            const syncUnitsIds = syncUnits.map(unit => unit.syncId);
+
+            const newSyncUnits = syncUnitsIds.filter(
+                syncUnitId => !prevSyncUnitsIds.includes(syncUnitId)
+            );
+
+            const removedSyncUnits = prevSyncUnitsIds.filter(
+                syncUnitId => !syncUnitsIds.includes(syncUnitId)
+            );
+
             // update listener cache
             const lastOperation = operationsApplied
                 .filter(op => op.scope === 'global')
@@ -1153,21 +1689,49 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
                                 revision: lastOperation.index
                             }
                         ],
-                        () => this.updateSyncStatus(drive, 'SYNCING'),
+                        () => {
+                            this.updateSyncStatus(drive, 'SYNCING');
+
+                            for (const syncUnitId of [
+                                ...newSyncUnits,
+                                ...removedSyncUnits
+                            ]) {
+                                this.updateSyncStatus(syncUnitId, 'SYNCING');
+                            }
+                        },
                         this.handleListenerError.bind(this),
                         forceSync
                     )
-                    .then(
-                        updates =>
-                            updates.length &&
-                            this.updateSyncStatus(drive, 'SUCCESS')
-                    )
+                    .then(updates => {
+                        if (updates.length) {
+                            this.updateSyncStatus(drive, 'SUCCESS');
+
+                            for (const syncUnitId of newSyncUnits) {
+                                this.updateSyncStatus(syncUnitId, 'SUCCESS');
+                            }
+
+                            for (const syncUnitId of removedSyncUnits) {
+                                this.updateSyncStatus(syncUnitId, null);
+                            }
+                        }
+                    })
                     .catch(error => {
                         logger.error(
                             'Non handled error updating sync revision',
                             error
                         );
                         this.updateSyncStatus(drive, 'ERROR', error as Error);
+
+                        for (const syncUnitId of [
+                            ...newSyncUnits,
+                            ...removedSyncUnits
+                        ]) {
+                            this.updateSyncStatus(
+                                syncUnitId,
+                                'ERROR',
+                                error as Error
+                            );
+                        }
                     });
             }
 
@@ -1194,11 +1758,11 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
                 error instanceof OperationError
                     ? error
                     : new OperationError(
-                        'ERROR',
-                        undefined,
-                        (error as Error).message,
-                        (error as Error).cause
-                    );
+                          'ERROR',
+                          undefined,
+                          (error as Error).message,
+                          (error as Error).cause
+                      );
 
             return {
                 status: operationError.status,
@@ -1230,36 +1794,44 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
     async addAction(
         drive: string,
         id: string,
-        action: Action
+        action: Action,
+        forceSync = true
     ): Promise<IOperationResult> {
-        return this.addActions(drive, id, [action]);
+        return this.addActions(drive, id, [action], forceSync);
     }
 
     async addActions(
         drive: string,
         id: string,
-        actions: Action[]
+        actions: Action[],
+        forceSync = true
     ): Promise<IOperationResult> {
         const document = await this.getDocument(drive, id);
         const operations = this._buildOperations(document, actions);
-        return this.queueOperations(drive, id, operations);
+        return this.addOperations(drive, id, operations, forceSync);
     }
 
     async addDriveAction(
         drive: string,
-        action: DocumentDriveAction | BaseAction
+        action: DocumentDriveAction | BaseAction,
+        forceSync = true
     ): Promise<IOperationResult<DocumentDriveDocument>> {
-        return this.addDriveActions(drive, [action]);
+        return this.addDriveActions(drive, [action], forceSync);
     }
 
     async addDriveActions(
         drive: string,
-        actions: (DocumentDriveAction | BaseAction)[]
+        actions: (DocumentDriveAction | BaseAction)[],
+        forceSync = true
     ): Promise<IOperationResult<DocumentDriveDocument>> {
         const document = await this.getDrive(drive);
         const operations = this._buildOperations(document, actions);
-        const result = await this.queueDriveOperations(drive, operations);
-        return result as IOperationResult<DocumentDriveDocument>;
+        const result = await this.addDriveOperations(
+            drive,
+            operations,
+            forceSync
+        );
+        return result;
     }
 
     async addInternalListener(