document-drive 1.0.0-alpha.13 → 1.0.0-alpha.15

package/package.json

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

package/src/server/index.ts

@@ -1,10 +1,12 @@
 import {
+    actions,
     AddListenerInput,
     DocumentDriveAction,
     DocumentDriveDocument,
     DocumentDriveState,
     FileNode,
     isFileNode,
+    ListenerFilter,
     RemoveListenerInput,
     Trigger,
     utils
@@ -32,12 +34,15 @@ import { OperationError } from './error';
 import { ListenerManager } from './listener/manager';
 import {
     CancelPullLoop,
+    InternalTransmitter,
+    IReceiver,
     ITransmitter,
     PullResponderTransmitter
 } from './listener/transmitter';
 import {
     BaseDocumentDriveServer,
     DriveEvents,
+    GetDocumentOptions,
     IOperationResult,
     ListenerState,
     RemoteDriveOptions,
@@ -49,6 +54,7 @@ import {
     type SignalResult,
     type SynchronizationUnit
 } from './types';
+import { filterOperationsByRevision } from './utils';
 
 export * from './listener';
 export type * from './types';
@@ -196,11 +202,33 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
     async initialize() {
         await this.listenerStateManager.init();
         const drives = await this.getDrives();
-        for (const id of drives) {
-            const drive = await this.getDrive(id);
-            if (this.shouldSyncRemoteDrive(drive)) {
-                this.startSyncRemoteDrive(id);
-            }
+        for (const drive of drives) {
+            await this._initializeDrive(drive);
+        }
+    }
+
+    private async _initializeDrive(driveId: string) {
+        const drive = await this.getDrive(driveId);
+
+        if (this.shouldSyncRemoteDrive(drive)) {
+            await this.startSyncRemoteDrive(driveId);
+        }
+
+        for (const listener of drive.state.local.listeners) {
+            await this.listenerStateManager.addListener({
+                driveId,
+                block: listener.block,
+                filter: {
+                    branch: listener.filter.branch ?? [],
+                    documentId: listener.filter.documentId ?? [],
+                    documentType: listener.filter.documentType ?? [],
+                    scope: listener.filter.scope ?? []
+                },
+                listenerId: listener.listenerId,
+                system: listener.system,
+                callInfo: listener.callInfo ?? undefined,
+                label: listener.label ?? ''
+            });
         }
     }
 
@@ -388,30 +416,7 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
         });
 
         await this.storage.createDrive(id, document);
-
-        // add listeners to state manager
-        for (const listener of drive.local.listeners) {
-            await this.listenerStateManager.addListener({
-                block: listener.block,
-                driveId: id,
-                filter: {
-                    branch: listener.filter.branch ?? [],
-                    documentId: listener.filter.documentId ?? [],
-                    documentType: listener.filter.documentType ?? [],
-                    scope: listener.filter.scope ?? []
-                },
-                listenerId: listener.listenerId,
-                system: listener.system,
-                callInfo: listener.callInfo ?? undefined,
-                label: listener.label ?? ''
-            });
-        }
-
-        // if it is a remote drive that should be available offline, starts
-        // the sync process to pull changes from remote every 30 seconds
-        if (this.shouldSyncRemoteDrive(document)) {
-            await this.startSyncRemoteDrive(id);
-        }
+        await this._initializeDrive(id);
     }
 
     async addRemoteDrive(url: string, options: RemoteDriveOptions) {
@@ -456,12 +461,15 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
         return this.storage.getDrives();
     }
 
