document-drive 1.0.0-alpha.1 → 1.0.0-alpha.2

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "document-drive",
-    "version": "1.0.0-alpha.1",
+    "version": "1.0.0-alpha.2",
     "license": "AGPL-3.0-only",
     "type": "module",
     "module": "./src/index.ts",
@@ -55,7 +55,7 @@
         "@typescript-eslint/parser": "^6.18.1",
         "@vitest/coverage-v8": "^0.34.6",
         "document-model": "^1.0.29",
-        "document-model-libs": "^1.1.44",
+        "document-model-libs": "^1.1.48",
         "eslint": "^8.56.0",
         "eslint-config-prettier": "^9.1.0",
         "fake-indexeddb": "^5.0.1",

package/src/server/index.ts

@@ -23,8 +23,11 @@ import { generateUUID, isDocumentDrive, isNoopUpdate } from '../utils';
 import { requestPublicDrive } from '../utils/graphql';
 import { OperationError } from './error';
 import { ListenerManager } from './listener/manager';
-import { PullResponderTransmitter } from './listener/transmitter';
-import type { ITransmitter } from './listener/transmitter/types';
+import {
+    CancelPullLoop,
+    ITransmitter,
+    PullResponderTransmitter
+} from './listener/transmitter';
 import {
     BaseDocumentDriveServer,
     DriveEvents,
@@ -52,7 +55,7 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
     private listenerStateManager: ListenerManager;
     private triggerMap = new Map<
         DocumentDriveState['id'],
-        Map<Trigger['id'], number>
+        Map<Trigger['id'], CancelPullLoop>
     >();
     private syncStatus = new Map<DocumentDriveState['id'], SyncStatus>();
 
@@ -100,7 +103,9 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
                   operations
               ));
 
-        this.updateSyncStatus(strand.driveId, result.status);
+        if (result.status === 'ERROR') {
+            this.updateSyncStatus(strand.driveId, result.status, result.error);
+        }
         this.emit('strandUpdate', strand);
         return result;
     }
@@ -142,7 +147,7 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
 
             this.updateSyncStatus(driveId, 'SYNCING');
             if (PullResponderTransmitter.isPullResponderTrigger(trigger)) {
-                const intervalId = PullResponderTransmitter.setupPull(
+                const cancelPullLoop = PullResponderTransmitter.setupPull(
                     driveId,
                     trigger,
                     this.saveStrand.bind(this),
@@ -151,12 +156,20 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
                             driveId,
                             error instanceof OperationError
                                 ? error.status
-                                : 'ERROR'
+                                : 'ERROR',
+                            error
                         );
                     },
-                    acknowledgeSuccess => {}
+                    revisions => {
+                        const errorRevision = revisions.find(
+                            r => r.status !== 'SUCCESS'
+                        );
+                        if (!errorRevision) {
+                            this.updateSyncStatus(driveId, 'SUCCESS');
+                        }
+                    }
                 );
-                driveTriggers.set(trigger.id, intervalId);
+                driveTriggers.set(trigger.id, cancelPullLoop);
                 this.triggerMap.set(driveId, driveTriggers);
             }
         }
@@ -164,7 +177,7 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
 
     private async stopSyncRemoteDrive(driveId: string) {
         const triggers = this.triggerMap.get(driveId);
-        triggers?.forEach(clearInterval);
+        triggers?.forEach(cancel => cancel());
         return this.triggerMap.delete(driveId);
     }
 
