document-drive 1.0.0-websockets.1 → 1.0.1

package/src/storage/prisma.ts

@@ -1,417 +1,402 @@
-import { Prisma, PrismaClient } from '@prisma/client';
-import { PrismaClientKnownRequestError } from '@prisma/client/runtime/library';
+import { Prisma, PrismaClient } from "@prisma/client";
+import { PrismaClientKnownRequestError } from "@prisma/client/runtime/library";
 import {
-    DocumentDriveAction,
-    DocumentDriveLocalState,
-    DocumentDriveState
-} from 'document-model-libs/document-drive';
+  DocumentDriveAction,
+  DocumentDriveLocalState,
+  DocumentDriveState,
+} from "document-model-libs/document-drive";
 import type {
-    Action,
-    AttachmentInput,
-    BaseAction,
-    Document,
-    DocumentHeader,
-    DocumentOperations,
-    ExtendedState,
-    FileRegistry,
-    Operation,
-    OperationScope,
-    State
-} from 'document-model/document';
-import { IBackOffOptions, backOff } from 'exponential-backoff';
-import { ConflictOperationError } from '../server/error';
-import type { SynchronizationUnitQuery } from '../server/types';
-import { logger } from '../utils/logger';
+  Action,
+  AttachmentInput,
+  BaseAction,
+  Document,
+  DocumentHeader,
+  DocumentOperations,
+  ExtendedState,
+  FileRegistry,
+  Operation,
+  OperationScope,
+  State,
+} from "document-model/document";
+import { IBackOffOptions, backOff } from "exponential-backoff";
+import { ConflictOperationError, DriveNotFoundError } from "../server/error";
+import type { SynchronizationUnitQuery } from "../server/types";
+import { logger } from "../utils/logger";
 import {
-    DocumentDriveStorage,
-    DocumentStorage,
-    IDriveStorage,
-    IStorageDelegate
-} from './types';
+  DocumentDriveStorage,
+  DocumentStorage,
+  IDriveStorage,
+  IStorageDelegate,
+} from "./types";
 
 type Transaction =
