document-drive 1.19.0 → 1.20.0

package/dist/src/server/utils.js

@@ -0,0 +1,47 @@
+export function buildRevisionsFilter(strands, driveId, documentId) {
+    return strands.reduce((acc, s) => {
+        if (!(s.driveId === driveId && s.documentId === documentId)) {
+            return acc;
+        }
+        acc[s.scope] = s.operations[s.operations.length - 1]?.index ?? -1;
+        return acc;
+    }, {});
+}
+export function buildDocumentRevisionsFilter(document) {
+    return Object.entries(document.operations).reduce((acc, [scope, operations]) => {
+        acc[scope] = operations.at(-1)?.index ?? -1;
+        return acc;
+    }, {});
+}
+export function filterOperationsByRevision(operations, revisions) {
+    if (!revisions) {
+        return operations;
+    }
+    return Object.keys(operations).reduce((acc, scope) => {
+        const revision = revisions[scope];
+        if (revision !== undefined) {
+            acc[scope] = operations[scope].filter((op) => op.index <= revision);
+        }
+        return acc;
+    }, { global: [], local: [] });
+}
+export function isAtRevision(document, revisions) {
+    return (!revisions ||
+        Object.entries(revisions).find(([scope, revision]) => {
+            const operation = document.operations[scope].at(-1);
+            if (revision === -1) {
+                return operation !== undefined;
+            }
+            return operation?.index !== revision;
+        }) === undefined);
+}
+export function isAfterRevision(document, revisions) {
+    return (!revisions ||
+        Object.entries(revisions).every(([scope, revision]) => {
+            const operation = document.operations[scope].at(-1);
+            if (revision === -1) {
+                return operation !== undefined;
+            }
+            return operation && operation.index > revision;
+        }));
+}

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

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

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

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

package/dist/src/storage/base.js

@@ -0,0 +1,4 @@
+class BaseStorage {
+}
+export class BaseDriveStorage extends BaseStorage {
+}

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

