document-drive 1.0.0-alpha.87 → 1.0.0-alpha.89

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "document-drive",
-    "version": "1.0.0-alpha.87",
+    "version": "1.0.0-alpha.89",
     "license": "AGPL-3.0-only",
     "type": "module",
     "module": "./src/index.ts",
@@ -19,6 +19,7 @@
         "./queue/base": "./src/queue/base.ts",
         "./utils": "./src/utils/index.ts",
         "./utils/graphql": "./src/utils/graphql.ts",
+        "./utils/migrations": "./src/utils/migrations.ts",
         "./logger": "./src/utils/logger.ts"
     },
     "files": [
@@ -30,7 +31,7 @@
         "lint:fix": "eslint src --ext .js,.jsx,.ts,.tsx --fix",
         "format": "prettier . --write",
         "release": "semantic-release",
-        "test": "vitest run --coverage",
+        "test": "vitest run --coverage --exclude \"test/flaky/**\"",
         "test:watch": "vitest watch"
     },
     "peerDependencies": {
@@ -38,7 +39,7 @@
         "document-model-libs": "^1.57.0"
     },
     "optionalDependencies": {
-        "@prisma/client": "5.17.0",
+        "@prisma/client": "^5.18.0",
         "localforage": "^1.10.0",
         "redis": "^4.6.15",
         "sequelize": "^6.37.3",
@@ -64,7 +65,7 @@
         "@types/uuid": "^9.0.8",
         "@typescript-eslint/eslint-plugin": "^6.21.0",
         "@typescript-eslint/parser": "^6.21.0",
-        "@vitest/coverage-v8": "^1.6.0",
+        "@vitest/coverage-v8": "^2.0.5",
         "document-model": "^1.7.0",
         "document-model-libs": "^1.70.0",
         "eslint": "^8.57.0",
@@ -74,12 +75,12 @@
         "msw": "^2.3.1",
         "prettier": "^3.3.3",
         "prettier-plugin-organize-imports": "^3.2.4",
-        "prisma": "^5.17.0",
+        "prisma": "^5.18.0",
         "semantic-release": "^23.1.1",
         "sequelize": "^6.37.2",
         "sqlite3": "^5.1.7",
         "typescript": "^5.5.3",
-        "vitest": "^1.6.0"
+        "vitest": "^2.0.5"
     },
     "packageManager": "pnpm@9.1.4+sha256.30a1801ac4e723779efed13a21f4c39f9eb6c9fbb4ced101bce06b422593d7c9"
 }

package/src/server/error.ts

@@ -33,3 +33,21 @@ export class MissingOperationError extends OperationError {
         super('MISSING', operation, `Missing operation on index ${index}`);
     }
 }
+
+export class DriveAlreadyExistsError extends Error {
+    driveId: string;
+
+    constructor(driveId: string) {
+        super(`Drive already exists. ID: ${driveId}`);
+        this.driveId = driveId;
+    }
+}
+
+export class DriveNotFoundError extends Error {
+    driveId: string;
+
+    constructor(driveId: string) {
+        super(`Drive with id ${driveId} not found`);
+        this.driveId = driveId;
+    }
+}

package/src/server/index.ts

@@ -42,6 +42,7 @@ import type {
     IDriveStorage
 } from '../storage/types';
 import { generateUUID, isBefore, isDocumentDrive } from '../utils';
