document-drive 1.19.1 → 1.20.1

package/dist/src/storage/sequelize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sequelize.d.ts","sourceRoot":"","sources":["../../../src/storage/sequelize.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,mBAAmB,EACnB,qBAAqB,EAGtB,MAAM,iCAAiC,CAAC;AACzC,OAAO,EAAE,wBAAwB,EAAE,MAAM,eAAe,CAAC;AACzD,OAAO,EAEL,eAAe,EACf,cAAc,EAEd,SAAS,EAET,UAAU,EACX,MAAM,gBAAgB,CAAC;AACxB,OAAO,EAAa,OAAO,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AAC1D,OAAO,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAE3C,qBAAa,gBAAiB,YAAW,aAAa;IACpD,OAAO,CAAC,EAAE,CAAY;gBAEV,OAAO,EAAE,OAAO;IAIrB,UAAU;IAuGX,WAAW,CAAC,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,qBAAqB,GAAG,OAAO,CAAC,IAAI,CAAC;IAKpE,kBAAkB,CACtB,EAAE,EAAE,MAAM,EACV,UAAU,EAAE,SAAS,CAAC,mBAAmB,CAAC,EAAE,EAC5C,MAAM,EAAE,cAAc,GACrB,OAAO,CAAC,IAAI,CAAC;IAGV,cAAc,CAClB,KAAK,EAAE,MAAM,EACb,EAAE,EAAE,MAAM,EACV,QAAQ,EAAE,UAAU,GACnB,OAAO,CAAC,IAAI,CAAC;IAiBV,qBAAqB,CACzB,KAAK,EAAE,MAAM,EACb,EAAE,EAAE,MAAM,EACV,UAAU,EAAE,SAAS,EAAE,EACvB,MAAM,EAAE,cAAc,GACrB,OAAO,CAAC,IAAI,CAAC;IAyEV,gCAAgC,CACpC,OAAO,EAAE,MAAM,EACf,UAAU,EAAE,MAAM,EAClB,SAAS,EAAE,SAAS,EACpB,WAAW,EAAE,eAAe,EAAE;IAuB1B,YAAY,CAAC,KAAK,EAAE,MAAM;IAoB1B,mBAAmB,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAelE,WAAW,CAAC,SAAS,SAAS,UAAU,EAC5C,OAAO,EAAE,MAAM,EACf,EAAE,EAAE,MAAM,GACT,OAAO,CAAC,SAAS,CAAC;IA6Ef,cAAc,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM;IAcxC,SAAS;IAIT,QAAQ,CAAC,EAAE,EAAE,MAAM;IAKnB,cAAc,CAAC,IAAI,EAAE,MAAM;IAoB3B,WAAW,CAAC,EAAE,EAAE,MAAM;IAwBtB,+BAA+B,CACnC,KAAK,EAAE,wBAAwB,EAAE,GAChC,OAAO,CACR;QACE,OAAO,EAAE,MAAM,CAAC;QAChB,UAAU,EAAE,MAAM,CAAC;QACnB,KAAK,EAAE,MAAM,CAAC;QACd,MAAM,EAAE,MAAM,CAAC;QACf,WAAW,EAAE,MAAM,CAAC;QACpB,QAAQ,EAAE,MAAM,CAAC;KAClB,EAAE,CACJ;CA2CF"}

package/dist/src/storage/sequelize.js