@@ -0,0 +1,36 @@
+import { DocumentDriveAction, DocumentDriveDocument } from "#drive-document-model/gen/types";
+import { SynchronizationUnitQuery } from "#server/types";
+import type { DocumentHeader, Operation, PHDocument } from "document-model";
+import { IDriveStorage } from "./types.js";
+export declare class BrowserStorage implements IDriveStorage {
+    private db;
+    static DBName: string;
+    static SEP: string;
+    static DRIVES_KEY: string;
+    constructor(namespace?: string);
+    buildKey(...args: string[]): string;
+    checkDocumentExists(drive: string, id: string): Promise<boolean>;
+    getDocuments(drive: string): Promise<string[]>;
+    getDocument<TDocument extends PHDocument>(driveId: string, id: string): Promise<TDocument>;
+    createDocument(drive: string, id: string, document: PHDocument): Promise<void>;
+    deleteDocument(drive: string, id: string): Promise<void>;
+    clearStorage(): Promise<void>;
+    addDocumentOperations(drive: string, id: string, operations: Operation[], header: DocumentHeader): Promise<void>;
+    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>;
+    addDriveOperations(id: string, operations: Operation<DocumentDriveAction>[], header: DocumentHeader): Promise<void>;
+    getSynchronizationUnitsRevision(units: SynchronizationUnitQuery[]): Promise<{
+        driveId: string;
+        documentId: string;
+        scope: string;
+        branch: string;
+        lastUpdated: string;
+        revision: number;
+    }[]>;
+    migrateOperationSignatures(): Promise<void>;
+    private migrateDocument;
+}
+//# sourceMappingURL=browser.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"browser.d.ts","sourceRoot":"","sources":["../../../src/storage/browser.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,mBAAmB,EACnB,qBAAqB,EACtB,MAAM,iCAAiC,CAAC;AAEzC,OAAO,EAAE,wBAAwB,EAAE,MAAM,eAAe,CAAC;AAGzD,OAAO,KAAK,EACV,cAAc,EACd,SAAS,EAET,UAAU,EACX,MAAM,gBAAgB,CAAC;AAExB,OAAO,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAE3C,qBAAa,cAAe,YAAW,aAAa;IAClD,OAAO,CAAC,EAAE,CAAuB;IAEjC,MAAM,CAAC,MAAM,SAAqB;IAClC,MAAM,CAAC,GAAG,SAAO;IACjB,MAAM,CAAC,UAAU,SAAY;gBAEjB,SAAS,CAAC,EAAE,MAAM;IAU9B,QAAQ,CAAC,GAAG,IAAI,EAAE,MAAM,EAAE;IAIpB,mBAAmB,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAOhE,YAAY,CAAC,KAAK,EAAE,MAAM;IAS1B,WAAW,CAAC,SAAS,SAAS,UAAU,EAC5C,OAAO,EAAE,MAAM,EACf,EAAE,EAAE,MAAM,GACT,OAAO,CAAC,SAAS,CAAC;IAUf,cAAc,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,QAAQ,EAAE,UAAU;IAI9D,cAAc,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM;IAIxC,YAAY,IAAI,OAAO,CAAC,IAAI,CAAC;IAI7B,qBAAqB,CACzB,KAAK,EAAE,MAAM,EACb,EAAE,EAAE,MAAM,EACV,UAAU,EAAE,SAAS,EAAE,EACvB,MAAM,EAAE,cAAc,GACrB,OAAO,CAAC,IAAI,CAAC;IAgBV,SAAS;IAUT,QAAQ,CAAC,EAAE,EAAE,MAAM;IAWnB,cAAc,CAAC,IAAI,EAAE,MAAM;IAa3B,WAAW,CAAC,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,qBAAqB;IAKpD,WAAW,CAAC,EAAE,EAAE,MAAM;IAQtB,kBAAkB,CACtB,EAAE,EAAE,MAAM,EACV,UAAU,EAAE,SAAS,CAAC,mBAAmB,CAAC,EAAE,EAC5C,MAAM,EAAE,cAAc,GACrB,OAAO,CAAC,IAAI,CAAC;IAaV,+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;IA6CK,0BAA0B;YAYlB,eAAe;CAU9B"}

package/dist/src/storage/browser.js