-    async getDrive(drive: string) {
+    async getDrive(drive: string, options?: GetDocumentOptions) {
         const driveStorage = await this.storage.getDrive(drive);
         const documentModel = this._getDocumentModel(driveStorage.documentType);
         const document = baseUtils.replayDocument(
             driveStorage.initialState,
-            driveStorage.operations,
+            filterOperationsByRevision(
+                driveStorage.operations,
+                options?.revisions
+            ),
             documentModel.reducer,
             undefined,
             driveStorage
@@ -475,7 +483,7 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
         }
     }
 
-    async getDocument(drive: string, id: string) {
+    async getDocument(drive: string, id: string, options?: GetDocumentOptions) {
         const { initialState, operations, ...header } =
             await this.storage.getDocument(drive, id);
 
@@ -483,7 +491,7 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
 
         return baseUtils.replayDocument(
             initialState,
-            operations,
+            filterOperationsByRevision(operations, options?.revisions),
             documentModel.reducer,
             undefined,
             header
@@ -1002,6 +1010,116 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
         }
     }
 
+    private _buildOperation<T extends Action>(
+        documentStorage: DocumentStorage,
+        action: T | BaseAction
+    ): Operation<T | BaseAction> {
+        const [operation] = this._buildOperations(documentStorage, [action]);
+        if (!operation) {
+            throw new Error('Error creating operation');
+        }
+        return operation;
+    }
+
+    private _buildOperations<T extends Action>(
+        documentStorage: DocumentStorage,
+        actions: (T | BaseAction)[]
+    ): Operation<T | BaseAction>[] {
+        const operations: Operation<T | BaseAction>[] = [];
+        const { reducer } = this._getDocumentModel(
+            documentStorage.documentType
+        );
+        let document = baseUtils.replayDocument(
+            documentStorage.initialState,
+            documentStorage.operations,
+            reducer,
+            undefined,
+            documentStorage
+        );
+        for (const action of actions) {
+            document = reducer(document, action);
+            const operation = document.operations[action.scope].slice().pop();
+            if (!operation) {
+                throw new Error('Error creating operations');
+            }
+            operations.push(operation);
+        }
+        return operations;
+    }
+
+    async addAction(
+        drive: string,
+        id: string,
+        action: Action
+    ): Promise<IOperationResult> {
+        const documentStorage = await this.storage.getDocument(drive, id);
+        const operation = this._buildOperation(documentStorage, action);
+        return this.addOperation(drive, id, operation);
+    }
+
+    async addActions(
+        drive: string,
+        id: string,
+        actions: Action[]
+    ): Promise<IOperationResult> {
+        const documentStorage = await this.storage.getDocument(drive, id);
+        const operations = this._buildOperations(documentStorage, actions);
+        return this.addOperations(drive, id, operations);
+    }
+
+    async addDriveAction(
+        drive: string,
+        action: DocumentDriveAction | BaseAction
+    ): Promise<IOperationResult<DocumentDriveDocument>> {
+        const documentStorage = await this.storage.getDrive(drive);
+        const operation = this._buildOperation(documentStorage, action);
+        return this.addDriveOperation(drive, operation);
+    }
+
+    async addDriveActions(
+        drive: string,
+        actions: (DocumentDriveAction | BaseAction)[]
+    ): Promise<IOperationResult<DocumentDriveDocument>> {
+        const documentStorage = await this.storage.getDrive(drive);
+        const operations = this._buildOperations(documentStorage, actions);
+        return this.addDriveOperations(drive, operations);
+    }
+
+    async addInternalListener(
+        driveId: string,
+        receiver: IReceiver,
+        options: {
+            listenerId: string;
+            label: string;
+            block: boolean;
+            filter: ListenerFilter;
+        }
+    ) {
+        const listener: AddListenerInput['listener'] = {
+            callInfo: {
+                data: '',
+                name: 'Interal',
+                transmitterType: 'Internal'
+            },
+            system: true,
+            ...options
+        };
+        await this.addDriveAction(driveId, actions.addListener({ listener }));
+        const transmitter = await this.getTransmitter(
+            driveId,
+            options.listenerId
+        );
+        if (!transmitter) {
+            throw new Error('Internal listener not found');
+        }
+        if (!(transmitter instanceof InternalTransmitter)) {
+            throw new Error('Listener is not an internal transmitter');
+        }
+
+        transmitter.setReceiver(receiver);
+        return transmitter;
+    }
+
     private async addListener(
         driveId: string,
         operation: Operation<Action<'ADD_LISTENER', AddListenerInput>>

package/src/server/listener/manager.ts

@@ -15,9 +15,9 @@ import {
     SynchronizationUnit
 } from '../types';
 import { PullResponderTransmitter } from './transmitter';
+import { InternalTransmitter } from './transmitter/internal';
 import { SwitchboardPushTransmitter } from './transmitter/switchboard-push';
 import { ITransmitter } from './transmitter/types';
-import { InternalTransmitter } from './transmitter/internal';
 
 export class ListenerManager extends BaseListenerManager {
     async getTransmitter(
@@ -73,10 +73,11 @@ export class ListenerManager extends BaseListenerManager {
                     this.drive,
                     this
                 );
+                break;
             }
-
             case 'Internal': {
                 transmitter = new InternalTransmitter(listener, this.drive);
+                break;
             }
         }
 

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

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

package/src/server/types.ts

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

package/src/server/utils.ts

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