-    | Omit<
-          PrismaClient<Prisma.PrismaClientOptions, never>,
-          | '$connect'
-          | '$disconnect'
-          | '$on'
-          | '$transaction'
-          | '$use'
-          | '$extends'
-      >
-    | ExtendedPrismaClient;
+  | Omit<
+      PrismaClient<Prisma.PrismaClientOptions, never>,
+      "$connect" | "$disconnect" | "$on" | "$transaction" | "$use" | "$extends"
+    >
+  | ExtendedPrismaClient;
 
 function storageToOperation(
-    op: Prisma.$OperationPayload['scalars'] & {
-        attachments?: AttachmentInput[];
-    }
+  op: Prisma.$OperationPayload["scalars"] & {
+    attachments?: AttachmentInput[];
+  },
 ): Operation {
-    const operation: 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 as OperationScope,
-        resultingState: op.resultingState
-            ? op.resultingState.toString()
-            : undefined,
-        attachments: op.attachments
-    };
-    if (op.context) {
-        operation.context = op.context as Prisma.JsonObject;
-    }
-    return operation;
+  const operation: 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 as OperationScope,
+    resultingState: op.resultingState
+      ? op.resultingState.toString()
+      : undefined,
+    attachments: op.attachments,
+  };
+  if (op.context) {
+    operation.context = op.context as Prisma.JsonObject;
+  }
+  return operation;
 }
 
 export type PrismaStorageOptions = {
-    transactionRetryBackoff?: IBackOffOptions;
+  transactionRetryBackoff?: IBackOffOptions;
 };
 
 function getRetryTransactionsClient<T extends PrismaClient>(
-    prisma: T,
-    backOffOptions?: Partial<IBackOffOptions>
+  prisma: T,
+  backOffOptions?: Partial<IBackOffOptions>,
 ) {
-    return prisma.$extends({
-        client: {
-            $transaction: (...args: Parameters<T['$transaction']>) => {
-                // eslint-disable-next-line prefer-spread
-                return backOff(() => prisma.$transaction.apply(prisma, args), {
-                    retry: e => {
-                        // 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
-                        return (e as { code: string }).code === 'P2034';
-                    },
-                    ...backOffOptions
-                });
+  return prisma.$extends({
+    client: {
+      $transaction: (...args: Parameters<T["$transaction"]>) => {
+        // eslint-disable-next-line prefer-spread
+        return backOff(() => prisma.$transaction.apply(prisma, args), {
+          retry: (e) => {
+            const code = (e as { code: string }).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,
+        });
+      },
+    },
+  });
 }
 
 type ExtendedPrismaClient = ReturnType<
-    typeof getRetryTransactionsClient<PrismaClient>
+  typeof getRetryTransactionsClient<PrismaClient>
 >;
 
 export class PrismaStorage implements IDriveStorage {
-    private db: ExtendedPrismaClient;
-    private delegate: IStorageDelegate | undefined;
-
-    constructor(db: PrismaClient, options?: PrismaStorageOptions) {
-        const backOffOptions = options?.transactionRetryBackoff;
-        this.db = getRetryTransactionsClient(db, {
-            ...backOffOptions,
-            jitter: backOffOptions?.jitter ?? 'full'
-        });
-    }
-
-    setStorageDelegate(delegate: IStorageDelegate): void {
-        this.delegate = delegate;
-    }
-
-    async createDrive(id: string, drive: DocumentDriveStorage): Promise<void> {
-        // drive for all drive documents
-        await this.createDocument('drives', id, drive as DocumentStorage);
-        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: string,
-        operations: Operation[],
-        header: DocumentHeader
-    ): Promise<void> {
-        await this.addDocumentOperations('drives', id, operations, header);
-    }
-
-    async addDriveOperationsWithTransaction(
-        drive: string,
-        callback: (document: DocumentDriveStorage) => Promise<{
-            operations: Operation<DocumentDriveAction | BaseAction>[];
-            header: DocumentHeader;
-        }>
-    ) {
-        return this.addDocumentOperationsWithTransaction(
-            'drives',
-            drive,
-            document => callback(document as DocumentDriveStorage)
-        );
-    }
-
-    async createDocument(
-        drive: string,
-        id: string,
-        document: DocumentStorage
-    ): Promise<void> {
-        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
-            }
-        });
-    }
-
-    private async _addDocumentOperations(
-        tx: Transaction,
-        drive: string,
-        id: string,
-        operations: Operation[],
-        header: DocumentHeader
-    ): Promise<void> {
-        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',
-                    skip: op.skip,
-                    context: op.context,
-                    resultingState: op.resultingState
-                        ? Buffer.from(JSON.stringify(op.resultingState))
-                        : undefined
-                }))
-            });
-
-            await tx.document.updateMany({
-                where: {
-                    id,
-                    driveId: drive
+  private db: ExtendedPrismaClient;
+  private delegate: IStorageDelegate | undefined;
+
+  constructor(db: PrismaClient, options?: PrismaStorageOptions) {
+    const backOffOptions = options?.transactionRetryBackoff;
+    this.db = getRetryTransactionsClient(db, {
+      ...backOffOptions,
+      jitter: backOffOptions?.jitter ?? "full",
+    });
+  }
+
+  setStorageDelegate(delegate: IStorageDelegate): void {
+    this.delegate = delegate;
+  }
+
+  async createDrive(id: string, drive: DocumentDriveStorage): Promise<void> {
+    // drive for all drive documents
+    await this.createDocument("drives", id, drive as DocumentStorage);
+    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: string,
+    operations: Operation[],
+    header: DocumentHeader,
+  ): Promise<void> {
+    await this.addDocumentOperations("drives", id, operations, header);
+  }
+
+  async addDriveOperationsWithTransaction(
+    drive: string,
+    callback: (document: DocumentDriveStorage) => Promise<{
+      operations: Operation<DocumentDriveAction | BaseAction>[];
+      header: DocumentHeader;
+    }>,
+  ) {
+    return this.addDocumentOperationsWithTransaction(
+      "drives",
+      drive,
+      (document) => callback(document as DocumentDriveStorage),
+    );
+  }
+
+  async createDocument(
+    drive: string,
+    id: string,
+    document: DocumentStorage,
+  ): Promise<void> {
+    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,
+      },
+    });
+  }
+
+  private async _addDocumentOperations(
+    tx: Transaction,
+    drive: string,
+    id: string,
+    operations: Operation[],
+    header: DocumentHeader,
+  ): Promise<void> {
+    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 ?? [],
+                  },
                 },
-                data: {
-                    lastModified: header.lastModified,
-                    revision: JSON.stringify(header.revision)
-                }
+              },
             });
+          }),
+      );
+    } 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,
+            })),
+          },
+        });
 