@@ -0,0 +1,155 @@
+import { DriveNotFoundError } from "#server/error";
+import { migrateDocumentOperationSignatures } from "#utils/migrations";
+import { mergeOperations } from "#utils/misc";
+import LocalForage from "localforage";
+export class BrowserStorage {
+    db;
+    static DBName = "DOCUMENT_DRIVES";
+    static SEP = ":";
+    static DRIVES_KEY = "DRIVES";
+    constructor(namespace) {
+        this.db = LocalForage.ready().then(() => LocalForage.createInstance({
+            name: namespace
+                ? `${namespace}:${BrowserStorage.DBName}`
+                : BrowserStorage.DBName,
+        }));
+    }
+    buildKey(...args) {
+        return args.join(BrowserStorage.SEP);
+    }
+    async checkDocumentExists(drive, id) {
+        const document = await (await this.db).getItem(this.buildKey(drive, id));
+        return !!document;
+    }
+    async getDocuments(drive) {
+        const db = await this.db;
+        const keys = await db.keys();
+        const driveKey = `${drive}${BrowserStorage.SEP}`;
+        return keys
+            .filter((key) => key.startsWith(driveKey))
+            .map((key) => key.slice(driveKey.length));
+    }
+    async getDocument(driveId, id) {
+        const document = await (await this.db).getItem(this.buildKey(driveId, id));
+        if (!document) {
+            throw new Error(`Document with id ${id} not found`);
+        }
+        return document;
+    }
+    async createDocument(drive, id, document) {
+        await (await this.db).setItem(this.buildKey(drive, id), document);
+    }
+    async deleteDocument(drive, id) {
+        await (await this.db).removeItem(this.buildKey(drive, id));
+    }
+    async clearStorage() {
+        return (await this.db).clear();
+    }
+    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 mergedOperations = mergeOperations(document.operations, operations);
+        const db = await this.db;
+        await db.setItem(this.buildKey(drive, id), {
+            ...document,
+            ...header,
+            operations: mergedOperations,
+        });
+    }
+    async getDrives() {
+        const db = await this.db;
+        const keys = await db.keys();
+        return keys
+            .filter((key) => key.startsWith(BrowserStorage.DRIVES_KEY))
+            .map((key) => key.slice(BrowserStorage.DRIVES_KEY.length + BrowserStorage.SEP.length));
+    }
+    async getDrive(id) {
+        const db = await this.db;
+        const drive = await db.getItem(this.buildKey(BrowserStorage.DRIVES_KEY, id));
+        if (!drive) {
+            throw new DriveNotFoundError(id);
+        }
+        return drive;
+    }
+    async getDriveBySlug(slug) {
+        // get oldes drives first
+        const drives = (await this.getDrives()).reverse();
+        for (const drive of drives) {
+            const driveData = await this.getDrive(drive);
+            if (driveData.initialState.state.global.slug === slug) {
+                return this.getDrive(drive);
+            }
+        }
+        throw new Error(`Drive with slug ${slug} not found`);
+    }
+    async createDrive(id, drive) {
+        const db = await this.db;
+        await db.setItem(this.buildKey(BrowserStorage.DRIVES_KEY, id), drive);
+    }
+    async deleteDrive(id) {
+        const documents = await this.getDocuments(id);
+        await Promise.all(documents.map((doc) => this.deleteDocument(id, doc)));
+        return (await this.db).removeItem(this.buildKey(BrowserStorage.DRIVES_KEY, id));
+    }
+    async addDriveOperations(id, operations, header) {
+        const drive = await this.getDrive(id);
+        const mergedOperations = mergeOperations(drive.operations, operations);
+        const db = await this.db;
+        await db.setItem(this.buildKey(BrowserStorage.DRIVES_KEY, id), {
+            ...drive,
+            ...header,
+            operations: mergedOperations,
+        });
+        return;
+    }
+    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;
+        }, []);
+    }
+    // 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)));
+        }
+    }
+    async migrateDocument(drive, id) {
+        const document = await this.getDocument(drive, id);
+        const migratedDocument = migrateDocumentOperationSignatures(document);
+        if (migratedDocument !== document) {
+            return (await this.db).setItem(this.buildKey(drive, id), migratedDocument);
+        }
+    }
+}

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

