document-drive 1.0.0-alpha.72 → 1.0.0-alpha.74

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "document-drive",
-    "version": "1.0.0-alpha.72",
+    "version": "1.0.0-alpha.74",
     "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,
@@ -186,7 +187,7 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
         const drive = await this.getDrive(driveId);
         let driveTriggers = this.triggerMap.get(driveId);
 
-        const syncUnits = await this.getSynchronizationUnits(driveId);
+        const syncUnits = await this.getSynchronizationUnitsIds(driveId);
 
         for (const trigger of drive.state.local.triggers) {
             if (driveTriggers?.get(trigger.id)) {
@@ -252,7 +253,7 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
     }
 
     private async stopSyncRemoteDrive(driveId: string) {
-        const syncUnits = await this.getSynchronizationUnits(driveId);
+        const syncUnits = await this.getSynchronizationUnitsIds(driveId);
         const fileNodes = syncUnits
             .filter(syncUnit => syncUnit.documentId !== '')
             .map(syncUnit => syncUnit.documentId);
@@ -338,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) &&
@@ -371,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
@@ -389,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<SynchronizationUnitQuery | undefined> {
         const drive = await this.getDrive(driveId);
         const node = drive.state.global.nodes.find(
             node =>
@@ -426,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;
+        }
 
-        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];
@@ -444,7 +485,7 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
             branch,
             driveId,
             documentId,
-            documentType: node.documentType,
+            documentType,
             lastUpdated: lastOperation?.timestamp ?? document.lastModified,
             revision: lastOperation?.index ?? 0
         };
@@ -458,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 ||
@@ -560,9 +605,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() {
@@ -685,7 +739,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);
@@ -1259,7 +1313,7 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
         const signals: SignalResult[] = [];
         let error: Error | undefined;
 
-        const prevSyncUnits = await this.getSynchronizationUnits(drive);
+        const prevSyncUnits = await this.getSynchronizationUnitsIds(drive);
 
         try {
             await this._addDriveOperations(drive, async documentStorage => {
@@ -1300,7 +1354,7 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
                 }
             }
 
-            const syncUnits = await this.getSynchronizationUnits(drive);
+            const syncUnits = await this.getSynchronizationUnitsIds(drive);
 
             const prevSyncUnitsIds = prevSyncUnits.map(unit => unit.syncId);
             const syncUnitsIds = syncUnits.map(unit => unit.syncId);

package/src/server/listener/manager.ts

@@ -53,7 +53,7 @@ export class ListenerManager extends BaseListenerManager {
         driveId: string,
         listenerId: string
     ): Promise<ITransmitter | undefined> {
-        return this.transmitters[driveId]?.[listenerId];
+        return Promise.resolve(this.transmitters[driveId]?.[listenerId]);
     }
 
     async addListener(listener: Listener) {
@@ -106,7 +106,7 @@ export class ListenerManager extends BaseListenerManager {
         const driveTransmitters = this.transmitters[drive] || {};
         driveTransmitters[listener.listenerId] = transmitter;
         this.transmitters[drive] = driveTransmitters;
-        return transmitter;
+        return Promise.resolve(transmitter);
     }
 
     async removeListener(driveId: string, listenerId: string) {
@@ -115,10 +115,10 @@ export class ListenerManager extends BaseListenerManager {
             return false;
         }
 
-        return driveMap.delete(listenerId);
+        return Promise.resolve(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;
@@ -128,6 +128,7 @@ export class ListenerManager extends BaseListenerManager {
                 listener.syncUnits.delete(syncUnit.syncId);
             }
         }
+        return Promise.resolve();
     }
 
     async updateSynchronizationRevisions(
@@ -203,6 +204,8 @@ export class ListenerManager extends BaseListenerManager {
         } else {
             listener.syncUnits.set(syncId, { listenerRev, lastUpdated });
         }
+
+        return Promise.resolve();
     }
 
     triggerUpdate = debounce(
@@ -243,7 +246,7 @@ export class ListenerManager extends BaseListenerManager {
 
                     const opData: OperationUpdate[] = [];
                     try {
-                        const data = await this.drive.getOperationData(
+                        const data = await this.drive.getOperationData( // TODO - join queries, DEAL WITH INVALID SYNC ID ERROR
                             driveId,
                             syncUnit.syncId,
                             {
@@ -373,6 +376,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: {
@@ -398,6 +416,14 @@ export class ListenerManager extends BaseListenerManager {
         }
     }
 
+    async removeDrive(driveId: string): Promise<void> {
+        this.listenerState.delete(driveId);
+        const transmitters = this.transmitters[driveId];
+        if (transmitters) {
+            await Promise.all(Object.values(transmitters).map(t => t.disconnect?.()));
+        }
+    }
+
     getListener(driveId: string, listenerId: string): Promise<ListenerState> {
         const drive = this.listenerState.get(driveId);
         if (!drive) throw new Error('Drive not found');
@@ -420,32 +446,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/internal.ts

@@ -12,6 +12,7 @@ import { logger } from '../../../utils/logger';
 
 export interface IReceiver {
     transmit: (strands: InternalTransmitterUpdate[]) => Promise<void>;
+    disconnect: () => Promise<void>;
 }
 
 export type InternalTransmitterUpdate<
@@ -88,4 +89,8 @@ export class InternalTransmitter implements ITransmitter {
     setReceiver(receiver: IReceiver) {
         this.receiver = receiver;
     }
+
+    async disconnect(): Promise<void> {
+        await this.receiver?.disconnect();
+    }
 }

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/listener/transmitter/types.ts

@@ -6,6 +6,7 @@ import { ListenerRevision, StrandUpdate } from '../..';
 
 export interface ITransmitter {
     transmit(strands: StrandUpdate[]): Promise<ListenerRevision[]>;
+    disconnect?(): Promise<void>;
 }
 
 export interface InternalTransmitterService extends ITransmitter {

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,
@@ -341,6 +351,7 @@ export abstract class BaseListenerManager {
     }
 
     abstract initDrive(drive: DocumentDriveDocument): Promise<void>;
+    abstract removeDrive(driveId: DocumentDriveState["id"]): Promise<void>;
 
     abstract addListener(listener: Listener): Promise<ITransmitter>;
     abstract removeListener(

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