@@ -607,9 +620,12 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
                 );
                 continue;
             } else if (op.index < nextIndex) {
-                const existingOperation = scopeOperations.find(
-                    existingOperation => existingOperation.index === op.index
-                );
+                const existingOperation = scopeOperations
+                    .concat(pastOperations)
+                    .find(
+                        existingOperation =>
+                            existingOperation.index === op.index
+                    );
                 if (existingOperation && existingOperation.hash !== op.hash) {
                     error = new OperationError(
                         'CONFLICT',
@@ -986,6 +1002,13 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
         return this.listenerStateManager.getTransmitter(driveId, listenerId);
     }
 
+    getListener(
+        driveId: string,
+        listenerId: string
+    ): Promise<ListenerState | undefined> {
+        return this.listenerStateManager.getListener(driveId, listenerId);
+    }
+
     getSyncStatus(drive: string): SyncStatus {
         const status = this.syncStatus.get(drive);
         if (!status) {

package/src/server/listener/decorator.ts

@@ -0,0 +1,28 @@
+import { DocumentDriveServer } from '..';
+
+function ListenerManagerDecorator(constructor: new () => DocumentDriveServer) {
+    return class extends constructor {
+        // Define extra methods here
+        extraMethod(): void {
+            // Access private variables of the original class
+            console.log('Accessing private variable:', this.getLi);
+        }
+    };
+}
+
+// Define your original class
+class OriginalClass {
+    private privateVariable: string;
+
+    constructor(privateVariable: string) {
+        this.privateVariable = privateVariable;
+    }
+
+    // Define other methods and properties here
+}
+
+// Use the decorator to augment the original class with extra methods
+const AugmentedClass = ExtraMethodsDecorator(OriginalClass);
+
+// Create an instance of the augmented class
+const instance = new AugmentedClass('private data');

package/src/server/listener/manager.ts

@@ -419,11 +419,53 @@ export class ListenerManager extends BaseListenerManager {
         }
     }
 
-    getListener(driveId: string, listenerId: string): ListenerState {
+    getListener(driveId: string, listenerId: string): Promise<ListenerState> {
         const drive = this.listenerState.get(driveId);
         if (!drive) throw new Error('Drive not found');
         const listener = drive.get(listenerId);
         if (!listener) throw new Error('Listener not found');
-        return listener;
+        return Promise.resolve(listener);
+    }
+
+    async getStrands(
+        driveId: string,
+        listenerId: string,
+        since?: string
+    ): Promise<StrandUpdate[]> {
+        // fetch listenerState from listenerManager
+        const entries = await this.getListener(driveId, listenerId);
+
+        // fetch operations from drive  and prepare strands
+        const strands: StrandUpdate[] = [];
+
+        for (const entry of entries.syncUnits) {
+            if (entry.listenerRev >= entry.syncRev) {
+                continue;
+            }
+
+            const { documentId, driveId, scope, branch } = entry;
+            const operations = await this.drive.getOperationData(
+                entry.driveId,
+                entry.syncId,
+                {
+                    since,
+                    fromRevision: entry.listenerRev
+                }
+            );
+
+            if (!operations.length) {
+                continue;
+            }
+
+            strands.push({
+                driveId,
+                documentId,
+                scope: scope as OperationScope,
+                branch,
+                operations
+            });
+        }
+
+        return strands;
     }
 }

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

@@ -8,6 +8,7 @@ import {
     IOperationResult,
     Listener,
     ListenerRevision,
+    ListenerRevisionWithError,
     OperationUpdate,
     StrandUpdate
 } from '../../types';
@@ -26,11 +27,17 @@ export type PullStrandsGraphQL = {
     };
 };
 
+export type CancelPullLoop = () => void;
+
 export type StrandUpdateGraphQL = Omit<StrandUpdate, 'operations'> & {
     operations: OperationUpdateGraphQL[];
 };
 
-export class PullResponderTransmitter implements ITransmitter {
+export interface IPullResponderTransmitter extends ITransmitter {
+    getStrands(since?: string): Promise<StrandUpdate[]>;
+}
+
+export class PullResponderTransmitter implements IPullResponderTransmitter {
     private drive: BaseDocumentDriveServer;
     private listener: Listener;
     private manager: ListenerManager;
@@ -49,48 +56,12 @@ export class PullResponderTransmitter implements ITransmitter {
         return [];
     }
 
-    async getStrands(
-        listenerId: string,
-        since?: string
-    ): Promise<StrandUpdate[]> {
-        // fetch listenerState from listenerManager
-        const entries = this.manager.getListener(
+    getStrands(since?: string | undefined): Promise<StrandUpdate[]> {
+        return this.manager.getStrands(
             this.listener.driveId,
-            listenerId
+            this.listener.listenerId,
+            since
         );
-
-        // fetch operations from drive  and prepare strands
-        const strands: StrandUpdate[] = [];
-
-        for (const entry of entries.syncUnits) {
-            if (entry.listenerRev >= entry.syncRev) {
-                continue;
-            }
-
-            const { documentId, driveId, scope, branch } = entry;
-            const operations = await this.drive.getOperationData(
-                entry.driveId,
-                entry.syncId,
-                {
-                    since,
-                    fromRevision: entry.listenerRev
-                }
-            );
-
-            if (!operations.length) {
-                continue;
-            }
-
-            strands.push({
-                driveId,
-                documentId,
-                scope: scope as OperationScope,
-                branch,
-                operations
-            });
-        }
-
-        return strands;
     }
 
     async processAcknowledge(
@@ -98,7 +69,7 @@ export class PullResponderTransmitter implements ITransmitter {
         listenerId: string,
         revisions: ListenerRevision[]
     ): Promise<boolean> {
-        const listener = this.manager.getListener(driveId, listenerId);
+        const listener = await this.manager.getListener(driveId, listenerId);
 
         let success = true;
         for (const revision of revisions) {
@@ -223,6 +194,7 @@ export class PullResponderTransmitter implements ITransmitter {
         trigger: PullResponderTrigger,
         onStrandUpdate: (strand: StrandUpdate) => Promise<IOperationResult>,
         onError: (error: Error) => void,
+        onRevisions?: (revisions: ListenerRevisionWithError[]) => void,
         onAcknowledge?: (success: boolean) => void
     ) {
         try {
@@ -239,7 +211,7 @@ export class PullResponderTransmitter implements ITransmitter {
                 return;
             }
 
-            const listenerRevisions: ListenerRevision[] = [];
+            const listenerRevisions: ListenerRevisionWithError[] = [];
 
             for (const strand of strands) {
                 const operations: Operation[] = strand.operations.map(
@@ -256,7 +228,6 @@ export class PullResponderTransmitter implements ITransmitter {
                 );
 
                 let error: Error | undefined = undefined;
-
                 try {
                     const result = await onStrandUpdate(strand);
                     if (result.error) {
@@ -277,20 +248,26 @@ export class PullResponderTransmitter implements ITransmitter {
                         ? error instanceof OperationError
                             ? error.status
                             : 'ERROR'
-                        : 'SUCCESS'
+                        : 'SUCCESS',
+                    error
                 });
 
                 // TODO: Should try to parse remaining strands?
-                if (error) {
-                    break;
-                }
+                // if (error) {
+                //     break;
+                // }
             }
 
+            onRevisions?.(listenerRevisions);
+
             await PullResponderTransmitter.acknowledgeStrands(
                 driveId,
                 url,
                 listenerId,
-                listenerRevisions
+                listenerRevisions.map(revision => {
+                    const { error, ...rest } = revision;
+                    return rest;
+                })
             )
                 .then(result => onAcknowledge?.(result))
                 .catch(error => console.error('ACK error', error));
@@ -304,8 +281,9 @@ export class PullResponderTransmitter implements ITransmitter {
         trigger: PullResponderTrigger,
         onStrandUpdate: (strand: StrandUpdate) => Promise<IOperationResult>,
         onError: (error: Error) => void,
+        onRevisions?: (revisions: ListenerRevisionWithError[]) => void,
         onAcknowledge?: (success: boolean) => void
-    ): number {
+    ): CancelPullLoop {
         const { interval } = trigger.data;
         let loopInterval = PULL_DRIVE_INTERVAL;
         if (interval) {
@@ -319,26 +297,36 @@ export class PullResponderTransmitter implements ITransmitter {
             }
         }
 
-        this.executePull(
-            driveId,
-            trigger,
-            onStrandUpdate,
-            onError,
-            onAcknowledge
-        );
+        let isCancelled = false;
+        let timeout: number | undefined;
 
-        const timeout = setInterval(
-            async () =>
-                this.executePull(
+        const executeLoop = async () => {
+            while (!isCancelled) {
+                await this.executePull(
                     driveId,
                     trigger,
                     onStrandUpdate,
                     onError,
+                    onRevisions,
                     onAcknowledge
-                ),
-            loopInterval
-        );
-        return timeout as unknown as number;
+                );
+                await new Promise(resolve => {
+                    timeout = setTimeout(
+                        resolve,
+                        loopInterval
+                    ) as unknown as number;
+                });
+            }
+        };
+
+        executeLoop().catch(console.error);
+
+        return () => {
+            isCancelled = true;
+            if (timeout !== undefined) {
+                clearTimeout(timeout);
+            }
+        };
     }
 
     static isPullResponderTrigger(

package/src/server/types.ts

@@ -93,6 +93,8 @@ export type ListenerRevision = {
     revision: number;
 };
 
+export type ListenerRevisionWithError = ListenerRevision & { error?: Error };
+
 export type ListenerUpdate = {
     listenerId: string;
     listenerRevisions: ListenerRevision[];
@@ -190,11 +192,6 @@ export abstract class BaseDocumentDriveServer {
     ): Promise<Document>;
     protected abstract deleteDocument(drive: string, id: string): Promise<void>;
 
-    abstract getTransmitter(
-        driveId: string,
-        listenerId: string
-    ): Promise<ITransmitter | undefined>;
-
     /** Event methods **/
     protected abstract emit<K extends keyof DriveEvents>(
         this: this,
@@ -206,6 +203,11 @@ export abstract class BaseDocumentDriveServer {
         event: K,
         cb: DriveEvents[K]
     ): Unsubscribe;
+
+    abstract getTransmitter(
+        driveId: string,
+        listenerId: string
+    ): Promise<ITransmitter | undefined>;
 }
 
 export abstract class BaseListenerManager {
@@ -225,15 +227,27 @@ export abstract class BaseListenerManager {
     }
 
     abstract init(): Promise<void>;
+
     abstract addListener(listener: Listener): Promise<ITransmitter>;
     abstract removeListener(
         driveId: string,
         listenerId: string
     ): Promise<boolean>;
+    abstract getListener(
+        driveId: string,
+        listenerId: string
+    ): Promise<ListenerState | undefined>;
+
     abstract getTransmitter(
         driveId: string,
         listenerId: string
     ): Promise<ITransmitter | undefined>;
+
+    abstract getStrands(
+        listenerId: string,
+        since?: string
+    ): Promise<StrandUpdate[]>;
+
     abstract updateSynchronizationRevision(
         driveId: string,
         syncId: string,