@@ -0,0 +1,33 @@
+import { DocumentDriveAction, DocumentDriveDocument } from "#drive-document-model/gen/types";
+import { SynchronizationUnitQuery } from "#server/types";
+import { DocumentHeader, Operation, PHDocument } from "document-model";
+import { IDriveStorage } from "./types.js";
+export declare class FilesystemStorage implements IDriveStorage {
+    private basePath;
+    private drivesPath;
+    private static DRIVES_DIR;
+    constructor(basePath: string);
+    private _buildDocumentPath;
+    getDocuments(drive: string): Promise<string[]>;
+    checkDocumentExists(drive: string, id: string): Promise<boolean>;
+    getDocument<TDocument extends PHDocument>(drive: string, id: string): Promise<TDocument>;
+    createDocument(drive: string, id: string, document: PHDocument): Promise<void>;
+    clearStorage(): Promise<void>;
+    deleteDocument(drive: string, id: string): Promise<void>;
+    addDocumentOperations(drive: string, id: string, operations: Operation[], header: DocumentHeader): Promise<void>;
+    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>;
+    addDriveOperations(id: string, operations: Operation<DocumentDriveAction>[], header: DocumentHeader): Promise<void>;
+    getSynchronizationUnitsRevision(units: SynchronizationUnitQuery[]): Promise<{
+        driveId: string;
+        documentId: string;
+        scope: string;
+        branch: string;
+        lastUpdated: string;
+        revision: number;
+    }[]>;
+}
+//# sourceMappingURL=filesystem.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"filesystem.d.ts","sourceRoot":"","sources":["../../../src/storage/filesystem.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,mBAAmB,EACnB,qBAAqB,EACtB,MAAM,iCAAiC,CAAC;AAEzC,OAAO,EAAE,wBAAwB,EAAE,MAAM,eAAe,CAAC;AAEzD,OAAO,EACL,cAAc,EACd,SAAS,EAET,UAAU,EACX,MAAM,gBAAgB,CAAC;AAaxB,OAAO,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAe3C,qBAAa,iBAAkB,YAAW,aAAa;IACrD,OAAO,CAAC,QAAQ,CAAS;IACzB,OAAO,CAAC,UAAU,CAAS;IAC3B,OAAO,CAAC,MAAM,CAAC,UAAU,CAAY;gBAEzB,QAAQ,EAAE,MAAM;IAO5B,OAAO,CAAC,kBAAkB;IAOpB,YAAY,CAAC,KAAK,EAAE,MAAM;IA2BhC,mBAAmB,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAK1D,WAAW,CAAC,SAAS,SAAS,UAAU,EAC5C,KAAK,EAAE,MAAM,EACb,EAAE,EAAE,MAAM,GACT,OAAO,CAAC,SAAS,CAAC;IAWf,cAAc,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,QAAQ,EAAE,UAAU;IAS9D,YAAY;IAmCZ,cAAc,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM;IAIxC,qBAAqB,CACzB,KAAK,EAAE,MAAM,EACb,EAAE,EAAE,MAAM,EACV,UAAU,EAAE,SAAS,EAAE,EACvB,MAAM,EAAE,cAAc;IAgBlB,SAAS;IAmBT,QAAQ,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,qBAAqB,CAAC;IAQpD,cAAc,CAAC,IAAI,EAAE,MAAM;IAkBjC,WAAW,CAAC,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,qBAAqB;IAI9C,WAAW,CAAC,EAAE,EAAE,MAAM;IAQtB,kBAAkB,CACtB,EAAE,EAAE,MAAM,EACV,UAAU,EAAE,SAAS,CAAC,mBAAmB,CAAC,EAAE,EAC5C,MAAM,EAAE,cAAc,GACrB,OAAO,CAAC,IAAI,CAAC;IAcV,+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/filesystem.js

