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

package/src/server/types.ts

@@ -14,6 +14,7 @@ import type {
     Document,
     Operation,
     OperationScope,
+    ReducerOptions,
     Signal,
     State
 } from 'document-model/document';
@@ -58,6 +59,8 @@ export type SynchronizationUnit = {
     revision: number;
 };
 
+export type SynchronizationUnitQuery = Omit<SynchronizationUnit, "revision" | "lastUpdated">;
+
 export type Listener = {
     driveId: string;
     listenerId: string;
@@ -116,6 +119,7 @@ export type OperationUpdate = {
     input: object;
     hash: string;
     context?: ActionContext;
+    id?: string;
 };
 
 export type StrandUpdate = {
@@ -140,7 +144,7 @@ export type PartialRecord<K extends keyof any, T> = {
 
 export type RevisionsFilter = PartialRecord<OperationScope, number>;
 
-export type GetDocumentOptions = {
+export type GetDocumentOptions = ReducerOptions & {
     revisions?: RevisionsFilter;
     checkHashes?: boolean;
 };
@@ -159,6 +163,10 @@ export abstract class BaseDocumentDriveServer {
         options?: GetDocumentOptions
     ): Promise<DocumentDriveDocument>;
 
+    abstract getDriveBySlug(
+        slug: string,
+    ): Promise<DocumentDriveDocument>;
+
     abstract getDocuments(drive: string): Promise<string[]>;
     abstract getDocument(
         drive: string,
@@ -172,6 +180,7 @@ export abstract class BaseDocumentDriveServer {
         operation: Operation,
         forceSync?: boolean
     ): Promise<IOperationResult>;
+
     abstract addOperations(
         drive: string,
         id: string,
@@ -185,6 +194,7 @@ export abstract class BaseDocumentDriveServer {
         operation: Operation,
         forceSync?: boolean
     ): Promise<IOperationResult>;
+
     abstract queueOperations(
         drive: string,
         id: string,
@@ -192,6 +202,20 @@ export abstract class BaseDocumentDriveServer {
         forceSync?: boolean
     ): Promise<IOperationResult>;
 
+    abstract queueAction(
+        drive: string,
+        id: string,
+        action: Action,
+        forceSync?: boolean
+    ): Promise<IOperationResult>;
+
+    abstract queueActions(
+        drive: string,
+        id: string,
+        actions: Action[],
+        forceSync?: boolean
+    ): Promise<IOperationResult>;
+
     abstract addDriveOperation(
         drive: string,
         operation: Operation<DocumentDriveAction | BaseAction>,
@@ -214,24 +238,40 @@ export abstract class BaseDocumentDriveServer {
         forceSync?: boolean
     ): Promise<IOperationResult<DocumentDriveDocument>>;
 
+    abstract queueDriveAction(
+        drive: string,
+        action: DocumentDriveAction | BaseAction,
+        forceSync?: boolean
+    ): Promise<IOperationResult<DocumentDriveDocument>>;
+
+    abstract queueDriveActions(
+        drive: string,
+        actions: Array<DocumentDriveAction | BaseAction>,
+        forceSync?: boolean
+    ): Promise<IOperationResult<DocumentDriveDocument>>;
+
     abstract addAction(
         drive: string,
         id: string,
-        action: Action
+        action: Action,
+        forceSync?: boolean
     ): Promise<IOperationResult>;
     abstract addActions(
         drive: string,
         id: string,
-        actions: Action[]
+        actions: Action[],
+        forceSync?: boolean
     ): Promise<IOperationResult>;
 
     abstract addDriveAction(
         drive: string,
-        action: DocumentDriveAction | BaseAction
+        action: DocumentDriveAction | BaseAction,
+        forceSync?: boolean
     ): Promise<IOperationResult<DocumentDriveDocument>>;
     abstract addDriveActions(
         drive: string,
-        actions: (DocumentDriveAction | BaseAction)[]
+        actions: (DocumentDriveAction | BaseAction)[],
+        forceSync?: boolean
     ): Promise<IOperationResult<DocumentDriveDocument>>;
 
     abstract getSyncStatus(drive: string): SyncStatus;
@@ -248,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,
@@ -303,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;
+        }, []);
+    }
 }