-            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: string,
-        id: string,
-        callback: (document: DocumentStorage) => Promise<{
-            operations: Operation[];
-            header: DocumentHeader;
-            newState?: State<any, any> | undefined;
-        }>
-    ) {
-        let result: {
-            operations: Operation[];
-            header: DocumentHeader;
-            newState?: State<any, any> | undefined;
-        } | null = 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' }
+        const conflictOp = operations.find(
+          (op) =>
+            existingOperation?.index === op.index &&
+            existingOperation.scope === op.scope,
         );
 
-        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-        if (!result) {
-            throw new Error('No operations were provided');
+        if (!existingOperation || !conflictOp) {
+          console.error(e);
+          throw e;
+        } else {
+          throw new ConflictOperationError(
+            storageToOperation(existingOperation),
+            conflictOp,
+          );
         }
-
-        return result;
+      } else {
+        throw e;
+      }
     }
+  }
+
+  async addDocumentOperationsWithTransaction(
+    drive: string,
+    id: string,
+    callback: (document: DocumentStorage) => Promise<{
+      operations: Operation[];
+      header: DocumentHeader;
+      newState?: State<any, any> | undefined;
+    }>,
+  ) {
+    let result: {
+      operations: Operation[];
+      header: DocumentHeader;
+      newState?: State<any, any> | undefined;
+    } | null = 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);
 
-    async addDocumentOperations(
-        drive: string,
-        id: string,
-        operations: Operation[],
-        header: DocumentHeader
-    ): Promise<void> {
-        return this._addDocumentOperations(
-            this.db,
-            drive,
-            id,
-            operations,
-            header
-        );
-    }
-
-    async getDocuments(drive: string) {
-        const docs = await this.db.document.findMany({
-            select: {
-                id: true
-            },
-            where: {
-                AND: {
-                    driveId: drive,
-                    NOT: {
-                        id: 'drives'
-                    }
-                }
-            }
-        });
-
-        return docs.map(doc => doc.id);
-    }
+        const { operations, header, newState } = result;
+        return this._addDocumentOperations(tx, drive, id, operations, header);
+      },
+      { isolationLevel: "Serializable", maxWait: 10000, timeout: 20000 },
+    );
 