+import { DefaultDrivesManager } from '../utils/default-drives-manager';
 import {
     attachBranch,
     garbageCollect,
@@ -54,7 +55,11 @@ import {
 } from '../utils/document-helpers';
 import { requestPublicDrive } from '../utils/graphql';
 import { logger } from '../utils/logger';
-import { ConflictOperationError, OperationError } from './error';
+import {
+    ConflictOperationError,
+    DriveAlreadyExistsError,
+    OperationError
+} from './error';
 import { ListenerManager } from './listener/manager';
 import {
     CancelPullLoop,
@@ -67,6 +72,7 @@ import {
 import {
     AddOperationOptions,
     BaseDocumentDriveServer,
+    DocumentDriveServerOptions,
     DriveEvents,
     GetDocumentOptions,
     IOperationResult,
@@ -75,6 +81,7 @@ import {
     StrandUpdate,
     SynchronizationUnitQuery,
     SyncStatus,
+    SyncUnitStatusObject,
     type CreateDocumentInput,
     type DriveInput,
     type OperationUpdate,
@@ -87,7 +94,6 @@ export * from './listener';
 export type * from './types';
 
 export const PULL_DRIVE_INTERVAL = 5000;
-
 export class DocumentDriveServer extends BaseDocumentDriveServer {
     private emitter = createNanoEvents<DriveEvents>();
     private cache: ICache;
@@ -98,15 +104,19 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
         DocumentDriveState['id'],
         Map<Trigger['id'], CancelPullLoop>
     >();
-    private syncStatus = new Map<string, SyncStatus>();
+    private syncStatus = new Map<string, SyncUnitStatusObject>();
 
     private queueManager: IQueueManager;
+    private initializePromise: Promise<Error[] | null>;
+
+    private defaultDrivesManager: DefaultDrivesManager;
 
     constructor(
         documentModels: DocumentModel[],
         storage: IDriveStorage = new MemoryStorage(),
         cache: ICache = new InMemoryCache(),
-        queueManager: IQueueManager = new BaseQueueManager()
+        queueManager: IQueueManager = new BaseQueueManager(),
+        options?: DocumentDriveServerOptions
     ) {
         super();
         this.listenerStateManager = new ListenerManager(this);
@@ -114,6 +124,11 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
         this.storage = storage;
         this.cache = cache;
         this.queueManager = queueManager;
+        this.defaultDrivesManager = new DefaultDrivesManager(
+            this,
+            this.defaultDrivesManagerDelegate,
+            options
+        );
 
         this.storage.setStorageDelegate?.({
             getCachedOperations: async (drive, id) => {
@@ -126,18 +141,139 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
                 }
             }
         });
+
+        this.initializePromise = this._initialize();
+    }
+
+    getDefaultRemoteDrives() {
+        return this.defaultDrivesManager.getDefaultRemoteDrives();
+    }
+
+    private getOperationSource(source: StrandUpdateSource) {
+        return source.type === 'local' ? 'push' : 'pull';
+    }
+
+    private getCombinedSyncUnitStatus(
+        syncUnitStatus: SyncUnitStatusObject
+    ): SyncStatus {
+        if (!syncUnitStatus.pull && !syncUnitStatus.push) return 'INITIAL_SYNC';
+        if (syncUnitStatus.pull === 'INITIAL_SYNC') return 'INITIAL_SYNC';
+        if (syncUnitStatus.push === 'INITIAL_SYNC')
+            return syncUnitStatus.pull || 'INITIAL_SYNC';
+
+        const order: Array<SyncStatus> = [
+            'ERROR',
+            'MISSING',
+            'CONFLICT',
+            'SYNCING',
+            'SUCCESS'
+        ];
+        const sortedStatus = Object.values(syncUnitStatus).sort(
+            (a, b) => order.indexOf(a) - order.indexOf(b)
+        );
+
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        return sortedStatus[0]!;
+    }
+
+    private initSyncStatus(
+        syncUnitId: string,
+        status: Partial<SyncUnitStatusObject>
+    ) {
+        const defaultSyncUnitStatus: SyncUnitStatusObject = Object.entries(
+            status
+        ).reduce((acc, [key, _status]) => {
+            return {
+                ...acc,
+                [key]: _status !== 'SYNCING' ? _status : 'INITIAL_SYNC'
+            };
+        }, {});
+
+        this.syncStatus.set(syncUnitId, defaultSyncUnitStatus);
+        this.emit(
+            'syncStatus',
+            syncUnitId,
+            this.getCombinedSyncUnitStatus(defaultSyncUnitStatus),
+            undefined,
+            defaultSyncUnitStatus
+        );
     }
 
-    private updateSyncStatus(
+    private async initializeDriveSyncStatus(
         driveId: string,
-        status: SyncStatus | null,
+        drive: DocumentDriveDocument
+    ) {
+        const syncUnits = await this.getSynchronizationUnitsIds(driveId);
+        const syncStatus: SyncUnitStatusObject = {
+            pull:
+                drive.state.local.triggers.length > 0
+                    ? 'INITIAL_SYNC'
+                    : undefined,
+            push: drive.state.local.listeners.length > 0 ? 'SUCCESS' : undefined
+        };
+
+        if (!syncStatus.pull && !syncStatus.push) return;
+
+        const syncUnitsIds = [driveId, ...syncUnits.map(s => s.syncId)];
+
+        for (const syncUnitId of syncUnitsIds) {
+            this.initSyncStatus(syncUnitId, syncStatus);
+        }
+    }
+
+    private updateSyncUnitStatus(
+        syncUnitId: string,
+        status: Partial<SyncUnitStatusObject> | null,
         error?: Error
     ) {
         if (status === null) {
-            this.syncStatus.delete(driveId);
-        } else if (this.syncStatus.get(driveId) !== status) {
-            this.syncStatus.set(driveId, status);
-            this.emit('syncStatus', driveId, status, error);
+            this.syncStatus.delete(syncUnitId);
+            return;
+        }
+
+        const syncUnitStatus = this.syncStatus.get(syncUnitId);
+
+        if (!syncUnitStatus) {
+            this.initSyncStatus(syncUnitId, status);
+            return;
+        }
+
+        const shouldUpdateStatus = Object.entries(status).some(
+            ([key, _status]) =>
+                syncUnitStatus[key as keyof SyncUnitStatusObject] !== _status
+        );
+
+        if (shouldUpdateStatus) {
+            const newstatus = Object.entries(status).reduce(
+                (acc, [key, _status]) => {
+                    return {
+                        ...acc,
+                        // do not replace initial_syncing if it has not finished yet
+                        [key]:
+                            acc[key as keyof SyncUnitStatusObject] ===
+                                'INITIAL_SYNC' && _status === 'SYNCING'
+                                ? 'INITIAL_SYNC'
+                                : _status
+                    };
+                },
+                syncUnitStatus
+            );
+
+            const previousCombinedStatus =
+                this.getCombinedSyncUnitStatus(syncUnitStatus);
+            const newCombinedStatus = this.getCombinedSyncUnitStatus(newstatus);
+
+            this.syncStatus.set(syncUnitId, newstatus);
+
+            if (previousCombinedStatus !== newCombinedStatus) {
+                this.emit(
+                    'syncStatus',
+                    syncUnitId,
+                    this.getCombinedSyncUnitStatus(newstatus),
+                    error,
+                    newstatus
+                );
+            }
         }
     }
 
@@ -162,7 +298,27 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
               ));
 
         if (result.status === 'ERROR') {
-            this.updateSyncStatus(strand.driveId, result.status, result.error);
+            const syncUnits =
+                strand.documentId !== ''
+                    ? (
+                          await this.getSynchronizationUnitsIds(
+                              strand.driveId,
+                              [strand.documentId],
+                              [strand.scope],
+                              [strand.branch]
+                          )
+                      ).map(s => s.syncId)
+                    : [strand.driveId];
+
+            const operationSource = this.getOperationSource(source);
+
+            for (const syncUnit of syncUnits) {
+                this.updateSyncUnitStatus(
+                    syncUnit,
+                    { [operationSource]: result.status },
+                    result.error
+                );
+            }
         }
         this.emit('strandUpdate', strand);
         return result;
@@ -177,11 +333,10 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
             `Listener ${listener.listener.label ?? listener.listener.listenerId} error:`,
             error
         );
-        this.updateSyncStatus(
-            driveId,
-            error instanceof OperationError ? error.status : 'ERROR',
-            error
-        );
+
+        const status = error instanceof OperationError ? error.status : 'ERROR';
+
+        this.updateSyncUnitStatus(driveId, { push: status }, error);
     }
 
     private shouldSyncRemoteDrive(drive: DocumentDriveDocument) {
@@ -213,10 +368,10 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
                 driveTriggers = new Map();
             }
 
-            this.updateSyncStatus(driveId, 'SYNCING');
+            this.updateSyncUnitStatus(driveId, { pull: 'SYNCING' });
 
             for (const syncUnit of syncUnits) {
-                this.updateSyncStatus(syncUnit.syncId, 'SYNCING');
+                this.updateSyncUnitStatus(syncUnit.syncId, { pull: 'SYNCING' });
             }
 
             if (PullResponderTransmitter.isPullResponderTrigger(trigger)) {
@@ -226,11 +381,14 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
                     trigger,
                     this.saveStrand.bind(this),
                     error => {
-                        this.updateSyncStatus(
-                            driveId,
+                        const statusError =
                             error instanceof OperationError
                                 ? error.status
-                                : 'ERROR',
+                                : 'ERROR';
+
+                        this.updateSyncUnitStatus(
+                            driveId,
+                            { pull: statusError },
                             error
                         );
 
@@ -248,28 +406,47 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
                         const errorRevision = revisions.filter(
                             r => r.status !== 'SUCCESS'
                         );
+
                         if (errorRevision.length < 1) {
-                            this.updateSyncStatus(driveId, 'SUCCESS');
+                            this.updateSyncUnitStatus(driveId, {
+                                pull: 'SUCCESS'
+                            });
                         }
 
-                        for (const syncUnit of syncUnits) {
-                            const fileErrorRevision = errorRevision.find(
-                                r => r.documentId === syncUnit.documentId
-                            );
+                        const documentIdsFromRevision = revisions
+                            .filter(rev => rev.documentId !== '')
+                            .map(rev => rev.documentId);
 
-                            if (fileErrorRevision) {
-                                this.updateSyncStatus(
-                                    syncUnit.syncId,
-                                    fileErrorRevision.status,
-                                    fileErrorRevision.error
-                                );
-                            } else {
-                                this.updateSyncStatus(
-                                    syncUnit.syncId,
-                                    'SUCCESS'
-                                );
-                            }
-                        }
+                        this.getSynchronizationUnitsIds(
+                            driveId,
+                            documentIdsFromRevision
+                        )
+                            .then(revSyncUnits => {
+                                for (const syncUnit of revSyncUnits) {
+                                    const fileErrorRevision =
+                                        errorRevision.find(
+                                            r =>
+                                                r.documentId ===
+                                                syncUnit.documentId
+                                        );
+
+                                    if (fileErrorRevision) {
+                                        this.updateSyncUnitStatus(
+                                            syncUnit.syncId,
+                                            { pull: fileErrorRevision.status },
+                                            fileErrorRevision.error
+                                        );
+                                    } else {
+                                        this.updateSyncUnitStatus(
+                                            syncUnit.syncId,
+                                            {
+                                                pull: 'SUCCESS'
+                                            }
+                                        );
+                                    }
+                                }
+                            })
+                            .catch(console.error);
 
                         // if it is the first pull and returns empty
                         // then updates corresponding push transmitter
@@ -311,20 +488,25 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
 
     private async stopSyncRemoteDrive(driveId: string) {
         const syncUnits = await this.getSynchronizationUnitsIds(driveId);
-        const fileNodes = syncUnits
+        const filesNodeSyncId = syncUnits
             .filter(syncUnit => syncUnit.documentId !== '')
-            .map(syncUnit => syncUnit.documentId);
+            .map(syncUnit => syncUnit.syncId);
 
         const triggers = this.triggerMap.get(driveId);
         triggers?.forEach(cancel => cancel());
-        this.updateSyncStatus(driveId, null);
+        this.updateSyncUnitStatus(driveId, null);
 
-        for (const fileNode of fileNodes) {
-            this.updateSyncStatus(fileNode, null);
+        for (const fileNodeSyncId of filesNodeSyncId) {
+            this.updateSyncUnitStatus(fileNodeSyncId, null);
         }
         return this.triggerMap.delete(driveId);
     }
 
+    private defaultDrivesManagerDelegate = {
+        emit: (...args: Parameters<DriveEvents['defaultRemoteDrive']>) =>
+            this.emit('defaultRemoteDrive', ...args)
+    };
+
     private queueDelegate = {
         checkDocumentExists: (
             driveId: string,
@@ -372,7 +554,17 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
         }
     };
 
-    async initialize() {
+    initialize() {
+        return this.initializePromise;
+    }
+
+    private async _initialize() {
+        try {
+            await this.defaultDrivesManager.removeOldremoteDrives();
+        } catch (error) {
+            logger.error(error);
+        }
+
         const errors: Error[] = [];
         const drives = await this.getDrives();
         for (const drive of drives) {
@@ -387,6 +579,8 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
             errors.push(error);
         });
 
+        await this.defaultDrivesManager.initializeDefaultRemoteDrives();
+
         // if network connect comes back online
         // then triggers the listeners update
         if (typeof window !== 'undefined') {
@@ -411,6 +605,7 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
 
     private async _initializeDrive(driveId: string) {
         const drive = await this.getDrive(driveId);
+        await this.initializeDriveSyncStatus(driveId, drive);
 
         if (this.shouldSyncRemoteDrive(drive)) {
             await this.startSyncRemoteDrive(driveId);
@@ -689,7 +884,7 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
 
         const drives = await this.storage.getDrives();
         if (drives.includes(id)) {
-            throw new Error('Drive already exists');
+            throw new DriveAlreadyExistsError(id);
         }
 
         const document = utils.createDocument({
@@ -711,7 +906,9 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
         url: string,
         options: RemoteDriveOptions
     ): Promise<DocumentDriveDocument> {
-        const { id, name, slug, icon } = await requestPublicDrive(url);
+        const { id, name, slug, icon } =
+            options.expectedDriveInfo || (await requestPublicDrive(url));
+
         const {
             pullFilter,
             pullInterval,
@@ -879,6 +1076,16 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
         };
         await this.storage.createDocument(driveId, input.id, documentStorage);
 
+        // set initial state for new syncUnits
+        for (const syncUnit of input.synchronizationUnits) {
+            this.initSyncStatus(syncUnit.syncId, {
+                pull: this.triggerMap.get(driveId) ? 'INITIAL_SYNC' : undefined,
+                push: this.listenerStateManager.driveHasListeners(driveId)
+                    ? 'SUCCESS'
+                    : undefined
+            });
+        }
+
         // if the document contains operations then
         // stores the operations in the storage
         const operations = Object.values(document.operations).flat();
@@ -907,6 +1114,11 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
             const syncUnits = await this.getSynchronizationUnitsIds(driveId, [
                 id
             ]);
+
+            // remove document sync units status when a document is deleted
+            for (const syncUnit of syncUnits) {
+                this.updateSyncUnitStatus(syncUnit.syncId, null);
+            }
             await this.listenerStateManager.removeSyncUnits(driveId, syncUnits);
         } catch (error) {
             logger.warn('Error deleting document', error);
@@ -989,7 +1201,9 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
                     );
                     document = appliedResult.document;
                     signals.push(...appliedResult.signals);
-                    operationsApplied.push(...appliedResult.operation);
+                    operationsApplied.push(appliedResult.operation);
+
+                    // TODO what to do if one of the applied operations has an error?
                 } catch (e) {
                     error =
                         e instanceof OperationError
@@ -1189,21 +1403,26 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
             { skip: operation.skip, reuseOperationResultingState: true }
         ) as T;
 
-        const appliedOperation = newDocument.operations[operation.scope].filter(
+        const appliedOperations = newDocument.operations[
+            operation.scope
+        ].filter(
             op => op.index == operation.index && op.skip == operation.skip
         );
+        const appliedOperation = appliedOperations.at(0);
 
-        if (appliedOperation.length < 1) {
+        if (!appliedOperation) {
             throw new OperationError(
                 'ERROR',
                 operation,
                 `Operation with index ${operation.index}:${operation.skip} was not applied.`
             );
-        } else if (
-            appliedOperation[0]!.hash !== operation.hash &&
+        }
+        if (
+            !appliedOperation.error &&
+            appliedOperation.hash !== operation.hash &&
             !skipHashValidation
         ) {
-            throw new ConflictOperationError(operation, appliedOperation[0]!);
+            throw new ConflictOperationError(operation, appliedOperation);
         }
 
         for (const signalHandler of operationSignals) {
@@ -1546,26 +1765,38 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
                 : (options?.source ?? { type: 'local' });
 
             // update listener cache
+
+            const operationSource = this.getOperationSource(source);
+
             this.listenerStateManager
                 .updateSynchronizationRevisions(
                     drive,
                     syncUnits,
                     source,
                     () => {
-                        this.updateSyncStatus(drive, 'SYNCING');
+                        this.updateSyncUnitStatus(drive, {
+                            [operationSource]: 'SYNCING'
+                        });
 
                         for (const syncUnit of syncUnits) {
-                            this.updateSyncStatus(syncUnit.syncId, 'SYNCING');
+                            this.updateSyncUnitStatus(syncUnit.syncId, {
+                                [operationSource]: 'SYNCING'
+                            });
                         }
                     },
                     this.handleListenerError.bind(this),
                     options?.forceSync ?? source.type === 'local'
                 )
                 .then(updates => {
-                    updates.length && this.updateSyncStatus(drive, 'SUCCESS');
+                    updates.length &&
+                        this.updateSyncUnitStatus(drive, {
+                            [operationSource]: 'SUCCESS'
+                        });
 
                     for (const syncUnit of syncUnits) {
-                        this.updateSyncStatus(syncUnit.syncId, 'SUCCESS');
+                        this.updateSyncUnitStatus(syncUnit.syncId, {
+                            [operationSource]: 'SUCCESS'
+                        });
                     }
                 })
                 .catch(error => {
@@ -1573,12 +1804,20 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
                         'Non handled error updating sync revision',
                         error
                     );
-                    this.updateSyncStatus(drive, 'ERROR', error as Error);
+                    this.updateSyncUnitStatus(
+                        drive,
+                        {
+                            [operationSource]: 'ERROR'
+                        },
+                        error as Error
+                    );
 
                     for (const syncUnit of syncUnits) {
-                        this.updateSyncStatus(
+                        this.updateSyncUnitStatus(
                             syncUnit.syncId,
-                            'ERROR',
+                            {
+                                [operationSource]: 'ERROR'
+                            },
                             error as Error
                         );
                     }
@@ -1772,7 +2011,6 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
             return result;
         }
 
-        const prevSyncUnits = await this.getSynchronizationUnitsIds(drive);
         try {
             await this._addDriveOperations(drive, async documentStorage => {
                 const result = await this._processOperations<
@@ -1811,26 +2049,6 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
                 }
             }
 
-            const syncUnits = await this.getSynchronizationUnitsIds(
-                drive,
-                undefined,
-                undefined,
-                undefined,
-                undefined,
-                document
-            );
-
-            const prevSyncUnitsIds = prevSyncUnits.map(unit => unit.syncId);
-            const syncUnitsIds = syncUnits.map(unit => unit.syncId);
-
-            const newSyncUnits = syncUnitsIds.filter(
-                syncUnitId => !prevSyncUnitsIds.includes(syncUnitId)
-            );
-
-            const removedSyncUnits = prevSyncUnitsIds.filter(
-                syncUnitId => !syncUnitsIds.includes(syncUnitId)
-            );
-
             // update listener cache
             const lastOperation = operationsApplied
                 .filter(op => op.scope === 'global')
@@ -1857,6 +2075,8 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
                     ? { type: 'local' }
                     : (options?.source ?? { type: 'local' });
 
+                const operationSource = this.getOperationSource(source);
+
                 this.listenerStateManager
                     .updateSynchronizationRevisions(
                         drive,
@@ -1874,29 +2094,18 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
                         ],
                         source,
                         () => {
-                            this.updateSyncStatus(drive, 'SYNCING');
-
-                            for (const syncUnitId of [
-                                ...newSyncUnits,
-                                ...removedSyncUnits
-                            ]) {
-                                this.updateSyncStatus(syncUnitId, 'SYNCING');
-                            }
+                            this.updateSyncUnitStatus(drive, {
+                                [operationSource]: 'SYNCING'
+                            });
                         },
                         this.handleListenerError.bind(this),
                         options?.forceSync ?? source.type === 'local'
                     )
                     .then(updates => {
                         if (updates.length) {
-                            this.updateSyncStatus(drive, 'SUCCESS');
-
-                            for (const syncUnitId of newSyncUnits) {
-                                this.updateSyncStatus(syncUnitId, 'SUCCESS');
-                            }
-
-                            for (const syncUnitId of removedSyncUnits) {
-                                this.updateSyncStatus(syncUnitId, null);
-                            }
+                            this.updateSyncUnitStatus(drive, {
+                                [operationSource]: 'SUCCESS'
+                            });
                         }
                     })
                     .catch(error => {
@@ -1904,18 +2113,11 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
                             'Non handled error updating sync revision',
                             error
                         );
-                        this.updateSyncStatus(drive, 'ERROR', error as Error);
-
-                        for (const syncUnitId of [
-                            ...newSyncUnits,
-                            ...removedSyncUnits
-                        ]) {
-                            this.updateSyncStatus(
-                                syncUnitId,
-                                'ERROR',
-                                error as Error
-                            );
-                        }
+                        this.updateSyncUnitStatus(
+                            drive,
+                            { [operationSource]: 'ERROR' },
+                            error as Error
+                        );
                     });
             }
 
@@ -2108,7 +2310,7 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
             logger.error(`Sync status not found for drive ${drive}`);
             throw new Error(`Sync status not found for drive ${drive}`);
         }
-        return status;
+        return this.getCombinedSyncUnitStatus(status);
     }
 
     on<K extends keyof DriveEvents>(event: K, cb: DriveEvents[K]): Unsubscribe {

package/src/server/listener/manager.ts

@@ -56,6 +56,10 @@ export class ListenerManager extends BaseListenerManager {
         return Promise.resolve(this.transmitters[driveId]?.[listenerId]);
     }
 
+    driveHasListeners(driveId: string) {
+        return this.listenerState.has(driveId);
+    }
+
     async addListener(listener: Listener) {
         const drive = listener.driveId;
 

package/src/server/types.ts

@@ -20,6 +20,7 @@ import type {
     State
 } from 'document-model/document';
 import { Unsubscribe } from 'nanoevents';
+import { DriveInfo } from '../utils/graphql';
 import { OperationError } from './error';
 import {
     ITransmitter,
@@ -36,6 +37,7 @@ export type RemoteDriveOptions = DocumentDriveLocalState & {
     // TODO make local state optional
     pullFilter?: ListenerFilter;
     pullInterval?: number;
+    expectedDriveInfo?: DriveInfo;
 };
 
 export type CreateDocumentInput = CreateChildDocumentInput;
@@ -138,10 +140,38 @@ export type StrandUpdate = {
     operations: OperationUpdate[];
 };
 
-export type SyncStatus = 'SYNCING' | UpdateStatus;
+export type SyncStatus = 'INITIAL_SYNC' | 'SYNCING' | UpdateStatus;
+
+export type PullSyncStatus = SyncStatus;
+export type PushSyncStatus = SyncStatus;
+
+export type SyncUnitStatusObject = {
+    push?: PushSyncStatus;
+    pull?: PullSyncStatus;
+};
+
+export type AddRemoteDriveStatus =
+    | 'SUCCESS'
+    | 'ERROR'
+    | 'PENDING'
+    | 'ADDING'
+    | 'ALREADY_ADDED';
 
 export interface DriveEvents {
-    syncStatus: (driveId: string, status: SyncStatus, error?: Error) => void;
+    syncStatus: (
+        driveId: string,
+        status: SyncStatus,
+        error?: Error,
+        syncUnitStatus?: SyncUnitStatusObject
+    ) => void;
+    defaultRemoteDrive: (
+        status: AddRemoteDriveStatus,
+        defaultDrives: Map<string, DefaultRemoteDriveInfo>,
+        driveInput: DefaultRemoteDriveInput,
+        driveId?: string,
+        driveName?: string,
+        error?: Error
+    ) => void;
     strandUpdate: (update: StrandUpdate) => void;
     clientStrandsError: (
         driveId: string,
@@ -168,6 +198,45 @@ export type AddOperationOptions = {
     source: StrandUpdateSource;
 };
 
+export type DefaultRemoteDriveInput = {
+    url: string;
+    options: RemoteDriveOptions;
+};
+
+export type DefaultRemoteDriveInfo = DefaultRemoteDriveInput & {
+    status: AddRemoteDriveStatus;
+    metadata?: DriveInfo;
+};
+
+export type RemoveOldRemoteDrivesOption =
+    | {
+          strategy: 'remove-all';
+      }
+    | {
+          strategy: 'preserve-all';
+      }
+    | {
+          strategy: 'remove-by-id';
+          ids: string[];
+      }
+    | {
+          strategy: 'remove-by-url';
+          urls: string[];
+      }
+    | {
+          strategy: 'preserve-by-id';
+          ids: string[];
+      }
+    | {
+          strategy: 'preserve-by-url';
+          urls: string[];
+      };
+
+export type DocumentDriveServerOptions = {
+    defaultRemoteDrives?: Array<DefaultRemoteDriveInput>;
+    removeOldRemoteDrives?: RemoveOldRemoteDrivesOption;
+};
+
 export abstract class BaseDocumentDriveServer {
     /** Public methods **/
     abstract getDrives(): Promise<string[]>;
@@ -380,6 +449,7 @@ export abstract class BaseListenerManager {
     abstract initDrive(drive: DocumentDriveDocument): Promise<void>;
     abstract removeDrive(driveId: DocumentDriveState['id']): Promise<void>;
 
+    abstract driveHasListeners(driveId: string): boolean;
     abstract addListener(listener: Listener): Promise<ITransmitter>;
     abstract removeListener(
         driveId: string,

package/src/storage/browser.ts

@@ -6,7 +6,10 @@ import {
     Operation,
     OperationScope
 } from 'document-model/document';
-import { mergeOperations, type SynchronizationUnitQuery } from '..';
+import { DriveNotFoundError } from '../server/error';
+import { SynchronizationUnitQuery } from '../server/types';
+import { mergeOperations } from '../utils';
+import { migrateDocumentOperationSigatures } from '../utils/migrations';
 import { DocumentDriveStorage, DocumentStorage, IDriveStorage } from './types';
 
 export class BrowserStorage implements IDriveStorage {
@@ -110,7 +113,7 @@ export class BrowserStorage implements IDriveStorage {
             this.buildKey(BrowserStorage.DRIVES_KEY, id)
         );
         if (!drive) {
-            throw new Error(`Drive with id ${id} not found`);
+            throw new DriveNotFoundError(id);
         }
         return drive;
     }
@@ -214,4 +217,28 @@ export class BrowserStorage implements IDriveStorage {
             return acc;
         }, []);
     }
+
+    // migrates all stored operations from legacy signature to signatures array
+    async migrateOperationSignatures() {
+        const drives = await this.getDrives();
+        for (const drive of drives) {
+            await this.migrateDocument(BrowserStorage.DRIVES_KEY, drive);
+
+            const documents = await this.getDocuments(drive);
+            await Promise.all(
+                documents.map(async docId => this.migrateDocument(drive, docId))
+            );
+        }
+    }
+
+    private async migrateDocument(drive: string, id: string) {
+        const document = await this.getDocument(drive, id);
+        const migratedDocument = migrateDocumentOperationSigatures(document);
+        if (migratedDocument !== document) {
+            return (await this.db).setItem(
+                this.buildKey(drive, id),
+                migratedDocument
+            );
+        }
+    }
 }

package/src/storage/filesystem.ts

@@ -17,6 +17,7 @@ import fs from 'fs/promises';
 import stringify from 'json-stringify-deterministic';
 import path from 'path';
 import sanitize from 'sanitize-filename';
+import { DriveNotFoundError } from '../server/error';
 import type { SynchronizationUnitQuery } from '../server/types';
 import { mergeOperations } from '../utils';
 import { DocumentDriveStorage, DocumentStorage, IDriveStorage } from './types';
@@ -199,7 +200,7 @@ export class FilesystemStorage implements IDriveStorage {
                 id
             )) as DocumentDriveStorage;
         } catch {
-            throw new Error(`Drive with id ${id} not found`);
+            throw new DriveNotFoundError(id);
         }
     }
 

package/src/storage/memory.ts

@@ -6,6 +6,7 @@ import {
     Operation,
     OperationScope
 } from 'document-model/document';
+import { DriveNotFoundError } from '../server/error';
 import type { SynchronizationUnitQuery } from '../server/types';
 import { mergeOperations } from '../utils';
 import { DocumentDriveStorage, DocumentStorage, IDriveStorage } from './types';
@@ -31,7 +32,7 @@ export class MemoryStorage implements IDriveStorage {
     async getDocument(driveId: string, id: string) {
         const drive = this.documents[driveId];
         if (!drive) {
-            throw new Error(`Drive with id ${driveId} not found`);
+            throw new DriveNotFoundError(driveId);
         }
         const document = drive[id];
         if (!document) {
@@ -102,7 +103,7 @@ export class MemoryStorage implements IDriveStorage {
 
     async deleteDocument(drive: string, id: string) {
         if (!this.documents[drive]) {
-            throw new Error(`Drive with id ${drive} not found`);
+            throw new DriveNotFoundError(drive);
         }
         delete this.documents[drive]![id];
     }
@@ -114,7 +115,7 @@ export class MemoryStorage implements IDriveStorage {
     async getDrive(id: string) {
         const drive = this.drives[id];
         if (!drive) {
-            throw new Error(`Drive with id ${id} not found`);
+            throw new DriveNotFoundError(id);
         }
         return drive;
     }

package/src/storage/prisma.ts

@@ -19,7 +19,7 @@ import type {
     State
 } from 'document-model/document';
 import { IBackOffOptions, backOff } from 'exponential-backoff';
-import { ConflictOperationError } from '../server/error';
+import { ConflictOperationError, DriveNotFoundError } from '../server/error';
 import type { SynchronizationUnitQuery } from '../server/types';
 import { logger } from '../utils/logger';
 import {
@@ -533,7 +533,7 @@ export class PrismaStorage implements IDriveStorage {
             return doc as DocumentDriveStorage;
         } catch (e) {
             logger.error(e);
-            throw new Error(`Drive with id ${id} not found`);
+            throw new DriveNotFoundError(id);
         }
     }
 
@@ -561,6 +561,13 @@ export class PrismaStorage implements IDriveStorage {
 
         // delete drive document and its operations
         await this.deleteDocument('drives', id);
+
+        // deletes all documents of the drive
+        await this.db.document.deleteMany({
+            where: {
+                driveId: id
+            }
+        });
     }
 
     async getOperationResultingState(
@@ -648,4 +655,22 @@ export class PrismaStorage implements IDriveStorage {
             lastUpdated: new Date(row.lastUpdated).toISOString()
         }));
     }
+
+    // migrates all stored operations from legacy signature to signatures array
+    async migrateOperationSignatures() {
+        const count = await this.db.$executeRaw`
+            UPDATE "Operation"
+            SET context = jsonb_set(
+                context #- '{signer,signature}',  -- Remove the old 'signature' field
+                '{signer,signatures}',            -- Path to the new 'signatures' field
+                CASE
+                    WHEN context->'signer'->>'signature' = '' THEN '[]'::jsonb
+                    ELSE to_jsonb(array[context->'signer'->>'signature'])
+                END
+            )
+            WHERE context->'signer' ? 'signature'  -- Check if the 'signature' key exists
+        `;
+        logger.info(`Migrated ${count} operations`);
+        return;
+    }
 }

package/src/utils/default-drives-manager.ts

@@ -0,0 +1,239 @@
+import {
+    BaseDocumentDriveServer,
+    DefaultRemoteDriveInfo,
+    DocumentDriveServerOptions,
+    DriveEvents,
+    RemoveOldRemoteDrivesOption
+} from '../server';
+import { DriveNotFoundError } from '../server/error';
+import { requestPublicDrive } from './graphql';
+import { logger } from './logger';
+
+export interface IServerDelegateDrivesManager {
+    emit: (...args: Parameters<DriveEvents['defaultRemoteDrive']>) => void;
+}
+
+export class DefaultDrivesManager {
+    private defaultRemoteDrives = new Map<string, DefaultRemoteDriveInfo>();
+    private removeOldRemoteDrivesConfig: RemoveOldRemoteDrivesOption;
+
+    constructor(
+        private server: BaseDocumentDriveServer,
+        private delegate: IServerDelegateDrivesManager,
+        options?: Pick<
+            DocumentDriveServerOptions,
+            'defaultRemoteDrives' | 'removeOldRemoteDrives'
+        >
+    ) {
+        if (options?.defaultRemoteDrives) {
+            for (const defaultDrive of options.defaultRemoteDrives) {
+                this.defaultRemoteDrives.set(defaultDrive.url, {
+                    ...defaultDrive,
+                    status: 'PENDING'
+                });
+            }
+        }
+
+        const strategyFromEnv =
+            process.env.DOCUMENT_DRIVE_OLD_REMOTE_DRIVES_STRATEGY;
+        const urlsFromEnv = process.env.DOCUMENT_DRIVE_OLD_REMOTE_DRIVES_URLS;
+        const idsFromEnv = process.env.DOCUMENT_DRIVE_OLD_REMOTE_DRIVES_IDS;
+
+        const strategy: RemoveOldRemoteDrivesOption['strategy'] =
+            strategyFromEnv !== undefined && strategyFromEnv !== ''
+                ? (strategyFromEnv as RemoveOldRemoteDrivesOption['strategy'])
+                : 'preserve-all';
+
+        const urls =
+            urlsFromEnv !== undefined && urlsFromEnv !== ''
+                ? urlsFromEnv.split(',')
+                : [];
+
+        const ids =
+            idsFromEnv !== undefined && idsFromEnv !== ''
+                ? idsFromEnv.split(',')
+                : [];
+
+        this.removeOldRemoteDrivesConfig = options?.removeOldRemoteDrives || {
+            strategy,
+            urls,
+            ids
+        };
+    }
+
+    getDefaultRemoteDrives() {
+        return this.defaultRemoteDrives;
+    }
+
+    private async deleteDriveById(driveId: string) {
+        try {
+            await this.server.deleteDrive(driveId);
+        } catch (error) {
+            if (!(error instanceof DriveNotFoundError)) {
+                logger.error(error);
+            }
+        }
+    }
+
+    private async preserveDrivesById(
+        drivesIdsToRemove: string[],
+        drives: string[]
+    ) {
+        const getAllDrives = drives.map(driveId =>
+            this.server.getDrive(driveId)
+        );
+
+        const drivesToRemove = (await Promise.all(getAllDrives))
+            .filter(
+                drive =>
+                    drive.state.local.listeners.length > 0 ||
+                    drive.state.local.triggers.length > 0
+            )
+            .filter(
+                drive => !drivesIdsToRemove.includes(drive.state.global.id)
+            );
+
+        const driveIds = drivesToRemove.map(drive => drive.state.global.id);
+        await this.removeDrivesById(driveIds);
+    }
+
+    private async removeDrivesById(driveIds: string[]) {
+        for (const driveId of driveIds) {
+            await this.deleteDriveById(driveId);
+        }
+    }
+
+    async removeOldremoteDrives() {
+        const driveids = await this.server.getDrives();
+
+        switch (this.removeOldRemoteDrivesConfig.strategy) {
+            case 'preserve-by-id': {
+                await this.preserveDrivesById(
+                    this.removeOldRemoteDrivesConfig.ids,
+                    driveids
+                );
+                break;
+            }
+            case 'preserve-by-url': {
+                const getDrivesInfo = this.removeOldRemoteDrivesConfig.urls.map(
+                    url => requestPublicDrive(url)
+                );
+
+                const drivesIdsToPreserve = (
+                    await Promise.all(getDrivesInfo)
+                ).map(driveInfo => driveInfo.id);
+
+                await this.preserveDrivesById(drivesIdsToPreserve, driveids);
+                break;
+            }
+            case 'remove-by-id': {
+                const drivesIdsToRemove =
+                    this.removeOldRemoteDrivesConfig.ids.filter(driveId =>
+                        driveids.includes(driveId)
+                    );
+
+                await this.removeDrivesById(drivesIdsToRemove);
+                break;
+            }
+            case 'remove-by-url': {
+                const getDrivesInfo = this.removeOldRemoteDrivesConfig.urls.map(
+                    driveUrl => requestPublicDrive(driveUrl)
+                );
+                const drivesInfo = await Promise.all(getDrivesInfo);
+
+                const drivesIdsToRemove = drivesInfo
+                    .map(driveInfo => driveInfo.id)
+                    .filter(driveId => driveids.includes(driveId));
+
+                await this.removeDrivesById(drivesIdsToRemove);
+                break;
+            }
+            case 'remove-all': {
+                const getDrives = driveids.map(driveId =>
+                    this.server.getDrive(driveId)
+                );
+                const drives = await Promise.all(getDrives);
+                const drivesToRemove = drives
+                    .filter(
+                        drive =>
+                            drive.state.local.listeners.length > 0 ||
+                            drive.state.local.triggers.length > 0
+                    )
+                    .map(drive => drive.state.global.id);
+
+                await this.removeDrivesById(drivesToRemove);
+                break;
+            }
+        }
+    }
+
+    async initializeDefaultRemoteDrives() {
+        const drives = await this.server.getDrives();
+
+        for (const remoteDrive of this.defaultRemoteDrives.values()) {
+            let remoteDriveInfo = { ...remoteDrive };
+
+            try {
+                const driveInfo = await requestPublicDrive(remoteDrive.url);
+
+                remoteDriveInfo = { ...remoteDrive, metadata: driveInfo };
+
+                this.defaultRemoteDrives.set(remoteDrive.url, remoteDriveInfo);
+
+                if (drives.includes(driveInfo.id)) {
+                    remoteDriveInfo.status = 'ALREADY_ADDED';
+
+                    this.defaultRemoteDrives.set(
+                        remoteDrive.url,
+                        remoteDriveInfo
+                    );
+                    this.delegate.emit(
+                        'ALREADY_ADDED',
+                        this.defaultRemoteDrives,
+                        remoteDriveInfo,
+                        driveInfo.id,
+                        driveInfo.name
+                    );
+                    continue;
+                }
+
+                remoteDriveInfo.status = 'ADDING';
+
+                this.defaultRemoteDrives.set(remoteDrive.url, remoteDriveInfo);
+                this.delegate.emit(
+                    'ADDING',
+                    this.defaultRemoteDrives,
+                    remoteDriveInfo
+                );
+
+                await this.server.addRemoteDrive(remoteDrive.url, {
+                    ...remoteDrive.options,
+                    expectedDriveInfo: driveInfo
+                });
+
+                remoteDriveInfo.status = 'SUCCESS';
+
+                this.defaultRemoteDrives.set(remoteDrive.url, remoteDriveInfo);
+                this.delegate.emit(
+                    'SUCCESS',
+                    this.defaultRemoteDrives,
+                    remoteDriveInfo,
+                    driveInfo.id,
+                    driveInfo.name
+                );
+            } catch (error) {
+                remoteDriveInfo.status = 'ERROR';
+
+                this.defaultRemoteDrives.set(remoteDrive.url, remoteDriveInfo);
+                this.delegate.emit(
+                    'ERROR',
+                    this.defaultRemoteDrives,
+                    remoteDriveInfo,
+                    undefined,
+                    undefined,
+                    error as Error
+                );
+            }
+        }
+    }
+}

package/src/utils/migrations.ts

@@ -0,0 +1,58 @@
+import {
+    Action,
+    Document,
+    DocumentOperations,
+    Operation,
+    OperationScope
+} from 'document-model/document';
+import { DocumentStorage } from '../storage/types';
+
+export function migrateDocumentOperationSigatures<D extends Document>(
+    document: DocumentStorage<D>
+): DocumentStorage<D> | undefined {
+    let legacy = false;
+    const operations = Object.entries(document.operations).reduce<
+        DocumentOperations<Action>
+    >(
+        (acc, [key, operations]) => {
+            const scope = key as unknown as OperationScope;
+            for (const op of operations) {
+                const newOp = migrateLegacyOperationSignature(op);
+                acc[scope].push(newOp);
+                if (newOp !== op) {
+                    legacy = true;
+                }
+            }
+            return acc;
+        },
+        { global: [], local: [] }
+    );
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+    return legacy ? { ...document, operations } : document;
+}
+
+export function migrateLegacyOperationSignature<A extends Action>(
+    operation: Operation<A>
+): Operation<A> {
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+    if (!operation.context?.signer || operation.context.signer.signatures) {
+        return operation;
+    }
+    const { signer } = operation.context;
+    if ('signature' in signer) {
+        const signature = signer.signature as string | undefined;
+        return {
+            ...operation,
+            context: {
+                ...operation.context,
+                signer: {
+                    user: signer.user,
+                    app: signer.app,
+                    signatures: signature?.length ? [signature] : []
+                }
+            }
+        };
+    } else {
+        return operation;
+    }
+}