document-drive 1.0.0-websockets → 1.0.0

package/src/storage/memory.ts

@@ -1,219 +1,211 @@
-import { DocumentDriveAction } from 'document-model-libs/document-drive';
+import { DocumentDriveAction } from "document-model-libs/document-drive";
 import {
-    BaseAction,
-    Document,
-    DocumentHeader,
-    Operation,
-    OperationScope
-} from 'document-model/document';
-import {
-    DocumentDriveStorage,
-    DocumentStorage,
-    IDriveStorage,
-} from './types';
-import type { SynchronizationUnitQuery } from '../server/types';
-import { mergeOperations } from '../utils';
+  BaseAction,
+  Document,
+  DocumentHeader,
+  Operation,
+  OperationScope,
+} from "document-model/document";
+import { DriveNotFoundError } from "../server/error";
+import type { SynchronizationUnitQuery } from "../server/types";
+import { mergeOperations } from "../utils";
+import { DocumentDriveStorage, DocumentStorage, IDriveStorage } from "./types";
 
 export class MemoryStorage implements IDriveStorage {
-    private documents: Record<string, Record<string, DocumentStorage>>;
-    private drives: Record<string, DocumentDriveStorage>;
-    private slugToDriveId: Record<string, string> = {};
-
-    constructor() {
-        this.documents = {};
-        this.drives = {};
-    }
-
-    checkDocumentExists(drive: string, id: string): Promise<boolean> {
-        return Promise.resolve(this.documents[drive]?.[id] !== undefined);
-    }
-
-    async getDocuments(drive: string) {
-        return Object.keys(this.documents[drive] ?? {});
-    }
-
-    async getDocument(driveId: string, id: string) {
-        const drive = this.documents[driveId];
-        if (!drive) {
-            throw new Error(`Drive with id ${driveId} not found`);
-        }
-        const document = drive[id];
-        if (!document) {
-            throw new Error(`Document with id ${id} not found`);
-        }
-
-        return document;
-    }
-
-    async saveDocument(drive: string, id: string, document: Document) {
-        this.documents[drive] = this.documents[drive] ?? {};
-        this.documents[drive]![id] = document;
-    }
-
-    async clearStorage(): Promise<void> {
-        this.documents = {};
-        this.drives = {};
-    }
-
-    async createDocument(drive: string, id: string, document: DocumentStorage) {
-        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: string,
-        id: string,
-        operations: Operation[],
-        header: DocumentHeader
-    ): Promise<void> {
-        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: string, id: string) {
-        if (!this.documents[drive]) {
-            throw new Error(`Drive with id ${drive} not found`);
-        }
-        delete this.documents[drive]![id];
-    }
-
-    async getDrives() {
-        return Object.keys(this.drives);
-    }
-
-    async getDrive(id: string) {
-        const drive = this.drives[id];
-        if (!drive) {
-            throw new Error(`Drive with id ${id} not found`);
-        }
-        return drive;
-    }
-
-    async getDriveBySlug(slug: string) {
-        const driveId = this.slugToDriveId[slug];
-        if (!driveId) {
-            throw new Error(`Drive with slug ${slug} not found`);
+  private documents: Record<string, Record<string, DocumentStorage>>;
+  private drives: Record<string, DocumentDriveStorage>;
+  private slugToDriveId: Record<string, string> = {};
+
+  constructor() {
+    this.documents = {};
+    this.drives = {};
+  }
+
+  checkDocumentExists(drive: string, id: string): Promise<boolean> {
+    return Promise.resolve(this.documents[drive]?.[id] !== undefined);
+  }
+
+  async getDocuments(drive: string) {
+    return Object.keys(this.documents[drive] ?? {});
+  }
+
+  async getDocument(driveId: string, id: string) {
+    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: string, id: string, document: Document) {
+    this.documents[drive] = this.documents[drive] ?? {};
+    this.documents[drive][id] = document;
+  }
+
+  async clearStorage(): Promise<void> {
+    this.documents = {};
+    this.drives = {};
+  }
+
+  async createDocument(drive: string, id: string, document: DocumentStorage) {
+    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: string,
+    id: string,
+    operations: Operation[],
+    header: DocumentHeader,
+  ): Promise<void> {
+    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: string, id: string) {
+    if (!this.documents[drive]) {
+      throw new DriveNotFoundError(drive);
+    }
+    delete this.documents[drive][id];
+  }
+
+  async getDrives() {
+    return Object.keys(this.drives);
+  }
+
+  async getDrive(id: string) {
+    const drive = this.drives[id];
+    if (!drive) {
+      throw new DriveNotFoundError(id);
+    }
+    return drive;
+  }
+
+  async getDriveBySlug(slug: string) {
+    const driveId = this.slugToDriveId[slug];
+    if (!driveId) {
+      throw new Error(`Drive with slug ${slug} not found`);
+    }
+    return this.getDrive(driveId);
+  }
+
+  async createDrive(id: string, drive: DocumentDriveStorage) {
+    this.drives[id] = drive;
+    this.documents[id] = {};
+    const { slug } = drive.initialState.state.global;
+    if (slug) {
+      this.slugToDriveId[slug] = id;
+    }
+  }
+
+  async addDriveOperations(
+    id: string,
+    operations: Operation<DocumentDriveAction | BaseAction>[],
+    header: DocumentHeader,
+  ): Promise<void> {
+    const drive = await this.getDrive(id);
+    const mergedOperations = mergeOperations(drive.operations, operations);
+
+    this.drives[id] = {
+      ...drive,
+      ...header,
+      operations: mergedOperations,
+    };
+  }
+
+  async deleteDrive(id: string) {
+    delete this.documents[id];
+    delete this.drives[id];
+  }
+
+  async getSynchronizationUnitsRevision(
+    units: SynchronizationUnitQuery[],
+  ): Promise<
+    {
+      driveId: string;
+      documentId: string;
+      scope: string;
+      branch: string;
+      lastUpdated: string;
+      revision: number;
+    }[]
+  > {
+    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 as OperationScope].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 this.getDrive(driveId);
-    }
-
-    async createDrive(id: string, drive: DocumentDriveStorage) {
-        this.drives[id] = drive;
-        this.documents[id] = {};
-        const { slug } = drive.initialState.state.global;
-        if (slug) {
-            this.slugToDriveId[slug] = id;
-        }
-    }
-
-    async addDriveOperations(
-        id: string,
-        operations: Operation<DocumentDriveAction | BaseAction>[],
-        header: DocumentHeader
-    ): Promise<void> {
-        const drive = await this.getDrive(id);
-        const mergedOperations = mergeOperations(drive.operations, operations);
-
-        this.drives[id] = {
-            ...drive,
-            ...header,
-            operations: mergedOperations
-        };
-    }
-
-    async deleteDrive(id: string) {
-        delete this.documents[id];
-        delete this.drives[id];
-    }
-
-    async getSynchronizationUnitsRevision(
-        units: SynchronizationUnitQuery[]
-    ): Promise<
-        {
-            driveId: string;
-            documentId: string;
-            scope: string;
-            branch: string;
-            lastUpdated: string;
-            revision: number;
-        }[]
-    > {
-        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 as OperationScope]?.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<
-            {
-                driveId: string;
-                documentId: string;
-                scope: string;
-                branch: string;
-                lastUpdated: string;
-                revision: number;
-            }[]
-        >((acc, curr) => {
-            if (curr.status === 'fulfilled' && curr.value !== undefined) {
-                acc.push(curr.value);
-            }
-            return acc;
-        }, []);
-    }
+      }),
+    );
+    return results.reduce<
+      {
+        driveId: string;
+        documentId: string;
+        scope: string;
+        branch: string;
+        lastUpdated: string;
+        revision: number;
+      }[]
+    >((acc, curr) => {
+      if (curr.status === "fulfilled" && curr.value !== undefined) {
+        acc.push(curr.value);
+      }
+      return acc;
+    }, []);
+  }
 }