document-drive 0.0.30 → 1.0.0-alpha.1

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "document-drive",
-    "version": "0.0.30",
+    "version": "1.0.0-alpha.1",
     "license": "AGPL-3.0-only",
     "type": "module",
     "module": "./src/index.ts",
@@ -24,6 +24,7 @@
         "lint": "eslint src --ext .js,.jsx,.ts,.tsx && yarn check-types",
         "lint:fix": "eslint src --ext .js,.jsx,.ts,.tsx --fix",
         "format": "prettier . --write",
+        "release": "semantic-release",
         "test": "vitest run --coverage",
         "test:watch": "vitest watch"
     },
@@ -43,7 +44,11 @@
         "sanitize-filename": "^1.6.3"
     },
     "devDependencies": {
+        "@commitlint/cli": "^18.6.1",
+        "@commitlint/config-conventional": "^18.6.2",
         "@prisma/client": "5.8.1",
+        "@semantic-release/changelog": "^6.0.3",
+        "@semantic-release/git": "^10.0.1",
         "@total-typescript/ts-reset": "^0.5.1",
         "@types/node": "^20.11.16",
         "@typescript-eslint/eslint-plugin": "^6.18.1",
@@ -58,6 +63,7 @@
         "msw": "^2.1.2",
         "prettier": "^3.1.1",
         "prettier-plugin-organize-imports": "^3.2.4",
+        "semantic-release": "^23.0.2",
         "sequelize": "^6.35.2",
         "sqlite3": "^5.1.7",
         "typescript": "^5.3.2",

package/src/server/index.ts

@@ -138,9 +138,9 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
 
             if (!driveTriggers) {
                 driveTriggers = new Map();
-                this.updateSyncStatus(driveId, 'SYNCING');
             }
 
+            this.updateSyncStatus(driveId, 'SYNCING');
             if (PullResponderTransmitter.isPullResponderTrigger(trigger)) {
                 const intervalId = PullResponderTransmitter.setupPull(
                     driveId,
@@ -786,8 +786,14 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
                         syncUnit.syncId,
                         syncUnit.revision,
                         syncUnit.lastUpdated,
+                        () => this.updateSyncStatus(drive, 'SYNCING'),
                         this.handleListenerError.bind(this)
                     )
+                    .then(
+                        updates =>
+                            updates.length &&
+                            this.updateSyncStatus(drive, 'SUCCESS')
+                    )
                     .catch(error => {
                         console.error(
                             'Non handled error updating sync revision',
@@ -917,8 +923,14 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
                         '0',
                         lastOperation.index,
                         lastOperation.timestamp,
+                        () => this.updateSyncStatus(drive, 'SYNCING'),
                         this.handleListenerError.bind(this)
                     )
+                    .then(
+                        updates =>
+                            updates.length &&
+                            this.updateSyncStatus(drive, 'SUCCESS')
+                    )
                     .catch(error => {
                         console.error(
                             'Non handled error updating sync revision',

package/src/server/listener/manager.ts

@@ -9,6 +9,7 @@ import {
     ErrorStatus,
     Listener,
     ListenerState,
+    ListenerUpdate,
     OperationUpdate,
     StrandUpdate,
     SynchronizationUnit
@@ -122,6 +123,7 @@ export class ListenerManager extends BaseListenerManager {
         syncId: string,
         syncRev: number,
         lastUpdated: string,
+        willUpdate?: (listeners: Listener[]) => void,
         onError?: (
             error: Error,
             driveId: string,
@@ -130,10 +132,10 @@ export class ListenerManager extends BaseListenerManager {
     ) {
         const drive = this.listenerState.get(driveId);
         if (!drive) {
-            return;
+            return [];
         }
 
-        let newRevision = false;
+        const outdatedListeners: Listener[] = [];
         for (const [, listener] of drive) {
             const syncUnits = listener.syncUnits.filter(
                 e => e.syncId === syncId
@@ -149,13 +151,21 @@ export class ListenerManager extends BaseListenerManager {
 
                 syncUnit.syncRev = syncRev;
                 syncUnit.lastUpdated = lastUpdated;
-                newRevision = true;
+                if (
+                    !outdatedListeners.find(
+                        l => l.listenerId === listener.listener.listenerId
+                    )
+                ) {
+                    outdatedListeners.push(listener.listener);
+                }
             }
         }
 
-        if (newRevision) {
+        if (outdatedListeners.length) {
+            willUpdate?.(outdatedListeners);
             return this.triggerUpdate(onError);
         }
+        return [];
     }
 
     async addSyncUnits(syncUnits: SynchronizationUnit[]) {
@@ -251,6 +261,7 @@ export class ListenerManager extends BaseListenerManager {
             listener: ListenerState
         ) => void
     ) {
+        const listenerUpdates: ListenerUpdate[] = [];
         for (const [driveId, drive] of this.listenerState) {
             for (const [id, listener] of drive) {
                 const transmitter = await this.getTransmitter(driveId, id);
@@ -338,6 +349,10 @@ export class ListenerManager extends BaseListenerManager {
                         );
                     }
                     listener.listenerStatus = 'SUCCESS';
+                    listenerUpdates.push({
+                        listenerId: listener.listener.listenerId,
+                        listenerRevisions
+                    });
                 } catch (e) {
                     // TODO: Handle error based on listener params (blocking, retry, etc)
                     onError?.(e as Error, driveId, listener);
@@ -346,6 +361,7 @@ export class ListenerManager extends BaseListenerManager {
                 }
             }
         }
+        return listenerUpdates;
     }
 
     private _checkFilter(

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

@@ -218,6 +218,87 @@ export class PullResponderTransmitter implements ITransmitter {
         return result.acknowledge;
     }
 
+    private static async executePull(
+        driveId: string,
+        trigger: PullResponderTrigger,
+        onStrandUpdate: (strand: StrandUpdate) => Promise<IOperationResult>,
+        onError: (error: Error) => void,
+        onAcknowledge?: (success: boolean) => void
+    ) {
+        try {
+            const { url, listenerId } = trigger.data;
+            const strands = await PullResponderTransmitter.pullStrands(
+                driveId,
+                url,
+                listenerId
+                // since ?
+            );
+
+            // if there are no new strands then do nothing
+            if (!strands.length) {
+                return;
+            }
+
+            const listenerRevisions: ListenerRevision[] = [];
+
+            for (const strand of strands) {
+                const operations: Operation[] = strand.operations.map(
+                    ({ index, type, hash, input, skip, timestamp }) => ({
+                        index,
+                        type,
+                        hash,
+                        input,
+                        skip,
+                        timestamp,
+                        scope: strand.scope,
+                        branch: strand.branch
+                    })
+                );
+
+                let error: Error | undefined = undefined;
+
+                try {
+                    const result = await onStrandUpdate(strand);
+                    if (result.error) {
+                        throw result.error;
+                    }
+                } catch (e) {
+                    error = e as Error;
+                    onError(error);
+                }
+
+                listenerRevisions.push({
+                    branch: strand.branch,
+                    documentId: strand.documentId || '',
+                    driveId: strand.driveId,
+                    revision: operations.pop()?.index ?? -1,
+                    scope: strand.scope as OperationScope,
+                    status: error
+                        ? error instanceof OperationError
+                            ? error.status
+                            : 'ERROR'
+                        : 'SUCCESS'
+                });
+
+                // TODO: Should try to parse remaining strands?
+                if (error) {
+                    break;
+                }
+            }
+
+            await PullResponderTransmitter.acknowledgeStrands(
+                driveId,
+                url,
+                listenerId,
+                listenerRevisions
+            )
+                .then(result => onAcknowledge?.(result))
+                .catch(error => console.error('ACK error', error));
+        } catch (error) {
+            onError(error as Error);
+        }
+    }
+
     static setupPull(
         driveId: string,
         trigger: PullResponderTrigger,
@@ -225,7 +306,7 @@ export class PullResponderTransmitter implements ITransmitter {
         onError: (error: Error) => void,
         onAcknowledge?: (success: boolean) => void
     ): number {
-        const { url, listenerId, interval } = trigger.data;
+        const { interval } = trigger.data;
         let loopInterval = PULL_DRIVE_INTERVAL;
         if (interval) {
             try {
@@ -238,79 +319,25 @@ export class PullResponderTransmitter implements ITransmitter {
             }
         }
 
-        const timeout = setInterval(async () => {
-            try {
-                const strands = await PullResponderTransmitter.pullStrands(
-                    driveId,
-                    url,
-                    listenerId
-                    // since ?
-                );
-
-                // if there are no new strands then do nothing
-                if (!strands.length) {
-                    return;
-                }
-
-                const listenerRevisions: ListenerRevision[] = [];
-
-                for (const strand of strands) {
-                    const operations: Operation[] = strand.operations.map(
-                        ({ index, type, hash, input, skip, timestamp }) => ({
-                            index,
-                            type,
-                            hash,
-                            input,
-                            skip,
-                            timestamp,
-                            scope: strand.scope,
-                            branch: strand.branch
-                        })
-                    );
-
-                    let error: Error | undefined = undefined;
-
-                    try {
-                        const result = await onStrandUpdate(strand);
-                        if (result.error) {
-                            throw result.error;
-                        }
-                    } catch (e) {
-                        error = e as Error;
-                        onError?.(error);
-                    }
-
-                    listenerRevisions.push({
-                        branch: strand.branch,
-                        documentId: strand.documentId ?? '',
-                        driveId: strand.driveId,
-                        revision: operations.pop()?.index ?? -1,
-                        scope: strand.scope as OperationScope,
-                        status: error
-                            ? error instanceof OperationError
-                                ? error.status
-                                : 'ERROR'
-                            : 'SUCCESS'
-                    });
-
-                    // TODO: Should try to parse remaining strands?
-                    if (error) {
-                        break;
-                    }
-                }
+        this.executePull(
+            driveId,
+            trigger,
+            onStrandUpdate,
+            onError,
+            onAcknowledge
+        );
 
-                await PullResponderTransmitter.acknowledgeStrands(
+        const timeout = setInterval(
+            async () =>
+                this.executePull(
                     driveId,
-                    url,
-                    listenerId,
-                    listenerRevisions
-                )
-                    .then(result => onAcknowledge?.(result))
-                    .catch(error => console.error('ACK error', error));
-            } catch (error) {
-                onError(error as Error);
-            }
-        }, loopInterval);
+                    trigger,
+                    onStrandUpdate,
+                    onError,
+                    onAcknowledge
+                ),
+            loopInterval
+        );
         return timeout as unknown as number;
     }
 

package/src/server/types.ts

@@ -93,6 +93,11 @@ export type ListenerRevision = {
     revision: number;
 };
 
+export type ListenerUpdate = {
+    listenerId: string;
+    listenerRevisions: ListenerRevision[];
+};
+
 export type UpdateStatus = 'SUCCESS' | 'CONFLICT' | 'MISSING' | 'ERROR';
 export type ErrorStatus = Exclude<UpdateStatus, 'SUCCESS'>;
 
@@ -233,8 +238,14 @@ export abstract class BaseListenerManager {
         driveId: string,
         syncId: string,
         syncRev: number,
-        lastUpdated: string
-    ): Promise<void>;
+        lastUpdated: string,
+        willUpdate?: (listeners: Listener[]) => void,
+        onError?: (
+            error: Error,
+            driveId: string,
+            listener: ListenerState
+        ) => void
+    ): Promise<ListenerUpdate[]>;
 
     abstract updateListenerRevision(
         listenerId: string,

package/src/storage/prisma.ts

@@ -119,28 +119,6 @@ export class PrismaStorage implements IDriveStorage {
         } catch (e) {
             console.log(e);
         }
-
-        await this.db.document.upsert({
-            where: {
-                id_driveId: {
-                    id: 'drives',
-                    driveId: id
-                }
-            },
-            create: {
-                id: 'drives',
-                driveId: id,
-                documentType: header.documentType,
-                initialState: document.initialState,
-                lastModified: header.lastModified,
-                revision: header.revision,
-                created: header.created
-            },
-            update: {
-                lastModified: header.lastModified,
-                revision: header.revision
-            }
-        });
     }
 
     async getDocuments(drive: string) {