-    async checkDocumentExists(driveId: string, id: string) {
-        const count = await this.db.document.count({
-            where: {
-                id: id,
-                driveId: driveId
-            }
-        });
-        return count > 0;
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+    if (!result) {
+      throw new Error("No operations were provided");
     }
 
-    async getDocument(driveId: string, id: string, tx?: Transaction) {
-        const prisma = tx ?? this.db;
-        const result = await prisma.document.findUnique({
-            where: {
-                id_driveId: {
-                    driveId,
-                    id
-                }
-            }
-        });
+    return result;
+  }
+
+  async addDocumentOperations(
+    drive: string,
+    id: string,
+    operations: Operation[],
+    header: DocumentHeader,
+  ): Promise<void> {
+    return this._addDocumentOperations(this.db, drive, id, operations, header);
+  }
+
+  async getDocuments(drive: string) {
+    const docs = await this.db.document.findMany({
+      select: {
+        id: true,
+      },
+      where: {
+        AND: {
+          driveId: drive,
+          NOT: {
+            id: "drives",
+          },
+        },
+      },
+    });
 
-        if (result === null) {
-            throw new Error(`Document with id ${id} not found`);
-        }
+    return docs.map((doc) => doc.id);
+  }
 
-        const cachedOperations = (await this.delegate?.getCachedOperations(
-            driveId,
-            id
-        )) ?? {
-            global: [],
-            local: []
-        };
-        const scopeIndex = Object.keys(cachedOperations).reduceRight<
-            Record<OperationScope, number>
-        >(
-            (acc, value) => {
-                const scope = value as OperationScope;
-                const lastIndex = cachedOperations[scope]?.at(-1)?.index ?? -1;
-                acc[scope] = lastIndex;
-                return acc;
-            },
-            { global: -1, local: -1 }
-        );
+  async checkDocumentExists(driveId: string, id: string) {
+    const count = await this.db.document.count({
+      where: {
+        id: id,
+        driveId: driveId,
+      },
+    });
+    return count > 0;
+  }
+
+  async getDocument(driveId: string, id: string, tx?: Transaction) {
+    const prisma = tx ?? this.db;
+    const result = await prisma.document.findUnique({
+      where: {
+        id_driveId: {
+          driveId,
+          id,
+        },
+      },
+    });
 
-        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(', ')}))`
-        );
+    if (result === null) {
+      throw new Error(`Document with id ${id} not found`);
+    }
 
-        // retrieves operations with resulting state
-        // for the last operation of each scope
-        // TODO prevent SQL injection
-        const queryOperations = await prisma.$queryRawUnsafe<
-            Prisma.$OperationPayload['scalars'][]
-        >(
-            `WITH ranked_operations AS (
+    const cachedOperations = (await this.delegate?.getCachedOperations(
+      driveId,
+      id,
+    )) ?? {
+      global: [],
+      local: [],
+    };
+    const scopeIndex = Object.keys(cachedOperations).reduceRight<
+      Record<OperationScope, number>
+    >(
+      (acc, value) => {
+        const scope = value as OperationScope;
+        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<
+      Prisma.$OperationPayload["scalars"][]
+    >(
+      `WITH ranked_operations AS (
             SELECT
                 *,
                 ROW_NUMBER() OVER (PARTITION BY scope ORDER BY index DESC) AS rn
@@ -435,212 +420,234 @@ export class PrismaStorage implements IDriveStorage {
             END AS "resultingState"
             FROM ranked_operations
             WHERE "driveId" = $1 AND "documentId" = $2
-            AND (${conditions.join(' OR ')})
+            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: FileRegistry = {};
-
-        const operationsByScope = queryOperations.reduce<
-            DocumentOperations<Action>
-        >((acc, operation) => {
-            const scope = operation.scope as OperationScope;
-            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: Document = {
-            created: dbDoc.created.toISOString(),
-            name: dbDoc.name ? dbDoc.name : '',
-            documentType: dbDoc.documentType,
-            initialState: JSON.parse(dbDoc.initialState) as ExtendedState<
-                DocumentDriveState,
-                DocumentDriveLocalState
-            >,
-            state: undefined,
-            lastModified: new Date(dbDoc.lastModified).toISOString(),
-            operations: operationsByScope,
-            clipboard: [],
-            revision: JSON.parse(dbDoc.revision) as Record<
-                OperationScope,
-                number
-            >,
-            attachments: {}
-        };
-        return doc;
-    }
-
-    async deleteDocument(drive: string, id: string) {
-        await this.db.document.delete({
-            where: {
-                id_driveId: {
-                    driveId: drive,
-                    id: id
-                }
-            },
-            include: {
-                operations: {
-                    include: {
-                        attachments: true
-                    }
-                }
-            }
-        });
-    }
+      driveId,
+      id,
+    );
+    const operationIds = queryOperations.map((o) => o.id);
+    const attachments = await prisma.attachment.findMany({
+      where: {
+        operationId: {
+          in: operationIds,
+        },
+      },
+    });
 
-    async getDrives() {
-        return this.getDocuments('drives');
+    // TODO add attachments from cached operations
+    const fileRegistry: FileRegistry = {};
+
+    const operationsByScope = queryOperations.reduce<
+      DocumentOperations<Action>
+    >((acc, operation) => {
+      const scope = operation.scope as OperationScope;
+      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: Document = {
+      created: dbDoc.created.toISOString(),
+      name: dbDoc.name ? dbDoc.name : "",
+      documentType: dbDoc.documentType,
+      initialState: JSON.parse(dbDoc.initialState) as ExtendedState<
+        DocumentDriveState,
+        DocumentDriveLocalState
+      >,
+      // @ts-expect-error TODO: fix as this should not be undefined
+      state: undefined,
+      lastModified: new Date(dbDoc.lastModified).toISOString(),
+      operations: operationsByScope,
+      clipboard: [],
+      revision: JSON.parse(dbDoc.revision) as Record<OperationScope, number>,
+      attachments: {},
+    };
+    return doc;
+  }
+
+  async deleteDocument(drive: string, id: string) {
+    try {
+      await this.db.document.deleteMany({
+        where: {
+          driveId: drive,
+          id: id,
+        },
+      });
+    } catch (e: unknown) {
+      const prismaError = e as { code?: string; message?: string };
+      // 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 getDrive(id: string) {
-        try {
-            const doc = await this.getDocument('drives', id);
-            return doc as DocumentDriveStorage;
-        } catch (e) {
-            logger.error(e);
-            throw new Error(`Drive with id ${id} not found`);
-        }
+  }
+
+  async getDrives() {
+    return this.getDocuments("drives");
+  }
+
+  async getDrive(id: string) {
+    try {
+      const doc = await this.getDocument("drives", id);
+      return doc as DocumentDriveStorage;
+    } catch (e) {
+      logger.error(e);
+      throw new DriveNotFoundError(id);
     }
+  }
 
-    async getDriveBySlug(slug: string) {
-        const driveEntity = await this.db.drive.findFirst({
-            where: {
-                slug
-            }
-        });
-
-        if (!driveEntity) {
-            throw new Error(`Drive with slug ${slug} not found`);
-        }
+  async getDriveBySlug(slug: string) {
+    const driveEntity = await this.db.drive.findFirst({
+      where: {
+        slug,
+      },
+    });
 
-        return this.getDrive(driveEntity.id);
+    if (!driveEntity) {
+      throw new Error(`Drive with slug ${slug} not found`);
     }
 
-    async deleteDrive(id: string) {
-        // delete drive documents and operations
-        await this.db.document.deleteMany({
-            where: {
-                driveId: id
-            }
-        });
-
-        // delete drive and associated slug
-        await this.db.drive.deleteMany({
-            where: {
-                id
-            }
-        });
-
-        // delete drive itself
-        await this.deleteDocument('drives', id);
-    }
+    return this.getDrive(driveEntity.id);
+  }
 
-    async getOperationResultingState(
-        driveId: string,
-        documentId: string,
-        index: number,
-        scope: string,
-        branch: string
-    ): Promise<unknown> {
-        const operation = await this.db.operation.findUnique({
-            where: {
-                unique_operation: {
-                    driveId,
-                    documentId,
-                    index,
-                    scope,
-                    branch
-                }
-            }
-        });
-        return operation?.resultingState?.toString();
-    }
+  async deleteDrive(id: string) {
+    // delete drive and associated slug
+    await this.db.drive.deleteMany({
+      where: {
+        id,
+      },
+    });
 
-    getDriveOperationResultingState(
-        drive: string,
-        index: number,
-        scope: string,
-        branch: string
-    ): Promise<unknown> {
-        return this.getOperationResultingState(
-            'drives',
-            drive,
-            index,
-            scope,
-            branch
-        );
-    }
+    // delete drive document and its operations
+    await this.deleteDocument("drives", id);
 
-    async getSynchronizationUnitsRevision(
-        units: SynchronizationUnitQuery[]
-    ): Promise<
-        {
-            driveId: string;
-            documentId: string;
-            scope: string;
-            branch: string;
-            lastUpdated: string;
-            revision: number;
-        }[]
-    > {
-        // 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 = `
+    // deletes all documents of the drive
+    await this.db.document.deleteMany({
+      where: {
+        driveId: id,
+      },
+    });
+  }
+
+  async getOperationResultingState(
+    driveId: string,
+    documentId: string,
+    index: number,
+    scope: string,
+    branch: string,
+  ): Promise<unknown> {
+    const operation = await this.db.operation.findUnique({
+      where: {
+        unique_operation: {
+          driveId,
+          documentId,
+          index,
+          scope,
+          branch,
+        },
+      },
+    });
+    return operation?.resultingState?.toString();
+  }
+
+  getDriveOperationResultingState(
+    drive: string,
+    index: number,
+    scope: string,
+    branch: string,
+  ): Promise<unknown> {
+    return this.getOperationResultingState(
+      "drives",
+      drive,
+      index,
+      scope,
+      branch,
+    );
+  }
+
+  async getSynchronizationUnitsRevision(
+    units: SynchronizationUnitQuery[],
+  ): Promise<
+    {
+      driveId: string;
+      documentId: string;
+      scope: string;
+      branch: string;
+      lastUpdated: string;
+      revision: number;
+    }[]
+  > {
+    // 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<
-            {
-                driveId: string;
-                documentId: string;
-                lastUpdated: string;
-                scope: OperationScope;
-                branch: string;
-                revision: number;
-            }[]
-        >(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()
-        }));
-    }
+    const params = units
+      .map((unit) => [
+        unit.documentId ? unit.driveId : "drives",
+        unit.documentId || unit.driveId,
+        unit.scope,
+      ])
+      .flat();
+    const results = await this.db.$queryRawUnsafe<
+      {
+        driveId: string;
+        documentId: string;
+        lastUpdated: string;
+        scope: OperationScope;
+        branch: string;
+        revision: number;
+      }[]
+    >(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;
+  }
 }