document-drive 1.0.0-alpha.71 → 1.0.0-alpha.73

package/package.json

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

package/src/server/index.ts

@@ -61,6 +61,7 @@ import {
     ListenerState,
     RemoteDriveOptions,
     StrandUpdate,
+    SynchronizationUnitQuery,
     SyncStatus,
     type CreateDocumentInput,
     type DriveInput,
@@ -87,7 +88,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;
 
@@ -186,6 +187,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;
@@ -196,6 +199,11 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
             }
 
             this.updateSyncStatus(driveId, 'SYNCING');
+
+            for (const syncUnit of syncUnits) {
+                this.updateSyncStatus(syncUnit.syncId, 'SYNCING');
+            }
+
             if (PullResponderTransmitter.isPullResponderTrigger(trigger)) {
                 const cancelPullLoop = PullResponderTransmitter.setupPull(
                     driveId,
@@ -211,12 +219,31 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
                         );
                     },
                     revisions => {
-                        const errorRevision = revisions.find(
+                        const errorRevision = revisions.filter(
                             r => r.status !== 'SUCCESS'
                         );
-                        if (!errorRevision) {
+                        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'
+                                );
+                            }
+                        }
                     }
                 );
                 driveTriggers.set(trigger.id, cancelPullLoop);
@@ -226,9 +253,18 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
     }
 
     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);
     }
 
@@ -303,6 +339,34 @@ 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) &&
@@ -336,8 +400,7 @@ 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
@@ -354,35 +417,22 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
             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,
-                    driveId,
-                    documentId: node.id,
-                    documentType: node.documentType,
-                    lastUpdated:
-                        lastOperation?.timestamp ?? document.lastModified,
-                    revision: lastOperation?.index ?? 0
-                });
-            }
+            synchronizationUnitsQuery.push(...nodeUnits.map(n => ({
+                driveId,
+                documentId: node.id,
+                syncId: n.syncId,
+                documentType: node.documentType,
+                scope: n.scope,
+                branch: n.branch
+            })));
         }
-        return synchronizationUnits;
+        return synchronizationUnitsQuery;
     }
 
-    public async getSynchronizationUnit(
+    public async getSynchronizationUnitIdInfo(
         driveId: string,
         syncId: string
-    ): Promise<SynchronizationUnit> {
+    ): Promise<Omit<SynchronizationUnit, "revision" | "lastUpdated"> | undefined> {
         const drive = await this.getDrive(driveId);
         const node = drive.state.global.nodes.find(
             node =>
@@ -391,14 +441,40 @@ 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;
+        }
+
+        return {
+            syncId,
+            scope: syncUnit.scope,
+            branch: syncUnit.branch,
+            driveId,
+            documentId: node.id,
+            documentType: node.documentType,
+        };
+    }
 
-        const documentId = node.id;
+    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];
@@ -409,7 +485,7 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
             branch,
             driveId,
             documentId,
-            documentType: node.documentType,
+            documentType,
             lastUpdated: lastOperation?.timestamp ?? document.lastModified,
             revision: lastOperation?.index ?? 0
         };
@@ -423,17 +499,21 @@ 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 ||
@@ -650,7 +730,7 @@ 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);
@@ -1075,21 +1155,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
@@ -1208,6 +1304,8 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
         const signals: SignalResult[] = [];
         let error: Error | undefined;
 
+        const prevSyncUnits = await this.getSynchronizationUnitsIds(drive);
+
         try {
             await this._addDriveOperations(drive, async documentStorage => {
                 const result = await this._processOperations<
@@ -1247,6 +1345,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')
@@ -1268,21 +1379,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
+                            );
+                        }
                     });
             }
 

package/src/server/listener/manager.ts

@@ -118,7 +118,7 @@ export class ListenerManager extends BaseListenerManager {
         return driveMap.delete(listenerId);
     }
 