@@ -0,0 +1,197 @@
+import { DriveNotFoundError } from "#server/error";
+import { mergeOperations } from "#utils/misc";
+import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync, } from "fs";
+import fs from "fs/promises";
+import stringify from "json-stringify-deterministic";
+import path from "path";
+import sanitize from "sanitize-filename";
+function ensureDir(dir) {
+    if (!existsSync(dir)) {
+        mkdirSync(dir, { recursive: true });
+    }
+}
+export class FilesystemStorage {
+    basePath;
+    drivesPath;
+    static DRIVES_DIR = "drives";
+    constructor(basePath) {
+        this.basePath = basePath;
+        ensureDir(this.basePath);
+        this.drivesPath = path.join(this.basePath, FilesystemStorage.DRIVES_DIR);
+        ensureDir(this.drivesPath);
+    }
+    _buildDocumentPath(...args) {
+        return `${path.join(this.basePath, ...args.map((arg) => sanitize(arg)))}.json`;
+    }
+    async getDocuments(drive) {
+        let files = [];
+        try {
+            files = readdirSync(path.join(this.basePath, drive), {
+                withFileTypes: true,
+            });
+        }
+        catch (error) {
+            // if folder is not found then drive has no documents
+            if (error.code !== "ENOENT") {
+                throw error;
+            }
+        }
+        const documents = [];
+        for (const file of files.filter((file) => file.isFile())) {
+            try {
+                const documentId = path.parse(file.name).name;
+                // checks if file is document
+                await this.getDocument(drive, documentId);
+                documents.push(documentId);
+            }
+            catch {
+                /* Ignore invalid document*/
+            }
+        }
+        return documents;
+    }
+    checkDocumentExists(drive, id) {
+        const documentExists = existsSync(this._buildDocumentPath(drive, id));
+        return Promise.resolve(documentExists);
+    }
+    async getDocument(drive, id) {
+        try {
+            const content = readFileSync(this._buildDocumentPath(drive, id), {
+                encoding: "utf-8",
+            });
+            return JSON.parse(content);
+        }
+        catch (error) {
+            throw new Error(`Document with id ${id} not found`);
+        }
+    }
+    async createDocument(drive, id, document) {
+        const documentPath = this._buildDocumentPath(drive, id);
+        ensureDir(path.dirname(documentPath));
+        writeFileSync(documentPath, stringify(document), {
+            encoding: "utf-8",
+        });
+        return Promise.resolve();
+    }
+    async clearStorage() {
+        const drivesPath = path.join(this.basePath, FilesystemStorage.DRIVES_DIR);
+        // delete content of drives directory
+        const drives = (await fs.readdir(drivesPath, {
+            withFileTypes: true,
+            recursive: true,
+        })).filter((dirent) => !!dirent.name);
+        await Promise.all(drives.map(async (dirent) => {
+            await fs.rm(path.join(drivesPath, dirent.name), {
+                recursive: true,
+            });
+        }));
+        // delete files in basePath
+        const files = (await fs.readdir(this.basePath, { withFileTypes: true })).filter((file) => file.name !== FilesystemStorage.DRIVES_DIR && !!file.name);
+        await Promise.all(files.map(async (dirent) => {
+            await fs.rm(path.join(this.basePath, dirent.name), {
+                recursive: true,
+            });
+        }));
+    }
+    async deleteDocument(drive, id) {
+        return fs.rm(this._buildDocumentPath(drive, id));
+    }
+    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 mergedOperations = mergeOperations(document.operations, operations);
+        await this.createDocument(drive, id, {
+            ...document,
+            ...header,
+            operations: mergedOperations,
+        });
+    }
+    async getDrives() {
+        const files = readdirSync(this.drivesPath, {
+            withFileTypes: true,
+        });
+        const drives = [];
+        for (const file of files.filter((file) => file.isFile())) {
+            try {
+                const driveId = path.parse(file.name).name;
+                // checks if file is drive
+                await this.getDrive(driveId);
+                drives.push(driveId);
+            }
+            catch {
+                /* Ignore invalid drive document found on drives dir */
+            }
+        }
+        return drives;
+    }
+    async getDrive(id) {
+        try {
+            return await this.getDocument(FilesystemStorage.DRIVES_DIR, id);
+        }
+        catch {
+            throw new DriveNotFoundError(id);
+        }
+    }
+    async getDriveBySlug(slug) {
+        // get oldes drives first
+        const drives = (await this.getDrives()).reverse();
+        for (const drive of drives) {
+            const { initialState: { state: { global: { slug: driveSlug }, }, }, } = await this.getDrive(drive);
+            if (driveSlug === slug) {
+                return this.getDrive(drive);
+            }
+        }
+        throw new Error(`Drive with slug ${slug} not found`);
+    }
+    createDrive(id, drive) {
+        return this.createDocument(FilesystemStorage.DRIVES_DIR, id, drive);
+    }
+    async deleteDrive(id) {
+        const documents = await this.getDocuments(id);
+        await this.deleteDocument(FilesystemStorage.DRIVES_DIR, id);
+        await Promise.all(documents.map((document) => this.deleteDocument(id, document)));
+    }
+    async addDriveOperations(id, operations, header) {
+        const drive = await this.getDrive(id);
+        const mergedOperations = mergeOperations(drive.operations, operations);
+        await this.createDrive(id, {
+            ...drive,
+            ...header,
+            operations: mergedOperations,
+        });
+    }
+    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/memory.d.ts