@@ -0,0 +1,373 @@
+import { DataTypes, Sequelize } from "sequelize";
+export class SequelizeStorage {
+    db;
+    constructor(options) {
+        this.db = new Sequelize(options);
+    }
+    syncModels() {
+        const Drive = this.db.define("drive", {
+            slug: {
+                type: DataTypes.STRING,
+                primaryKey: true,
+            },
+            id: DataTypes.STRING,
+        });
+        const Document = this.db.define("document", {
+            id: {
+                type: DataTypes.STRING,
+                primaryKey: true,
+            },
+            driveId: {
+                type: DataTypes.STRING,
+                primaryKey: true,
+            },
+            name: DataTypes.STRING,
+            documentType: DataTypes.STRING,
+            initialState: DataTypes.JSON,
+            lastModified: DataTypes.DATE,
+            revision: DataTypes.JSON,
+        });
+        const Operation = this.db.define("operation", {
+            driveId: {
+                type: DataTypes.STRING,
+                primaryKey: true,
+                unique: "unique_operation",
+            },
+            documentId: {
+                type: DataTypes.STRING,
+                primaryKey: true,
+                unique: "unique_operation",
+            },
+            hash: DataTypes.STRING,
+            index: {
+                type: DataTypes.INTEGER,
+                primaryKey: true,
+                unique: "unique_operation",
+            },
+            input: DataTypes.JSON,
+            timestamp: DataTypes.DATE,
+            type: DataTypes.STRING,
+            scope: {
+                type: DataTypes.STRING,
+                primaryKey: true,
+                unique: "unique_operation",
+            },
+            branch: {
+                type: DataTypes.STRING,
+                primaryKey: true,
+                unique: "unique_operation",
+            },
+            skip: {
+                type: DataTypes.INTEGER,
+                defaultValue: 0,
+            },
+        });
+        const Attachment = this.db.define("attachment", {
+            driveId: {
+                type: DataTypes.STRING,
+                primaryKey: true,
+            },
+            documentId: {
+                type: DataTypes.STRING,
+                primaryKey: true,
+            },
+            scope: {
+                type: DataTypes.STRING,
+                primaryKey: true,
+            },
+            branch: {
+                type: DataTypes.STRING,
+                primaryKey: true,
+            },
+            index: {
+                type: DataTypes.STRING,
+                primaryKey: true,
+            },
+            hash: {
+                type: DataTypes.STRING,
+                primaryKey: true,
+            },
+            mimeType: DataTypes.STRING,
+            fileName: DataTypes.STRING,
+            extension: DataTypes.STRING,
+            data: DataTypes.BLOB,
+        });
+        Operation.hasMany(Attachment, {
+            onDelete: "CASCADE",
+        });
+        Attachment.belongsTo(Operation);
+        Document.hasMany(Operation, {
+            onDelete: "CASCADE",
+        });
+        Operation.belongsTo(Document);
+        return this.db.sync({ force: true });
+    }
+    async createDrive(id, drive) {
+        await this.createDocument("drives", id, drive);
+        const Drive = this.db.models.drive;
+        await Drive.upsert({ id, slug: drive.initialState.state.global.slug });
+    }
+    async addDriveOperations(id, operations, header) {
+        await this.addDocumentOperations("drives", id, operations, header);
+    }
+    async createDocument(drive, id, document) {
+        const Document = this.db.models.document;
+        if (!Document) {
+            throw new Error("Document model not found");
+        }
+        await Document.create({
+            id: id,
+            driveId: drive,
+            name: document.name,
+            documentType: document.documentType,
+            initialState: document.initialState,
+            lastModified: document.lastModified,
+            revision: document.revision,
+        });
+    }
+    async addDocumentOperations(drive, id, operations, header) {
+        const document = await this.getDocument(drive, id);
+        if (!document) {
+            throw new Error(`Document with id ${id} not found`);
+        }
+        const Operation = this.db.models.operation;
+        if (!Operation) {
+            throw new Error("Operation model not found");
+        }
+        await Operation.bulkCreate(operations.map((op) => ({
+            driveId: drive,
+            documentId: id,
+            hash: op.hash,
+            index: op.index,
+            input: op.input,
+            timestamp: op.timestamp,
+            type: op.type,
+            scope: op.scope,
+            branch: "main",
+            opId: op.id,
+        })));
+        const attachments = operations.reduce((acc, op) => {
+            if (op.attachments?.length) {
+                return acc.concat(op.attachments.map((attachment) => ({
+                    driveId: drive,
+                    documentId: id,
+                    scope: op.scope,
+                    branch: "main",
+                    index: op.index,
+                    mimeType: attachment.mimeType,
+                    fileName: attachment.fileName,
+                    extension: attachment.extension,
+                    data: attachment.data,
+                    hash: attachment.hash,
+                })));
+            }
+            return acc;
+        }, []);
+        if (attachments.length) {
+            const Attachment = this.db.models.attachment;
+            if (!Attachment) {
+                throw new Error("Attachment model not found");
+            }
+            await Attachment.bulkCreate(attachments);
+        }
+        const Document = this.db.models.document;
+        if (!Document) {
+            throw new Error("Document model not found");
+        }
+        await Document.update({
+            lastModified: header.lastModified,
+            revision: header.revision,
+        }, {
+            where: {
+                id: id,
+                driveId: drive,
+            },
+        });
+    }
+    async _addDocumentOperationAttachments(driveId, documentId, operation, attachments) {
+        const Attachment = this.db.models.attachment;
+        if (!Attachment) {
+            throw new Error("Attachment model not found");
+        }
+        return Attachment.bulkCreate(attachments.map((attachment) => ({
+            driveId: driveId,
+            documentId: documentId,
+            scope: operation.scope,
+            branch: "main",
+            index: operation.index,
+            mimeType: attachment.mimeType,
+            fileName: attachment.fileName,
+            extension: attachment.extension,
+            data: attachment.data,
+            hash: attachment.hash,
+        })));
+    }
+    async getDocuments(drive) {
+        const Document = this.db.models.document;
+        if (!Document) {
+            throw new Error("Document model not found");
+        }
+        const result = await Document.findAll({
+            attributes: ["id"],
+            where: {
+                driveId: drive,
+            },
+        });
+        const ids = result.map((e) => {
+            const { id } = e.dataValues;
+            return id;
+        });
+        return ids;
+    }
+    async checkDocumentExists(driveId, id) {
+        const Document = this.db.models.document;
+        if (!Document) {
+            throw new Error("Document model not found");
+        }
+        const count = await Document.count({
+            where: {
+                id: id,
+                driveId: driveId,
+            },
+        });
+        return count > 0;
+    }
+    async getDocument(driveId, id) {
+        const documentFromDb = this.db.models.document;
+        if (!documentFromDb) {
+            throw new Error("Document model not found");
+        }
+        const entry = await documentFromDb.findOne({
+            where: {
+                id: id,
+                driveId: driveId,
+            },
+            include: [
+                {
+                    model: this.db.models.operation,
+                    as: "operations",
+                },
+            ],
+        });
+        if (entry === null) {
+            throw new Error(`Document with id ${id} not found`);
+        }
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+        const document = entry.dataValues;
+        const operationFromDb = this.db.models.operation;
+        if (!operationFromDb) {
+            throw new Error("Operation model not found");
+        }
+        const operations = document.operations.map((op) => ({
+            hash: op.hash,
+            index: op.index,
+            timestamp: new Date(op.timestamp).toISOString(),
+            input: op.input,
+            type: op.type,
+            scope: op.scope,
+            id: op.opId,
+            skip: op.skip,
+            // attachments: fileRegistry
+        }));
+        const doc = {
+            created: document.createdAt.toISOString(),
+            name: document.name ? document.name : "",
+            documentType: document.documentType,
+            initialState: document.initialState,
+            lastModified: document.updatedAt.toISOString(),
+            operations: {
+                global: operations.filter((op) => op.scope === "global"),
+                local: operations.filter((op) => op.scope === "local"),
+            },
+            revision: document.revision,
+        };
+        return doc;
+    }
+    async deleteDocument(drive, id) {
+        const documentFromDb = this.db.models.document;
+        if (!documentFromDb) {
+            throw new Error("Document model not found");
+        }
+        await documentFromDb.destroy({
+            where: {
+                id: id,
+                driveId: drive,
+            },
+        });
+    }
+    async getDrives() {
+        return this.getDocuments("drives");
+    }
+    async getDrive(id) {
+        const doc = await this.getDocument("drives", id);
+        return doc;
+    }
+    async getDriveBySlug(slug) {
+        const driveFromDb = this.db.models.drive;
+        if (!driveFromDb) {
+            throw new Error("Drive model not found");
+        }
+        const driveEntity = await driveFromDb.findOne({
+            where: {
+                slug,
+            },
+        });
+        if (!driveEntity) {
+            throw new Error(`Drive with slug ${slug} not found`);
+        }
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument, @typescript-eslint/no-unsafe-member-access
+        return this.getDrive(driveEntity.dataValues.id);
+    }
+    async deleteDrive(id) {
+        await this.deleteDocument("drives", id);
+        const documentFromDb = this.db.models.document;
+        if (!documentFromDb) {
+            throw new Error("Document model not found");
+        }
+        await documentFromDb.destroy({
+            where: {
+                driveId: id,
+            },
+        });
+        const driveFromDb = this.db.models.drive;
+        if (driveFromDb) {
+            await driveFromDb.destroy({
+                where: {
+                    id: id,
+                },
+            });
+        }
+    }
+    async getSynchronizationUnitsRevision(units) {
+        const results = await Promise.allSettled(units.map(async (unit) => {
+            try {
+                const document = await (unit.documentId
+                    ? this.getDocument(unit.driveId, unit.documentId)
+                    : this.getDrive(unit.driveId));
+                if (!document) {
+                    return undefined;
+                }
+                const operation = document.operations[unit.scope].at(-1);
+                if (operation) {
+                    return {
+                        driveId: unit.driveId,
+                        documentId: unit.documentId,
+                        scope: unit.scope,
+                        branch: unit.branch,
+                        lastUpdated: operation.timestamp,
+                        revision: operation.index,
+                    };
+                }
+            }
+            catch {
+                return undefined;
+            }
+        }));
+        return results.reduce((acc, curr) => {
+            if (curr.status === "fulfilled" && curr.value !== undefined) {
+                acc.push(curr.value);
+            }
+            return acc;
+        }, []);
+    }
+}

