document-drive 1.0.0-websockets.1 → 1.0.1

package/src/server/utils.ts

@@ -1,35 +1,34 @@
-import type { Document, OperationScope } from 'document-model/document';
-import { RevisionsFilter, StrandUpdate } from './types';
+import type { Document, OperationScope } from "document-model/document";
+import { RevisionsFilter, StrandUpdate } from "./types";
 
 export function buildRevisionsFilter(
-    strands: StrandUpdate[],
-    driveId: string,
-    documentId: string
+  strands: StrandUpdate[],
+  driveId: string,
+  documentId: string,
 ): RevisionsFilter {
-    return strands.reduce<RevisionsFilter>((acc, s) => {
-        if (!(s.driveId === driveId && s.documentId === documentId)) {
-            return acc;
-        }
-        acc[s.scope] = s.operations[s.operations.length - 1]?.index ?? -1;
-        return acc;
-    }, {});
+  return strands.reduce<RevisionsFilter>((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 filterOperationsByRevision(
-    operations: Document['operations'],
-    revisions?: RevisionsFilter
-): Document['operations'] {
-    if (!revisions) {
-        return operations;
+  operations: Document["operations"],
+  revisions?: RevisionsFilter,
+): Document["operations"] {
+  if (!revisions) {
+    return operations;
+  }
+  return (Object.keys(operations) as OperationScope[]).reduce<
+    Document["operations"]
+  >((acc, scope) => {
+    const revision = revisions[scope];
+    if (revision !== undefined) {
+      acc[scope] = operations[scope].filter((op) => op.index <= revision);
     }
-    return (Object.keys(operations) as OperationScope[]).reduce<
-        Document['operations']
-    >((acc, scope) => {
-        const revision = revisions[scope];
-        if (revision !== undefined) {
-            acc[scope] = operations[scope].filter(op => op.index <= revision);
-        }
-        return acc;
-    }, operations);
+    return acc;
+  }, operations);
 }
-

package/src/storage/base.ts

@@ -0,0 +1,81 @@
+import { DocumentDriveAction } from "document-model-libs/document-drive";
+import { BaseAction, DocumentHeader, Operation } from "document-model/document";
+import { SynchronizationUnitQuery } from "../server";
+import {
+  DocumentDriveStorage,
+  DocumentStorage,
+  IDriveStorage,
+  IStorage,
+  IStorageDelegate,
+} from "./types";
+
+abstract class BaseStorage implements IStorage {
+  abstract checkDocumentExists(drive: string, id: string): Promise<boolean>;
+
+  abstract getDocuments(drive: string): Promise<string[]>;
+
+  abstract getDocument(drive: string, id: string): Promise<DocumentStorage>;
+
+  abstract createDocument(
+    drive: string,
+    id: string,
+    document: DocumentStorage,
+  ): Promise<void>;
+
+  abstract addDocumentOperations(
+    drive: string,
+    id: string,
+    operations: Operation[],
+    header: DocumentHeader,
+  ): Promise<void>;
+
+  abstract addDocumentOperationsWithTransaction?(
+    drive: string,
+    id: string,
+    callback: (document: DocumentStorage) => Promise<{
+      operations: Operation[];
+      header: DocumentHeader;
+    }>,
+  ): Promise<void>;
+
+  abstract deleteDocument(drive: string, id: string): Promise<void>;
+
+  abstract getOperationResultingState?(
+    drive: string,
+    id: string,
+    index: number,
+    scope: string,
+    branch: string,
+  ): Promise<unknown>;
+
+  abstract setStorageDelegate?(delegate: IStorageDelegate): void;
+
+  abstract getSynchronizationUnitsRevision(
+    units: SynchronizationUnitQuery[],
+  ): Promise<
+    {
+      driveId: string;
+      documentId: string;
+      scope: string;
+      branch: string;
+      lastUpdated: string;
+      revision: number;
+    }[]
+  >;
+}
+
+export abstract class BaseDriveStorage
+  extends BaseStorage
+  implements IDriveStorage
+{
+  abstract getDrives(): Promise<string[]>;
+  abstract getDrive(id: string): Promise<DocumentDriveStorage>;
+  abstract getDriveBySlug(slug: string): Promise<DocumentDriveStorage>;
+  abstract createDrive(id: string, drive: DocumentDriveStorage): Promise<void>;
+  abstract deleteDrive(id: string): Promise<void>;
+  abstract addDriveOperations(
+    id: string,
+    operations: Operation<DocumentDriveAction | BaseAction>[],
+    header: DocumentHeader,
+  ): Promise<void>;
+}

package/src/storage/browser.ts

@@ -1,221 +1,238 @@
-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 { mergeOperations, type SynchronizationUnitQuery } from '..';
-import {
-    DocumentDriveStorage,
-    DocumentStorage,
-    IDriveStorage,
-} from './types';
+  BaseAction,
+  Document,
+  DocumentHeader,
+  Operation,
+  OperationScope,
+} from "document-model/document";
+import LocalForage from "localforage";
+import { DriveNotFoundError } from "../server/error";
+import { SynchronizationUnitQuery } from "../server/types";
+import { mergeOperations } from "../utils";
+import { migrateDocumentOperationSigatures } from "../utils/migrations";
+import { DocumentDriveStorage, DocumentStorage, IDriveStorage } from "./types";
 
 export class BrowserStorage implements IDriveStorage {
-    private db: Promise<LocalForage>;
-
-    static DBName = 'DOCUMENT_DRIVES';
-    static SEP = ':';
-    static DRIVES_KEY = 'DRIVES';
-
-    constructor(namespace?: string) {
-        this.db = import('localforage').then(localForage =>
-            localForage.default.createInstance({
-                name: namespace
-                    ? `${namespace}:${BrowserStorage.DBName}`
-                    : BrowserStorage.DBName
-            })
-        );
-    }
-
-    buildKey(...args: string[]) {
-        return args.join(BrowserStorage.SEP);
-    }
-
-    async checkDocumentExists(drive: string, id: string): Promise<boolean> {
-        const document = await (
-            await this.db
-        ).getItem<Document>(this.buildKey(drive, id));
-        return document !== undefined;
-    }
-
-    async getDocuments(drive: string) {
-        const keys = await (await this.db).keys();
-        const driveKey = `${drive}${BrowserStorage.SEP}`;
-        return keys
-            .filter(key => key.startsWith(driveKey))
-            .map(key => key.slice(driveKey.length));
-    }
-
-    async getDocument(driveId: string, id: string) {
-        const document = await (
-            await this.db
-        ).getItem<Document>(this.buildKey(driveId, id));
-        if (!document) {
-            throw new Error(`Document with id ${id} not found`);
+  private db: Promise<LocalForage>;
+
+  static DBName = "DOCUMENT_DRIVES";
+  static SEP = ":";
+  static DRIVES_KEY = "DRIVES";
+
+  constructor(namespace?: string) {
+    this.db = LocalForage.ready().then(() =>
+      LocalForage.createInstance({
+        name: namespace
+          ? `${namespace}:${BrowserStorage.DBName}`
+          : BrowserStorage.DBName,
+      }),
+    );
+  }
+
+  buildKey(...args: string[]) {
+    return args.join(BrowserStorage.SEP);
+  }
+
+  async checkDocumentExists(drive: string, id: string): Promise<boolean> {
+    const document = await (
+      await this.db
+    ).getItem<Document>(this.buildKey(drive, id));
+    return !!document;
+  }
+
+  async getDocuments(drive: string) {
+    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: string, id: string) {
+    const document = await (
+      await this.db
+    ).getItem<Document>(this.buildKey(driveId, id));
+    if (!document) {
+      throw new Error(`Document with id ${id} not found`);
+    }
+    return document;
+  }
+
+  async createDocument(drive: string, id: string, document: DocumentStorage) {
+    await (await this.db).setItem(this.buildKey(drive, id), document);
+  }
+
+  async deleteDocument(drive: string, id: string) {
+    await (await this.db).removeItem(this.buildKey(drive, id));
+  }
+
+  async clearStorage(): Promise<void> {
+    return (await this.db).clear();
+  }
+
+  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);
+
+    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: string) {
+    const db = await this.db;
+    const drive = await db.getItem<DocumentDriveStorage>(
+      this.buildKey(BrowserStorage.DRIVES_KEY, id),
+    );
+    if (!drive) {
+      throw new DriveNotFoundError(id);
+    }
+    return drive;
+  }
+
+  async getDriveBySlug(slug: string) {
+    // 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: string, drive: DocumentDriveStorage) {
+    const db = await this.db;
+    await db.setItem(this.buildKey(BrowserStorage.DRIVES_KEY, id), drive);
+  }
+
+  async deleteDrive(id: string) {
+    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: string,
+    operations: Operation<DocumentDriveAction | BaseAction>[],
+    header: DocumentHeader,
+  ): Promise<void> {
+    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: 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 document;
-    }
-
-    async createDocument(drive: string, id: string, document: DocumentStorage) {
-        await (await this.db).setItem(this.buildKey(drive, id), document);
-    }
-
-    async deleteDocument(drive: string, id: string) {
-        await (await this.db).removeItem(this.buildKey(drive, id));
-    }
-
-    async clearStorage(): Promise<void> {
-        return (await this.db).clear();
-    }
-
-    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
-        );
-
-        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: string) {
-        const drive = await (
-            await this.db
-        ).getItem<DocumentDriveStorage>(
-            this.buildKey(BrowserStorage.DRIVES_KEY, id)
-        );
-        if (!drive) {
-            throw new Error(`Drive with id ${id} not found`);
-        }
-        return drive;
-    }
-
-    async getDriveBySlug(slug: string) {
-        // 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: string, drive: DocumentDriveStorage) {
-        const db = await this.db;
-        await db.setItem(this.buildKey(BrowserStorage.DRIVES_KEY, id), drive);
-    }
-
-    async deleteDrive(id: string) {
-        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: string,
-        operations: Operation<DocumentDriveAction | BaseAction>[],
-        header: DocumentHeader
-    ): Promise<void> {
-        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: 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;
+    }, []);
+  }
+
+  // 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)),
+      );
+    }
+  }
+
+  private async migrateDocument(drive: string, id: string) {
+    const document = await this.getDocument(drive, id);
+    const migratedDocument = migrateDocumentOperationSigatures(document);
+    if (migratedDocument !== document) {
+      return (await this.db).setItem(
+        this.buildKey(drive, id),
+        migratedDocument,
+      );
+    }
+  }
 }