document-drive 1.19.0 → 1.20.0

package/dist/src/storage/memory.js

@@ -0,0 +1,139 @@
+import { DriveNotFoundError } from "#server/error";
+import { mergeOperations } from "#utils/misc";
+export class MemoryStorage {
+    documents;
+    drives;
+    slugToDriveId = {};
+    constructor() {
+        this.documents = {};
+        this.drives = {};
+    }
+    checkDocumentExists(drive, id) {
+        return Promise.resolve(this.documents[drive][id] !== undefined);
+    }
+    async getDocuments(drive) {
+        return Object.keys(this.documents[drive] ?? {});
+    }
+    async getDocument(driveId, id) {
+        const drive = this.documents[driveId];
+        if (!drive) {
+            throw new DriveNotFoundError(driveId);
+        }
+        const document = drive[id];
+        if (!document) {
+            throw new Error(`Document with id ${id} not found`);
+        }
+        return document;
+    }
+    async saveDocument(drive, id, document) {
+        this.documents[drive] = this.documents[drive] ?? {};
+        this.documents[drive][id] = document;
+    }
+    async clearStorage() {
+        this.documents = {};
+        this.drives = {};
+    }
+    async createDocument(drive, id, document) {
+        this.documents[drive] = this.documents[drive] ?? {};
+        const { operations, initialState, name, revision, documentType, created, lastModified, clipboard, state, } = document;
+        this.documents[drive][id] = {
+            operations,
+            initialState,
+            name,
+            revision,
+            documentType,
+            created,
+            lastModified,
+            clipboard,
+            state,
+        };
+    }
+    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);
+        this.documents[drive][id] = {
+            ...document,
+            ...header,
+            operations: mergedOperations,
+        };
+    }
+    async deleteDocument(drive, id) {
+        if (!this.documents[drive]) {
+            throw new DriveNotFoundError(drive);
+        }
+        delete this.documents[drive][id];
+    }
+    async getDrives() {
+        return Object.keys(this.drives);
+    }
+    async getDrive(id) {
+        const drive = this.drives[id];
+        if (!drive) {
+            throw new DriveNotFoundError(id);
+        }
+        return drive;
+    }
+    async getDriveBySlug(slug) {
+        const driveId = this.slugToDriveId[slug];
+        if (!driveId) {
+            throw new Error(`Drive with slug ${slug} not found`);
+        }
+        return this.getDrive(driveId);
+    }
+    async createDrive(id, drive) {
+        this.drives[id] = drive;
+        this.documents[id] = {};
+        const { slug } = drive.initialState.state.global;
+        if (slug) {
+            this.slugToDriveId[slug] = id;
+        }
+    }
+    async addDriveOperations(id, operations, header) {
+        const drive = await this.getDrive(id);
+        const mergedOperations = mergeOperations(drive.operations, operations);
+        this.drives[id] = {
+            ...drive,
+            ...header,
+            operations: mergedOperations,
+        };
+    }
+    async deleteDrive(id) {
+        delete this.documents[id];
+        delete this.drives[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/prisma.d.ts

@@ -0,0 +1,67 @@
+import { Prisma, PrismaClient } from "@prisma/client";
+import type { BaseStateFromDocument, DocumentHeader, Operation, OperationFromDocument, PHDocument } from "document-model";
+import { IBackOffOptions } from "exponential-backoff";
+import { DocumentDriveAction, DocumentDriveDocument } from "../drive-document-model/gen/types.js";
+import { SynchronizationUnitQuery } from "../server/types.js";
+import { IDriveStorage, IStorageDelegate } from "./types.js";
+type Transaction = Omit<PrismaClient<Prisma.PrismaClientOptions, never>, "$connect" | "$disconnect" | "$on" | "$transaction" | "$use" | "$extends"> | ExtendedPrismaClient;
+export type PrismaStorageOptions = {
+    transactionRetryBackoff?: IBackOffOptions;
+};
+declare function getRetryTransactionsClient<T extends PrismaClient>(prisma: T, backOffOptions?: Partial<IBackOffOptions>): import("@prisma/client/runtime/library").DynamicClientExtensionThis<Prisma.TypeMap<import("@prisma/client/runtime/library").InternalArgs & {
+    result: {};
+    model: {};
+    query: {};
+    client: {
+        $transaction: () => (...args: Parameters<T["$transaction"]>) => Promise<unknown>;
+    };
+}, Prisma.PrismaClientOptions>, Prisma.TypeMapCb, {
+    result: {};
+    model: {};
+    query: {};
+    client: {
+        $transaction: () => (...args: Parameters<T["$transaction"]>) => Promise<unknown>;
+    };
+}, {}>;
+type ExtendedPrismaClient = ReturnType<typeof getRetryTransactionsClient<PrismaClient>>;
+export declare class PrismaStorage implements IDriveStorage {
+    private db;
+    private delegate;
+    constructor(db: PrismaClient, options?: PrismaStorageOptions);
+    setStorageDelegate(delegate: IStorageDelegate): void;
+    createDrive(id: string, drive: DocumentDriveDocument): Promise<void>;
+    addDriveOperations(id: string, operations: Operation<DocumentDriveAction>[], header: DocumentHeader): Promise<void>;
+    addDriveOperationsWithTransaction(drive: string, callback: (document: DocumentDriveDocument) => Promise<{
+        operations: Operation[];
+        header: DocumentHeader;
+    }>): Promise<never>;
+    createDocument(drive: string, id: string, document: PHDocument): Promise<void>;
+    private _addDocumentOperations;
+    addDocumentOperationsWithTransaction<TDocument extends PHDocument>(drive: string, id: string, callback: (document: TDocument) => Promise<{
+        operations: OperationFromDocument<TDocument>[];
+        header: DocumentHeader;
+        newState?: BaseStateFromDocument<TDocument> | undefined;
+    }>): Promise<never>;
+    addDocumentOperations(drive: string, id: string, operations: Operation[], header: DocumentHeader): Promise<void>;
+    getDocuments(drive: string): Promise<string[]>;
+    checkDocumentExists(driveId: string, id: string): Promise<boolean>;
+    getDocument<TDocument extends PHDocument>(driveId: string, id: string, tx?: Transaction): Promise<TDocument>;
+    deleteDocument(drive: string, id: string): Promise<void>;
+    getDrives(): Promise<string[]>;
+    getDrive(id: string): Promise<DocumentDriveDocument>;
+    getDriveBySlug(slug: string): Promise<DocumentDriveDocument>;
+    deleteDrive(id: string): Promise<void>;
+    getOperationResultingState(driveId: string, documentId: string, index: number, scope: string, branch: string): Promise<string | undefined>;
+    getDriveOperationResultingState(drive: string, index: number, scope: string, branch: string): Promise<string | undefined>;
+    getSynchronizationUnitsRevision(units: SynchronizationUnitQuery[]): Promise<{
+        driveId: string;
+        documentId: string;
+        scope: string;
+        branch: string;
+        lastUpdated: string;
+        revision: number;
+    }[]>;
+    migrateOperationSignatures(): Promise<void>;
+}
+export {};
+//# sourceMappingURL=prisma.d.ts.map

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

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

package/dist/src/storage/prisma.js

@@ -0,0 +1,445 @@
+import { PrismaClientKnownRequestError } from "@prisma/client/runtime/library";
+import { backOff } from "exponential-backoff";
+import { ConflictOperationError, DriveNotFoundError } from "../server/error.js";
+import { logger } from "../utils/logger.js";
+function storageToOperation(op) {
+    const operation = {
+        id: op.opId || undefined,
+        skip: op.skip,
+        hash: op.hash,
+        index: op.index,
+        timestamp: new Date(op.timestamp).toISOString(),
+        input: JSON.parse(op.input),
+        type: op.type,
+        scope: op.scope,
+        resultingState: op.resultingState
+            ? op.resultingState.toString()
+            : undefined,
+        attachments: op.attachments,
+    };
+    if (op.context) {
+        operation.context = op.context;
+    }
+    return operation;
+}
+function getRetryTransactionsClient(prisma, backOffOptions) {
+    return prisma.$extends({
+        client: {
+            $transaction: (...args) => {
+                // eslint-disable-next-line prefer-spread
+                return backOff(() => prisma.$transaction.apply(prisma, args), {
+                    retry: (e) => {
+                        const code = e.code;
+                        // Retry the transaction only if the error was due to a write conflict or deadlock
+                        // See: https://www.prisma.io/docs/reference/api-reference/error-reference#p2034
+                        if (code !== "P2034") {
+                            logger.error("TRANSACTION ERROR", e);
+                        }
+                        return code === "P2034";
+                    },
+                    ...backOffOptions,
+                });
+            },
+        },
+    });
+}
+export class PrismaStorage {
+    db;
+    delegate;
+    constructor(db, options) {
+        const backOffOptions = options?.transactionRetryBackoff;
+        this.db = getRetryTransactionsClient(db, {
+            ...backOffOptions,
+            jitter: backOffOptions?.jitter ?? "full",
+        });
+    }
+    setStorageDelegate(delegate) {
+        this.delegate = delegate;
+    }
+    async createDrive(id, drive) {
+        // drive for all drive documents
+        await this.createDocument("drives", id, drive);
+        await this.db.drive.upsert({
+            where: {
+                slug: drive.initialState.state.global.slug ?? id,
+            },
+            create: {
+                id: id,
+                slug: drive.initialState.state.global.slug ?? id,
+            },
+            update: {
+                id,
+            },
+        });
+    }
+    async addDriveOperations(id, operations, header) {
+        await this.addDocumentOperations("drives", id, operations, header);
+    }
+    async addDriveOperationsWithTransaction(drive, callback) {
+        return this.addDocumentOperationsWithTransaction("drives", drive, (document) => callback(document));
+    }
+    async createDocument(drive, id, document) {
+        await this.db.document.upsert({
+            where: {
+                id_driveId: {
+                    id,
+                    driveId: drive,
+                },
+            },
+            update: {},
+            create: {
+                name: document.name,
+                documentType: document.documentType,
+                driveId: drive,
+                initialState: JSON.stringify(document.initialState),
+                lastModified: document.lastModified,
+                revision: JSON.stringify(document.revision),
+                id,
+            },
+        });
+    }
+    async _addDocumentOperations(tx, drive, id, operations, header) {
+        try {
+            await tx.operation.createMany({
+                data: operations.map((op) => ({
+                    driveId: drive,
+                    documentId: id,
+                    hash: op.hash,
+                    index: op.index,
+                    input: JSON.stringify(op.input),
+                    timestamp: op.timestamp,
+                    type: op.type,
+                    scope: op.scope,
+                    branch: "main",
+                    opId: op.id,
+                    skip: op.skip,
+                    context: op.context,
+                    resultingState: op.resultingState
+                        ? Buffer.from(JSON.stringify(op.resultingState))
+                        : undefined,
+                })),
+            });
+            await tx.document.updateMany({
+                where: {
+                    id,
+                    driveId: drive,
+                },
+                data: {
+                    lastModified: header.lastModified,
+                    revision: JSON.stringify(header.revision),
+                },
+            });
+            await Promise.all(operations
+                .filter((o) => o.attachments?.length)
+                .map((op) => {
+                return tx.operation.update({
+                    where: {
+                        unique_operation: {
+                            driveId: drive,
+                            documentId: id,
+                            index: op.index,
+                            scope: op.scope,
+                            branch: "main",
+                        },
+                    },
+                    data: {
+                        attachments: {
+                            createMany: {
+                                data: op.attachments ?? [],
+                            },
+                        },
+                    },
+                });
+            }));
+        }
+        catch (e) {
+            // P2002: Unique constraint failed
+            // Operation with existing index
+            if (e instanceof PrismaClientKnownRequestError && e.code === "P2002") {
+                const existingOperation = await this.db.operation.findFirst({
+                    where: {
+                        AND: operations.map((op) => ({
+                            driveId: drive,
+                            documentId: id,
+                            scope: op.scope,
+                            branch: "main",
+                            index: op.index,
+                        })),
+                    },
+                });
+                const conflictOp = operations.find((op) => existingOperation?.index === op.index &&
+                    existingOperation.scope === op.scope);
+                if (!existingOperation || !conflictOp) {
+                    console.error(e);
+                    throw e;
+                }
+                else {
+                    throw new ConflictOperationError(storageToOperation(existingOperation), conflictOp);
+                }
+            }
+            else {
+                throw e;
+            }
+        }
+    }
+    async addDocumentOperationsWithTransaction(drive, id, callback) {
+        let result = null;
+        await this.db.$transaction(async (tx) => {
+            const document = await this.getDocument(drive, id, tx);
+            if (!document) {
+                throw new Error(`Document with id ${id} not found`);
+            }
+            result = await callback(document);
+            const { operations, header, newState } = result;
+            return this._addDocumentOperations(tx, drive, id, operations, header);
+        }, { isolationLevel: "Serializable", maxWait: 10000, timeout: 20000 });
+        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+        if (!result) {
+            throw new Error("No operations were provided");
+        }
+        return result;
+    }
+    async addDocumentOperations(drive, id, operations, header) {
+        return this._addDocumentOperations(this.db, drive, id, operations, header);
+    }
+    async getDocuments(drive) {
+        const docs = await this.db.document.findMany({
+            select: {
+                id: true,
+            },
+            where: {
+                AND: {
+                    driveId: drive,
+                    NOT: {
+                        id: "drives",
+                    },
+                },
+            },
+        });
+        return docs.map((doc) => doc.id);
+    }
+    async checkDocumentExists(driveId, id) {
+        const count = await this.db.document.count({
+            where: {
+                id: id,
+                driveId: driveId,
+            },
+        });
+        return count > 0;
+    }
+    async getDocument(driveId, id, tx) {
+        const prisma = tx ?? this.db;
+        const result = await prisma.document.findUnique({
+            where: {
+                id_driveId: {
+                    driveId,
+                    id,
+                },
+            },
+        });
+        if (result === null) {
+            throw new Error(`Document with id ${id} not found`);
+        }
+        const cachedOperations = (await this.delegate?.getCachedOperations(driveId, id)) ?? {
+            global: [],
+            local: [],
+        };
+        const scopeIndex = Object.keys(cachedOperations).reduceRight((acc, value) => {
+            const scope = value;
+            const lastIndex = cachedOperations[scope].at(-1)?.index ?? -1;
+            acc[scope] = lastIndex;
+            return acc;
+        }, { global: -1, local: -1 });
+        const conditions = Object.entries(scopeIndex).map(([scope, index]) => `("scope" = '${scope}' AND "index" > ${index})`);
+        conditions.push(`("scope" NOT IN (${Object.keys(cachedOperations)
+            .map((s) => `'${s}'`)
+            .join(", ")}))`);
+        // retrieves operations with resulting state
+        // for the last operation of each scope
+        // TODO prevent SQL injection
+        const queryOperations = await prisma.$queryRawUnsafe(`WITH ranked_operations AS (
+            SELECT
+                *,
+                ROW_NUMBER() OVER (PARTITION BY scope ORDER BY index DESC) AS rn
+            FROM "Operation"
+            )
+            SELECT
+            "id",
+            "opId",
+            "scope",
+            "branch",
+            "index",
+            "skip",
+            "hash",
+            "timestamp",
+            "input",
+            "type",
+            "context",
+            CASE
+                WHEN rn = 1 THEN "resultingState"
+                ELSE NULL
+            END AS "resultingState"
+            FROM ranked_operations
+            WHERE "driveId" = $1 AND "documentId" = $2
+            AND (${conditions.join(" OR ")})
+            ORDER BY scope, index;
+        `, driveId, id);
+        const operationIds = queryOperations.map((o) => o.id);
+        const attachments = await prisma.attachment.findMany({
+            where: {
+                operationId: {
+                    in: operationIds,
+                },
+            },
+        });
+        // TODO add attachments from cached operations
+        const fileRegistry = {};
+        const operationsByScope = queryOperations.reduce((acc, operation) => {
+            const scope = operation.scope;
+            if (!acc[scope]) {
+                acc[scope] = [];
+            }
+            const result = storageToOperation(operation);
+            result.attachments = attachments.filter((a) => a.operationId === operation.id);
+            result.attachments.forEach(({ hash, ...file }) => {
+                fileRegistry[hash] = file;
+            });
+            acc[scope].push(result);
+            return acc;
+        }, cachedOperations);
+        const dbDoc = result;
+        const doc = {
+            created: dbDoc.created.toISOString(),
+            name: dbDoc.name ? dbDoc.name : "",
+            documentType: dbDoc.documentType,
+            initialState: JSON.parse(dbDoc.initialState),
+            state: undefined,
+            lastModified: new Date(dbDoc.lastModified).toISOString(),
+            operations: operationsByScope,
+            clipboard: [],
+            revision: JSON.parse(dbDoc.revision),
+            attachments: {},
+        };
+        return doc;
+    }
+    async deleteDocument(drive, id) {
+        try {
+            await this.db.document.deleteMany({
+                where: {
+                    driveId: drive,
+                    id: id,
+                },
+            });
+        }
+        catch (e) {
+            const prismaError = e;
+            // Ignore Error: P2025: An operation failed because it depends on one or more records that were required but not found.
+            if ((prismaError.code && prismaError.code === "P2025") ||
+                prismaError.message?.includes("An operation failed because it depends on one or more records that were required but not found.")) {
+                return;
+            }
+            throw e;
+        }
+    }
+    async getDrives() {
+        return this.getDocuments("drives");
+    }
+    async getDrive(id) {
+        try {
+            const doc = await this.getDocument("drives", id);
+            return doc;
+        }
+        catch (e) {
+            logger.error(e);
+            throw new DriveNotFoundError(id);
+        }
+    }
+    async getDriveBySlug(slug) {
+        const driveEntity = await this.db.drive.findFirst({
+            where: {
+                slug,
+            },
+        });
+        if (!driveEntity) {
+            throw new Error(`Drive with slug ${slug} not found`);
+        }
+        return this.getDrive(driveEntity.id);
+    }
+    async deleteDrive(id) {
+        // delete drive and associated slug
+        await this.db.drive.deleteMany({
+            where: {
+                id,
+            },
+        });
+        // 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(driveId, documentId, index, scope, branch) {
+        const operation = await this.db.operation.findUnique({
+            where: {
+                unique_operation: {
+                    driveId,
+                    documentId,
+                    index,
+                    scope,
+                    branch,
+                },
+            },
+        });
+        return operation?.resultingState?.toString();
+    }
+    getDriveOperationResultingState(drive, index, scope, branch) {
+        return this.getOperationResultingState("drives", drive, index, scope, branch);
+    }
+    async getSynchronizationUnitsRevision(units) {
+        // TODO add branch condition
+        const whereClauses = units
+            .map((_, index) => {
+            return `("driveId" = $${index * 3 + 1} AND "documentId" = $${index * 3 + 2} AND "scope" = $${index * 3 + 3})`;
+        })
+            .join(" OR ");
+        const query = `
+            SELECT "driveId", "documentId", "scope", "branch", MAX("timestamp") as "lastUpdated", MAX("index") as revision FROM "Operation"
+            WHERE ${whereClauses}
+            GROUP BY "driveId", "documentId", "scope", "branch"
+        `;
+        const params = units
+            .map((unit) => [
+            unit.documentId ? unit.driveId : "drives",
+            unit.documentId || unit.driveId,
+            unit.scope,
+        ])
+            .flat();
+        const results = await this.db.$queryRawUnsafe(query, ...params);
+        return results.map((row) => ({
+            ...row,
+            driveId: row.driveId === "drives" ? row.documentId : row.driveId,
+            documentId: row.driveId === "drives" ? "" : row.documentId,
+            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/dist/src/storage/sequelize.d.ts

@@ -0,0 +1,32 @@
+import { DocumentDriveAction, DocumentDriveDocument } from "#drive-document-model/gen/types";
+import { SynchronizationUnitQuery } from "#server/types";
+import { AttachmentInput, DocumentHeader, Operation, PHDocument } from "document-model";
+import { Options, Sequelize } from "sequelize";
+import { IDriveStorage } from "./types.js";
+export declare class SequelizeStorage implements IDriveStorage {
+    private db;
+    constructor(options: Options);
+    syncModels(): Promise<Sequelize>;
+    createDrive(id: string, drive: DocumentDriveDocument): Promise<void>;
+    addDriveOperations(id: string, operations: Operation<DocumentDriveAction>[], header: DocumentHeader): Promise<void>;
+    createDocument(drive: string, id: string, document: PHDocument): Promise<void>;
+    addDocumentOperations(drive: string, id: string, operations: Operation[], header: DocumentHeader): Promise<void>;
+    _addDocumentOperationAttachments(driveId: string, documentId: string, operation: Operation, attachments: AttachmentInput[]): Promise<import("sequelize").Model<any, any>[]>;
+    getDocuments(drive: string): Promise<string[]>;
+    checkDocumentExists(driveId: string, id: string): Promise<boolean>;
+    getDocument<TDocument extends PHDocument>(driveId: string, id: string): Promise<TDocument>;
+    deleteDocument(drive: string, id: string): Promise<void>;
+    getDrives(): Promise<string[]>;
+    getDrive(id: string): Promise<DocumentDriveDocument>;
+    getDriveBySlug(slug: string): Promise<DocumentDriveDocument>;
+    deleteDrive(id: string): Promise<void>;
+    getSynchronizationUnitsRevision(units: SynchronizationUnitQuery[]): Promise<{
+        driveId: string;
+        documentId: string;
+        scope: string;
+        branch: string;
+        lastUpdated: string;
+        revision: number;
+    }[]>;
+}
+//# sourceMappingURL=sequelize.d.ts.map