package/dist/src/storage/types.d.ts

@@ -0,0 +1,43 @@
+import { DocumentDriveDocument } from "#drive-document-model/gen/types";
+import { SynchronizationUnitQuery } from "#server/types";
+import type { DocumentHeader, Operation, OperationFromDocument, OperationsFromDocument, PHDocument } from "document-model";
+export interface IStorageDelegate {
+    getCachedOperations<TDocument extends PHDocument = PHDocument>(drive: string, id: string): Promise<OperationsFromDocument<TDocument> | undefined>;
+}
+export interface IStorage {
+    checkDocumentExists(drive: string, id: string): Promise<boolean>;
+    getDocuments: (drive: string) => Promise<string[]>;
+    getDocument<TDocument extends PHDocument>(drive: string, id: string): Promise<TDocument>;
+    createDocument(drive: string, id: string, document: PHDocument): Promise<void>;
+    addDocumentOperations<TDocument extends PHDocument>(drive: string, id: string, operations: OperationFromDocument<TDocument>[], header: DocumentHeader): Promise<void>;
+    addDocumentOperationsWithTransaction?<TDocument extends PHDocument>(drive: string, id: string, callback: (document: TDocument) => Promise<{
+        operations: OperationFromDocument<TDocument>[];
+        header: DocumentHeader;
+    }>): Promise<void>;
+    deleteDocument(drive: string, id: string): Promise<void>;
+    getOperationResultingState?(drive: string, id: string, index: number, scope: string, branch: string): Promise<string | undefined>;
+    setStorageDelegate?(delegate: IStorageDelegate): void;
+    getSynchronizationUnitsRevision(units: SynchronizationUnitQuery[]): Promise<{
+        driveId: string;
+        documentId: string;
+        scope: string;
+        branch: string;
+        lastUpdated: string;
+        revision: number;
+    }[]>;
+}
+export interface IDriveStorage extends IStorage {
+    getDrives(): Promise<string[]>;
+    getDrive(id: string): Promise<DocumentDriveDocument>;
+    getDriveBySlug(slug: string): Promise<DocumentDriveDocument>;
+    createDrive(id: string, drive: DocumentDriveDocument): Promise<void>;
+    deleteDrive(id: string): Promise<void>;
+    clearStorage?(): Promise<void>;
+    addDriveOperations(id: string, operations: Operation[], header: DocumentHeader): Promise<void>;
+    addDriveOperationsWithTransaction?(drive: string, callback: (document: DocumentDriveDocument) => Promise<{
+        operations: Operation[];
+        header: DocumentHeader;
+    }>): Promise<void>;
+    getDriveOperationResultingState?(drive: string, index: number, scope: string, branch: string): Promise<string | undefined>;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/src/storage/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/storage/types.ts"],"names":[],"mappings":"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"}

package/dist/src/storage/types.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,29 @@
+import { IReadModeDriveServer } from "#read-mode/types";
+import { DefaultRemoteDriveInfo, DocumentDriveServerOptions, DriveEvents, IBaseDocumentDriveServer, RemoteDriveAccessLevel } from "#server/types";
+export interface IServerDelegateDrivesManager {
+    emit: (...args: Parameters<DriveEvents["defaultRemoteDrive"]>) => void;
+    detachDrive: (driveId: string) => Promise<void>;
+}
+export interface IDefaultDrivesManager {
+    initializeDefaultRemoteDrives(): Promise<void>;
+    getDefaultRemoteDrives(): Map<string, DefaultRemoteDriveInfo>;
+    setDefaultDriveAccessLevel(url: string, level: RemoteDriveAccessLevel): Promise<void>;
+    setAllDefaultDrivesAccessLevel(level: RemoteDriveAccessLevel): Promise<void>;
+}
+export declare class DefaultDrivesManager implements IDefaultDrivesManager {
+    private server;
+    private delegate;
+    private defaultRemoteDrives;
+    private removeOldRemoteDrivesConfig;
+    constructor(server: IBaseDocumentDriveServer | (IBaseDocumentDriveServer & IReadModeDriveServer), delegate: IServerDelegateDrivesManager, options?: Pick<DocumentDriveServerOptions, "defaultDrives">);
+    getDefaultRemoteDrives(): Map<string, DefaultRemoteDriveInfo>;
+    private deleteDriveById;
+    private preserveDrivesById;
+    private removeDrivesById;
+    private detachDrivesById;
+    removeOldremoteDrives(): Promise<void>;
+    setAllDefaultDrivesAccessLevel(level: RemoteDriveAccessLevel): Promise<void>;
+    setDefaultDriveAccessLevel(url: string, level: RemoteDriveAccessLevel): Promise<void>;
+    initializeDefaultRemoteDrives(defaultDrives?: DefaultRemoteDriveInfo[]): Promise<void>;
+}
+//# sourceMappingURL=default-drives-manager.d.ts.map

package/dist/src/utils/default-drives-manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"default-drives-manager.d.ts","sourceRoot":"","sources":["../../../src/utils/default-drives-manager.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAC;AAExD,OAAO,EACL,sBAAsB,EACtB,0BAA0B,EAC1B,WAAW,EACX,wBAAwB,EACxB,sBAAsB,EAGvB,MAAM,eAAe,CAAC;AAIvB,MAAM,WAAW,4BAA4B;IAC3C,IAAI,EAAE,CAAC,GAAG,IAAI,EAAE,UAAU,CAAC,WAAW,CAAC,oBAAoB,CAAC,CAAC,KAAK,IAAI,CAAC;IACvE,WAAW,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;CACjD;AAMD,MAAM,WAAW,qBAAqB;IACpC,6BAA6B,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IAC/C,sBAAsB,IAAI,GAAG,CAAC,MAAM,EAAE,sBAAsB,CAAC,CAAC;IAC9D,0BAA0B,CACxB,GAAG,EAAE,MAAM,EACX,KAAK,EAAE,sBAAsB,GAC5B,OAAO,CAAC,IAAI,CAAC,CAAC;IACjB,8BAA8B,CAAC,KAAK,EAAE,sBAAsB,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CAC9E;AAED,qBAAa,oBAAqB,YAAW,qBAAqB;IAK9D,OAAO,CAAC,MAAM;IAGd,OAAO,CAAC,QAAQ;IAPlB,OAAO,CAAC,mBAAmB,CAA6C;IACxE,OAAO,CAAC,2BAA2B,CAA8B;gBAGvD,MAAM,EACV,wBAAwB,GACxB,CAAC,wBAAwB,GAAG,oBAAoB,CAAC,EAC7C,QAAQ,EAAE,4BAA4B,EAC9C,OAAO,CAAC,EAAE,IAAI,CAAC,0BAA0B,EAAE,eAAe,CAAC;IAiB7D,sBAAsB;YAQR,eAAe;YAUf,kBAAkB;YAwBlB,gBAAgB;YAMhB,gBAAgB;IAQxB,qBAAqB;IA0GrB,8BAA8B,CAAC,KAAK,EAAE,sBAAsB;IAO5D,0BAA0B,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,sBAAsB;IAYrE,6BAA6B,CACjC,aAAa,GAAE,sBAAsB,EAEpC;CAiGJ"}

package/dist/src/utils/default-drives-manager.js

@@ -0,0 +1,208 @@
+import { DriveNotFoundError } from "#server/error";
+import { requestPublicDrive } from "./graphql.js";
+import { logger } from "./logger.js";
+function isReadModeDriveServer(obj) {
+    return typeof obj.getReadDrives === "function";
+}
+export class DefaultDrivesManager {
+    server;
+    delegate;
+    defaultRemoteDrives = new Map();
+    removeOldRemoteDrivesConfig;
+    constructor(server, delegate, options) {
+        this.server = server;
+        this.delegate = delegate;
+        if (options?.defaultDrives.remoteDrives) {
+            for (const defaultDrive of options.defaultDrives.remoteDrives) {
+                this.defaultRemoteDrives.set(defaultDrive.url, {
+                    ...defaultDrive,
+                    status: "PENDING",
+                });
+            }
+        }
+        this.removeOldRemoteDrivesConfig = options?.defaultDrives
+            .removeOldRemoteDrives || {
+            strategy: "preserve-all",
+        };
+    }
+    getDefaultRemoteDrives() {
+        return new Map(JSON.parse(JSON.stringify(Array.from(this.defaultRemoteDrives))));
+    }
+    async deleteDriveById(driveId) {
+        try {
+            await this.server.deleteDrive(driveId);
+        }
+        catch (error) {
+            if (!(error instanceof DriveNotFoundError)) {
+                logger.error(error);
+            }
+        }
+    }
+    async preserveDrivesById(driveIdsToPreserve, drives, removeStrategy = "detach") {
+        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) => !driveIdsToPreserve.includes(drive.state.global.id));
+        const driveIds = drivesToRemove.map((drive) => drive.state.global.id);
+        if (removeStrategy === "detach") {
+            await this.detachDrivesById(driveIds);
+        }
+        else {
+            await this.removeDrivesById(driveIds);
+        }
+    }
+    async removeDrivesById(driveIds) {
+        for (const driveId of driveIds) {
+            await this.deleteDriveById(driveId);
+        }
+    }
+    async detachDrivesById(driveIds) {
+        const detachDrivesPromises = driveIds.map((driveId) => this.delegate.detachDrive(driveId));
+        await Promise.all(detachDrivesPromises);
+    }
+    async removeOldremoteDrives() {
+        const driveids = await this.server.getDrives();
+        switch (this.removeOldRemoteDrivesConfig.strategy) {
+            case "preserve-by-id-and-detach":
+            case "preserve-by-id": {
+                const detach = this.removeOldRemoteDrivesConfig.strategy ===
+                    "preserve-by-id-and-detach"
+                    ? "detach"
+                    : "remove";
+                await this.preserveDrivesById(this.removeOldRemoteDrivesConfig.ids, driveids, detach);
+                break;
+            }
+            case "preserve-by-url-and-detach":
+            case "preserve-by-url": {
+                const detach = this.removeOldRemoteDrivesConfig.strategy ===
+                    "preserve-by-url-and-detach"
+                    ? "detach"
+                    : "remove";
+                const getDrivesInfo = this.removeOldRemoteDrivesConfig.urls.map((url) => requestPublicDrive(url));
+                const drivesIdsToPreserve = (await Promise.all(getDrivesInfo)).map((driveInfo) => driveInfo.id);
+                await this.preserveDrivesById(drivesIdsToPreserve, driveids, detach);
+                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;
+            }
+            case "detach-by-id": {
+                const drivesIdsToRemove = this.removeOldRemoteDrivesConfig.ids.filter((driveId) => driveids.includes(driveId));
+                const detachDrivesPromises = drivesIdsToRemove.map((driveId) => this.delegate.detachDrive(driveId));
+                await Promise.all(detachDrivesPromises);
+                break;
+            }
+            case "detach-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));
+                const detachDrivesPromises = drivesIdsToRemove.map((driveId) => this.delegate.detachDrive(driveId));
+                await Promise.all(detachDrivesPromises);
+                break;
+            }
+        }
+    }
+    async setAllDefaultDrivesAccessLevel(level) {
+        const drives = this.defaultRemoteDrives.values();
+        for (const drive of drives) {
+            await this.setDefaultDriveAccessLevel(drive.url, level);
+        }
+    }
+    async setDefaultDriveAccessLevel(url, level) {
+        const drive = this.defaultRemoteDrives.get(url);
+        if (drive && drive.options.accessLevel !== level) {
+            const newDriveValue = {
+                ...drive,
+                options: { ...drive.options, accessLevel: level },
+            };
+            this.defaultRemoteDrives.set(url, newDriveValue);
+            await this.initializeDefaultRemoteDrives([newDriveValue]);
+        }
+    }
+    async initializeDefaultRemoteDrives(defaultDrives = Array.from(this.defaultRemoteDrives.values())) {
+        const drives = await this.server.getDrives();
+        const readServer = isReadModeDriveServer(this.server)
+            ? this.server
+            : undefined;
+        const readDrives = await readServer?.getReadDrives();
+        for (const remoteDrive of defaultDrives) {
+            let remoteDriveInfo = { ...remoteDrive };
+            try {
+                const driveInfo = remoteDrive.metadata ?? (await requestPublicDrive(remoteDrive.url));
+                remoteDriveInfo = { ...remoteDrive, metadata: driveInfo };
+                this.defaultRemoteDrives.set(remoteDrive.url, remoteDriveInfo);
+                const driveIsAdded = drives.includes(driveInfo.id);
+                const readDriveIsAdded = readDrives?.includes(driveInfo.id);
+                const hasAccessLevel = remoteDrive.options.accessLevel !== undefined;
+                const readMode = readServer && remoteDrive.options.accessLevel === "READ";
+                const isAdded = readMode ? readDriveIsAdded : driveIsAdded;
+                // if the read mode has changed then existing drives
+                // in the previous mode should be deleted
+                const driveToDelete = hasAccessLevel && (readMode ? driveIsAdded : readDriveIsAdded);
+                if (driveToDelete) {
+                    try {
+                        await (readMode
+                            ? this.server.deleteDrive(driveInfo.id)
+                            : readServer?.deleteReadDrive(driveInfo.id));
+                    }
+                    catch (e) {
+                        logger.error(e);
+                    }
+                }
+                if (isAdded) {
+                    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);
+                if ((!hasAccessLevel && readServer) || readMode) {
+                    await readServer.addReadDrive(remoteDrive.url, {
+                        ...remoteDrive.options,
+                        expectedDriveInfo: driveInfo,
+                    });
+                }
+                else {
+                    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);
+            }
+        }
+    }
+}