document-drive 1.0.0-websockets → 1.0.0

package/src/storage/filesystem.ts

@@ -1,296 +1,297 @@
-import { DocumentDriveAction } from 'document-model-libs/document-drive';
-import { BaseAction, DocumentHeader, Operation, OperationScope } from 'document-model/document';
-import type { Dirent } from 'fs';
+import { DocumentDriveAction } from "document-model-libs/document-drive";
 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 type { SynchronizationUnitQuery } from '../server/types';
-import { mergeOperations } from '../utils';
-import { DocumentDriveStorage, DocumentStorage, IDriveStorage } from './types';
+  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;
+  errno: number;
+  code: string;
+  syscall: string;
+  path: string;
 };
 
 function ensureDir(dir: string) {
-    if (!existsSync(dir)) {
-        mkdirSync(dir, { recursive: true });
-    }
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
 }
 
 export class FilesystemStorage implements IDriveStorage {
-    private basePath: string;
-    private drivesPath: string;
-    private static DRIVES_DIR = 'drives';
+  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);
-    }
+  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`;
-    }
+  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;
+  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;
 
-    checkDocumentExists(drive: string, id: string): Promise<boolean> {
-        const documentExists = existsSync(this._buildDocumentPath(drive, id));
-        return Promise.resolve(documentExists);
+        // checks if file is document
+        await this.getDocument(drive, documentId);
+        documents.push(documentId);
+      } catch {
+        /* Ignore invalid document*/
+      }
     }
+    return documents;
+  }
 
-    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`);
-        }
-    }
+  checkDocumentExists(drive: string, id: string): Promise<boolean> {
+    const documentExists = existsSync(this._buildDocumentPath(drive, id));
+    return Promise.resolve(documentExists);
+  }
 
-    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 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 clearStorage() {
-        const drivesPath = path.join(
-            this.basePath,
-            FilesystemStorage.DRIVES_DIR
-        );
+  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();
+  }
 
-        // delete content of drives directory
-        const drives = (
-            await fs.readdir(drivesPath, {
-                withFileTypes: true,
-                recursive: true
-            })
-        ).filter(dirent => !!dirent.name);
+  async clearStorage() {
+    const drivesPath = path.join(this.basePath, FilesystemStorage.DRIVES_DIR);
 
-        await Promise.all(
-            drives.map(async dirent => {
-                await fs.rm(path.join(drivesPath, dirent.name), {
-                    recursive: true
-                });
-            })
-        );
+    // delete content of drives directory
+    const drives = (
+      await fs.readdir(drivesPath, {
+        withFileTypes: true,
+        recursive: true,
+      })
+    ).filter((dirent) => !!dirent.name);
 
-        // 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
-                });
-            })
-        );
-    }
+    await Promise.all(
+      drives.map(async (dirent) => {
+        await fs.rm(path.join(drivesPath, dirent.name), {
+          recursive: true,
+        });
+      }),
+    );
 
-    async deleteDocument(drive: string, id: string) {
-        return fs.rm(this._buildDocumentPath(drive, id));
-    }
+    // delete files in basePath
+    const files = (
+      await fs.readdir(this.basePath, { withFileTypes: true })
+    ).filter(
+      (file) => file.name !== FilesystemStorage.DRIVES_DIR && !!file.name,
+    );
 
-    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`);
-        }
+    await Promise.all(
+      files.map(async (dirent) => {
+        await fs.rm(path.join(this.basePath, dirent.name), {
+          recursive: true,
+        });
+      }),
+    );
+  }
 
-        const mergedOperations = mergeOperations(
-            document.operations,
-            operations
-        );
+  async deleteDocument(drive: string, id: string) {
+    return fs.rm(this._buildDocumentPath(drive, id));
+  }
 
-        await this.createDocument(drive, id, {
-            ...document,
-            ...header,
-            operations: mergedOperations
-        });
+  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`);
     }
 
-    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;
+    const mergedOperations = mergeOperations(document.operations, operations);
 
-                // checks if file is drive
-                await this.getDrive(driveId);
-                drives.push(driveId);
-            } catch {
-                /* Ignore invalid drive document found on drives dir */
-            }
-        }
-        return drives;
-    }
+    await this.createDocument(drive, id, {
+      ...document,
+      ...header,
+      operations: mergedOperations,
+    });
+  }
 
-    async getDrive(id: string) {
-        try {
-            return (await this.getDocument(
-                FilesystemStorage.DRIVES_DIR,
-                id
-            )) as DocumentDriveStorage;
-        } catch {
-            throw new Error(`Drive with id ${id} not found`);
-        }
-    }
+  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;
 
-    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`);
+        // checks if file is drive
+        await this.getDrive(driveId);
+        drives.push(driveId);
+      } catch {
+        /* Ignore invalid drive document found on drives dir */
+      }
     }
+    return drives;
+  }
 
-    createDrive(id: string, drive: DocumentDriveStorage) {
-        return this.createDocument(FilesystemStorage.DRIVES_DIR, id, drive);
+  async getDrive(id: string) {
+    try {
+      return (await this.getDocument(
+        FilesystemStorage.DRIVES_DIR,
+        id,
+      )) as DocumentDriveStorage;
+    } catch {
+      throw new DriveNotFoundError(id);
     }
+  }
 
-    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 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`);
+  }
 
-    async addDriveOperations(
-        id: string,
-        operations: Operation<DocumentDriveAction | BaseAction>[],
-        header: DocumentHeader
-    ): Promise<void> {
-        const drive = await this.getDrive(id);
-        const mergedOperations = mergeOperations(drive.operations, operations);
+  createDrive(id: string, drive: DocumentDriveStorage) {
+    return this.createDocument(FilesystemStorage.DRIVES_DIR, id, drive);
+  }
 
-        await this.createDrive(id, {
-            ...drive,
-            ...header,
-            operations: mergedOperations
-        });
-    }
+  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 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;
-        }, []);
-    }
+  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 +1,2 @@
-export type * from './types';
+export * from "./base";
+export type * from "./types";