document-drive 1.19.0 → 1.20.0

package/src/storage/base.ts

@@ -1,81 +0,0 @@
-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,238 +0,0 @@
-import { DocumentDriveAction } from "document-model-libs/document-drive";
-import {
-  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 = 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 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,
-      );
-    }
-  }
-}

package/src/storage/filesystem.ts

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

package/src/storage/index.ts

@@ -1,2 +0,0 @@
-export * from "./base";
-export type * from "./types";