@@ -0,0 +1,33 @@
+import { DocumentDriveDocument } from "#drive-document-model/gen/types";
+import { SynchronizationUnitQuery } from "#server/types";
+import { DocumentHeader, Operation, OperationFromDocument, PHDocument } from "document-model";
+import { IDriveStorage } from "./types.js";
+export declare class MemoryStorage implements IDriveStorage {
+    private documents;
+    private drives;
+    private slugToDriveId;
+    constructor();
+    checkDocumentExists(drive: string, id: string): Promise<boolean>;
+    getDocuments(drive: string): Promise<string[]>;
+    getDocument<TDocument extends PHDocument>(driveId: string, id: string): Promise<TDocument>;
+    saveDocument(drive: string, id: string, document: PHDocument): Promise<void>;
+    clearStorage(): Promise<void>;
+    createDocument(drive: string, id: string, document: PHDocument): Promise<void>;
+    addDocumentOperations(drive: string, id: string, operations: Operation[], header: DocumentHeader): Promise<void>;
+    deleteDocument(drive: string, id: string): Promise<void>;
+    getDrives(): Promise<string[]>;
+    getDrive(id: string): Promise<DocumentDriveDocument>;
+    getDriveBySlug(slug: string): Promise<DocumentDriveDocument>;
+    createDrive(id: string, drive: DocumentDriveDocument): Promise<void>;
+    addDriveOperations(id: string, operations: OperationFromDocument<DocumentDriveDocument>[], header: DocumentHeader): Promise<void>;
+    deleteDrive(id: string): Promise<void>;
+    getSynchronizationUnitsRevision(units: SynchronizationUnitQuery[]): Promise<{
+        driveId: string;
+        documentId: string;
+        scope: string;
+        branch: string;
+        lastUpdated: string;
+        revision: number;
+    }[]>;
+}
+//# sourceMappingURL=memory.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"memory.d.ts","sourceRoot":"","sources":["../../../src/storage/memory.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,qBAAqB,EAAE,MAAM,iCAAiC,CAAC;AAExE,OAAO,EAAE,wBAAwB,EAAE,MAAM,eAAe,CAAC;AAEzD,OAAO,EACL,cAAc,EACd,SAAS,EACT,qBAAqB,EAErB,UAAU,EACX,MAAM,gBAAgB,CAAC;AACxB,OAAO,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAE3C,qBAAa,aAAc,YAAW,aAAa;IACjD,OAAO,CAAC,SAAS,CAA6C;IAC9D,OAAO,CAAC,MAAM,CAAwC;IACtD,OAAO,CAAC,aAAa,CAA8B;;IAOnD,mBAAmB,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAI1D,YAAY,CAAC,KAAK,EAAE,MAAM;IAI1B,WAAW,CAAC,SAAS,SAAS,UAAU,EAC5C,OAAO,EAAE,MAAM,EACf,EAAE,EAAE,MAAM,GACT,OAAO,CAAC,SAAS,CAAC;IAaf,YAAY,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,QAAQ,EAAE,UAAU;IAK5D,YAAY,IAAI,OAAO,CAAC,IAAI,CAAC;IAK7B,cAAc,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,QAAQ,EAAE,UAAU;IA0B9D,qBAAqB,CACzB,KAAK,EAAE,MAAM,EACb,EAAE,EAAE,MAAM,EACV,UAAU,EAAE,SAAS,EAAE,EACvB,MAAM,EAAE,cAAc,GACrB,OAAO,CAAC,IAAI,CAAC;IAeV,cAAc,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM;IAOxC,SAAS;IAIT,QAAQ,CAAC,EAAE,EAAE,MAAM;IAQnB,cAAc,CAAC,IAAI,EAAE,MAAM;IAQ3B,WAAW,CAAC,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,qBAAqB;IASpD,kBAAkB,CACtB,EAAE,EAAE,MAAM,EACV,UAAU,EAAE,qBAAqB,CAAC,qBAAqB,CAAC,EAAE,EAC1D,MAAM,EAAE,cAAc,GACrB,OAAO,CAAC,IAAI,CAAC;IAcV,WAAW,CAAC,EAAE,EAAE,MAAM;IAKtB,+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"}