-    async removeSyncUnits(driveId: string, syncUnits: SynchronizationUnit[]) {
+    async removeSyncUnits(driveId: string, syncUnits: Pick<SynchronizationUnit, "syncId">[]) {
         const listeners = this.listenerState.get(driveId);
         if (!listeners) {
             return;
@@ -243,7 +243,7 @@ export class ListenerManager extends BaseListenerManager {
 
                     const opData: OperationUpdate[] = [];
                     try {
-                        const data = await this.drive.getOperationData(
+                        const data = await this.drive.getOperationData( // DEAL WITH INVALID SYNC ID ERROR
                             driveId,
                             syncUnit.syncId,
                             {
@@ -373,6 +373,21 @@ export class ListenerManager extends BaseListenerManager {
         );
     }
 
+    getListenerSyncUnitIds(driveId: string, listenerId: string) {
+        const listener = this.listenerState.get(driveId)?.get(listenerId);
+        if (!listener) {
+            return [];
+        }
+        const filter = listener.listener.filter;
+        return this.drive.getSynchronizationUnitsIds(
+            driveId,
+            filter.documentId ?? ['*'],
+            filter.scope ?? ['*'],
+            filter.branch ?? ['*'],
+            filter.documentType ?? ['*']
+        );
+    }
+
     async initDrive(drive: DocumentDriveDocument) {
         const {
             state: {
@@ -420,32 +435,40 @@ export class ListenerManager extends BaseListenerManager {
         const syncUnits = await this.getListenerSyncUnits(driveId, listenerId);
 
         for (const syncUnit of syncUnits) {
+            if (syncUnit.revision < 0) {
+                continue;
+            }
             const entry = listener.syncUnits.get(syncUnit.syncId);
             if (entry && entry.listenerRev >= syncUnit.revision) {
                 continue;
             }
 
             const { documentId, driveId, scope, branch } = syncUnit;
-            const operations = await this.drive.getOperationData(
-                driveId,
-                syncUnit.syncId,
-                {
-                    since,
-                    fromRevision: entry?.listenerRev
+            try {
+                const operations = await this.drive.getOperationData( // DEAL WITH INVALID SYNC ID ERROR
+                    driveId,
+                    syncUnit.syncId,
+                    {
+                        since,
+                        fromRevision: entry?.listenerRev
+                    }
+                );
+
+                if (!operations.length) {
+                    continue;
                 }
-            );
 
-            if (!operations.length) {
+                strands.push({
+                    driveId,
+                    documentId,
+                    scope: scope as OperationScope,
+                    branch,
+                    operations
+                });
+            } catch (error) {
+                logger.error(error);
                 continue;
             }
-
-            strands.push({
-                driveId,
-                documentId,
-                scope: scope as OperationScope,
-                branch,
-                operations
-            });
         }
 
         return strands;

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

@@ -72,7 +72,7 @@ export class PullResponderTransmitter implements IPullResponderTransmitter {
         listenerId: string,
         revisions: ListenerRevision[]
     ): Promise<boolean> {
-        const syncUnits = await this.manager.getListenerSyncUnits(
+        const syncUnits = await this.manager.getListenerSyncUnitIds(
             driveId,
             listenerId
         );

package/src/server/types.ts

@@ -59,6 +59,8 @@ export type SynchronizationUnit = {
     revision: number;
 };
 
+export type SynchronizationUnitQuery = Omit<SynchronizationUnit, "revision" | "lastUpdated">;
+
 export type Listener = {
     driveId: string;
     listenerId: string;
@@ -286,7 +288,15 @@ export abstract class BaseDocumentDriveServer {
     abstract getSynchronizationUnit(
         driveId: string,
         syncId: string
-    ): Promise<SynchronizationUnit>;
+    ): Promise<SynchronizationUnit | undefined>;
+
+    abstract getSynchronizationUnitsIds(
+        driveId: string,
+        documentId?: string[],
+        scope?: string[],
+        branch?: string[],
+        documentType?: string[]
+    ): Promise<SynchronizationUnitQuery[]>;
 
     abstract getOperationData(
         driveId: string,

package/src/storage/browser.ts

@@ -3,10 +3,15 @@ import {
     BaseAction,
     Document,
     DocumentHeader,
-    Operation
+    Operation,
+    OperationScope
 } from 'document-model/document';
-import { mergeOperations } from '..';
-import { DocumentDriveStorage, DocumentStorage, IDriveStorage } from './types';
+import { mergeOperations, type SynchronizationUnitQuery } from '..';
+import {
+    DocumentDriveStorage,
+    DocumentStorage,
+    IDriveStorage,
+} from './types';
 
 export class BrowserStorage implements IDriveStorage {
     private db: Promise<LocalForage>;
@@ -18,7 +23,9 @@ export class BrowserStorage implements IDriveStorage {
     constructor(namespace?: string) {
         this.db = import('localforage').then(localForage =>
             localForage.default.createInstance({
-                name: namespace ? `${namespace}:${BrowserStorage.DBName}` : BrowserStorage.DBName
+                name: namespace
+                    ? `${namespace}:${BrowserStorage.DBName}`
+                    : BrowserStorage.DBName
             })
         );
     }
@@ -68,7 +75,7 @@ export class BrowserStorage implements IDriveStorage {
         drive: string,
         id: string,
         operations: Operation[],
-        header: DocumentHeader,
+        header: DocumentHeader
     ): Promise<void> {
         const document = await this.getDocument(drive, id);
         if (!document) {
@@ -154,4 +161,61 @@ export class BrowserStorage implements IDriveStorage {
         });
         return;
     }
+
+    async getSynchronizationUnitsRevision(
+        units: SynchronizationUnitQuery[]
+    ): Promise<
+        {
+            driveId: string;
+            documentId: string;
+            scope: string;
+            branch: string;
+            lastUpdated: string;
+            revision: number;
+        }[]
+    > {
+        const results = await Promise.allSettled(
+            units.map(async unit => {
+                try {
+                    const document = await (unit.documentId
+                        ? this.getDocument(unit.driveId, unit.documentId)
+                        : this.getDrive(unit.driveId));
+                    if (!document) {
+                        return undefined;
+                    }
+                    const operation =
+                        document.operations[unit.scope as OperationScope]?.at(
+                            -1
+                        );
+                    if (operation) {
+                        return {
+                            driveId: unit.driveId,
+                            documentId: unit.documentId,
+                            scope: unit.scope,
+                            branch: unit.branch,
+                            lastUpdated: operation.timestamp,
+                            revision: operation.index
+                        };
+                    }
+                } catch {
+                    return undefined;
+                }
+            })
+        );
+        return results.reduce<
+            {
+                driveId: string;
+                documentId: string;
+                scope: string;
+                branch: string;
+                lastUpdated: string;
+                revision: number;
+            }[]
+        >((acc, curr) => {
+            if (curr.status === 'fulfilled' && curr.value !== undefined) {
+                acc.push(curr.value);
+            }
+            return acc;
+        }, []);
+    }
 }

package/src/storage/filesystem.ts

@@ -1,5 +1,5 @@
 import { DocumentDriveAction } from 'document-model-libs/document-drive';
-import { BaseAction, DocumentHeader, Operation } from 'document-model/document';
+import { BaseAction, DocumentHeader, Operation, OperationScope } from 'document-model/document';
 import type { Dirent } from 'fs';
 import {
     existsSync,
@@ -12,7 +12,8 @@ import fs from 'fs/promises';
 import stringify from 'json-stringify-deterministic';
 import path from 'path';
 import sanitize from 'sanitize-filename';
-import { mergeOperations } from '..';
+import type { SynchronizationUnitQuery } from '../server/types';
+import { mergeOperations } from '../utils';
 import { DocumentDriveStorage, DocumentStorage, IDriveStorage } from './types';
 
 type FSError = {
@@ -235,4 +236,61 @@ export class FilesystemStorage implements IDriveStorage {
             operations: mergedOperations
         });
     }
+
+    async getSynchronizationUnitsRevision(
+        units: SynchronizationUnitQuery[]
+    ): Promise<
+        {
+            driveId: string;
+            documentId: string;
+            scope: string;
+            branch: string;
+            lastUpdated: string;
+            revision: number;
+        }[]
+    > {
+        const results = await Promise.allSettled(
+            units.map(async unit => {
+                try {
+                    const document = await (unit.documentId
+                        ? this.getDocument(unit.driveId, unit.documentId)
+                        : this.getDrive(unit.driveId));
+                    if (!document) {
+                        return undefined;
+                    }
+                    const operation =
+                        document.operations[unit.scope as OperationScope]?.at(
+                            -1
+                        );
+                    if (operation) {
+                        return {
+                            driveId: unit.driveId,
+                            documentId: unit.documentId,
+                            scope: unit.scope,
+                            branch: unit.branch,
+                            lastUpdated: operation.timestamp,
+                            revision: operation.index
+                        };
+                    }
+                } catch {
+                    return undefined;
+                }
+            })
+        );
+        return results.reduce<
+            {
+                driveId: string;
+                documentId: string;
+                scope: string;
+                branch: string;
+                lastUpdated: string;
+                revision: number;
+            }[]
+        >((acc, curr) => {
+            if (curr.status === 'fulfilled' && curr.value !== undefined) {
+                acc.push(curr.value);
+            }
+            return acc;
+        }, []);
+    }
 }

package/src/storage/memory.ts

@@ -3,10 +3,16 @@ import {
     BaseAction,
     Document,
     DocumentHeader,
-    Operation
+    Operation,
+    OperationScope
 } from 'document-model/document';
-import { mergeOperations } from '..';
-import { DocumentDriveStorage, DocumentStorage, IDriveStorage } from './types';
+import {
+    DocumentDriveStorage,
+    DocumentStorage,
+    IDriveStorage,
+} from './types';
+import type { SynchronizationUnitQuery } from '../server/types';
+import { mergeOperations } from '../utils';
 
 export class MemoryStorage implements IDriveStorage {
     private documents: Record<string, Record<string, DocumentStorage>>;
@@ -19,7 +25,7 @@ export class MemoryStorage implements IDriveStorage {
     }
 
     checkDocumentExists(drive: string, id: string): Promise<boolean> {
-        return Promise.resolve(this.documents[drive]?.[id] !== undefined)
+        return Promise.resolve(this.documents[drive]?.[id] !== undefined);
     }
 
     async getDocuments(drive: string) {
@@ -153,4 +159,61 @@ export class MemoryStorage implements IDriveStorage {
         delete this.documents[id];
         delete this.drives[id];
     }
+
+    async getSynchronizationUnitsRevision(
+        units: SynchronizationUnitQuery[]
+    ): Promise<
+        {
+            driveId: string;
+            documentId: string;
+            scope: string;
+            branch: string;
+            lastUpdated: string;
+            revision: number;
+        }[]
+    > {
+        const results = await Promise.allSettled(
+            units.map(async unit => {
+                try {
+                    const document = await (unit.documentId
+                        ? this.getDocument(unit.driveId, unit.documentId)
+                        : this.getDrive(unit.driveId));
+                    if (!document) {
+                        return undefined;
+                    }
+                    const operation =
+                        document.operations[unit.scope as OperationScope]?.at(
+                            -1
+                        );
+                    if (operation) {
+                        return {
+                            driveId: unit.driveId,
+                            documentId: unit.documentId,
+                            scope: unit.scope,
+                            branch: unit.branch,
+                            lastUpdated: operation.timestamp,
+                            revision: operation.index
+                        };
+                    }
+                } catch {
+                    return undefined;
+                }
+            })
+        );
+        return results.reduce<
+            {
+                driveId: string;
+                documentId: string;
+                scope: string;
+                branch: string;
+                lastUpdated: string;
+                revision: number;
+            }[]
+        >((acc, curr) => {
+            if (curr.status === 'fulfilled' && curr.value !== undefined) {
+                acc.push(curr.value);
+            }
+            return acc;
+        }, []);
+    }
 }

package/src/storage/prisma.ts

@@ -22,6 +22,7 @@ import { IBackOffOptions, backOff } from 'exponential-backoff';
 import { ConflictOperationError } from '../server/error';
 import { logger } from '../utils/logger';
 import { DocumentDriveStorage, DocumentStorage, IDriveStorage, IStorageDelegate } from './types';
+import type { SynchronizationUnitQuery } from '../server/types';
 
 type Transaction =
     | Omit<
@@ -552,4 +553,37 @@ export class PrismaStorage implements IDriveStorage {
     getDriveOperationResultingState(drive: string, index: number, scope: string, branch: string): Promise<unknown> {
         return this.getOperationResultingState("drives", drive, index, scope, branch);
     }
+
+    async getSynchronizationUnitsRevision(
+        units: SynchronizationUnitQuery[]
+    ): Promise<
+        {
+            driveId: string;
+            documentId: string;
+            scope: string;
+            branch: string;
+            lastUpdated: string;
+            revision: number;
+        }[]
+    > {
+        // TODO add branch condition
+        const whereClauses = units.map((_, index) => {
+            return `("driveId" = $${index * 3 + 1} AND "documentId" = $${index * 3 + 2} AND "scope" = $${index * 3 + 3})`;
+        }).join(' OR ');
+
+        const query = `
+            SELECT "driveId", "documentId", "scope", "branch", MAX("timestamp") as "lastUpdated", MAX("index") as revision FROM "Operation"
+            WHERE ${whereClauses}
+            GROUP BY "driveId", "documentId", "scope", "branch"
+        `;
+
+        const params = units.map(unit => [unit.documentId ? unit.driveId : "drives", unit.documentId || unit.driveId, unit.scope]).flat();
+        const results = await this.db.$queryRawUnsafe<{ driveId: string, documentId: string, lastUpdated: string, scope: OperationScope, branch: string, revision: number }[]>(query, ...params);
+        return results.map(row => ({
+            ...row,
+            driveId: row.driveId === "drives" ? row.documentId : row.driveId,
+            documentId: row.driveId === "drives" ? '' : row.documentId,
+            lastUpdated: new Date(row.lastUpdated).toISOString(),
+        }));
+    }
 }

package/src/storage/sequelize.ts

@@ -11,6 +11,7 @@ import {
 } from 'document-model/document';
 import { DataTypes, Options, Sequelize } from 'sequelize';
 import { DocumentDriveStorage, DocumentStorage, IDriveStorage } from './types';
+import type { SynchronizationUnitQuery } from '../server/types';
 
 export class SequelizeStorage implements IDriveStorage {
     private db: Sequelize;
@@ -448,4 +449,61 @@ export class SequelizeStorage implements IDriveStorage {
             });
         }
     }
+
+    async getSynchronizationUnitsRevision(
+        units: SynchronizationUnitQuery[]
+    ): Promise<
+        {
+            driveId: string;
+            documentId: string;
+            scope: string;
+            branch: string;
+            lastUpdated: string;
+            revision: number;
+        }[]
+    > {
+        const results = await Promise.allSettled(
+            units.map(async unit => {
+                try {
+                    const document = await (unit.documentId
+                        ? this.getDocument(unit.driveId, unit.documentId)
+                        : this.getDrive(unit.driveId));
+                    if (!document) {
+                        return undefined;
+                    }
+                    const operation =
+                        document.operations[unit.scope as OperationScope]?.at(
+                            -1
+                        );
+                    if (operation) {
+                        return {
+                            driveId: unit.driveId,
+                            documentId: unit.documentId,
+                            scope: unit.scope,
+                            branch: unit.branch,
+                            lastUpdated: operation.timestamp,
+                            revision: operation.index
+                        };
+                    }
+                } catch {
+                    return undefined;
+                }
+            })
+        );
+        return results.reduce<
+            {
+                driveId: string;
+                documentId: string;
+                scope: string;
+                branch: string;
+                lastUpdated: string;
+                revision: number;
+            }[]
+        >((acc, curr) => {
+            if (curr.status === 'fulfilled' && curr.value !== undefined) {
+                acc.push(curr.value);
+            }
+            return acc;
+        }, []);
+    }
 }

package/src/storage/types.ts

@@ -10,6 +10,7 @@ import type {
     DocumentOperations,
     Operation,
 } from 'document-model/document';
+import type { SynchronizationUnitQuery } from '../server/types';
 
 export type DocumentStorage<D extends Document = Document> = Omit<
     D,
@@ -48,6 +49,14 @@ export interface IStorage {
     deleteDocument(drive: string, id: string): Promise<void>;
     getOperationResultingState?(drive: string, id: string, index: number, scope: string, branch: string): Promise<unknown>;
     setStorageDelegate?(delegate: IStorageDelegate): void;
+    getSynchronizationUnitsRevision(units: SynchronizationUnitQuery[]): Promise<{
+        driveId: string;
+        documentId: string;
+        scope: string;
+        branch: string;
+        lastUpdated: string;
+        revision: number;
+    }[]>
 }
 export interface IDriveStorage extends IStorage {
     getDrives(): Promise<string[]>;
@@ -69,4 +78,4 @@ export interface IDriveStorage extends IStorage {
         }>
     ): Promise<void>;
     getDriveOperationResultingState?(drive: string, index: number, scope: string, branch: string): Promise<unknown>;
-}
+}