document-drive 0.0.4 → 0.0.6

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "document-drive",
-    "version": "0.0.4",
+    "version": "0.0.6",
     "license": "AGPL-3.0-only",
     "type": "module",
     "module": "./src/index.ts",
@@ -23,8 +23,9 @@
         "test:watch": "vitest watch"
     },
     "peerDependencies": {
-        "document-model": "^1.0.11",
-        "document-model-libs": "^1.1.14"
+        "document-model": "^1.0.13",
+        "document-model-libs": "^1.1.21",
+        "localforage": "^1.10.0"
     },
     "dependencies": {
         "sanitize-filename": "^1.6.3"
@@ -33,10 +34,12 @@
         "@typescript-eslint/eslint-plugin": "^6.12.0",
         "@typescript-eslint/parser": "^6.12.0",
         "@vitest/coverage-v8": "^0.34.6",
-        "document-model": "^1.0.11",
-        "document-model-libs": "^1.1.20",
+        "document-model": "^1.0.15",
+        "document-model-libs": "^1.1.23",
         "eslint": "^8.54.0",
         "eslint-config-prettier": "^9.0.0",
+        "fake-indexeddb": "^5.0.1",
+        "localforage": "^1.10.0",
         "prettier": "^3.1.0",
         "prettier-plugin-organize-imports": "^3.2.4",
         "typescript": "^5.3.2",

package/src/server/index.ts

@@ -1,9 +1,19 @@
-import { utils } from 'document-model-libs/document-drive';
-import { Document, DocumentModel, Operation } from 'document-model/document';
+import {
+    DocumentDriveAction,
+    DocumentDriveDocument,
+    utils
+} from 'document-model-libs/document-drive';
+import { BaseAction, DocumentModel, Operation } from 'document-model/document';
 import { IDriveStorage } from '../storage';
 import { MemoryStorage } from '../storage/memory';
 import { isDocumentDrive } from '../utils';
-import { CreateDocumentInput, DriveInput, IDocumentDriveServer } from './types';
+import {
+    CreateDocumentInput,
+    DriveInput,
+    IDocumentDriveServer,
+    IOperationResult,
+    SignalResult
+} from './types';
 
 export type * from './types';
 
@@ -67,47 +77,101 @@ export class DocumentDriveServer implements IDocumentDriveServer {
         return this.storage.deleteDocument(driveId, id);
     }
 
-    async addOperation(
-        drive: string,
-        id: string,
-        operation: Operation
-    ): Promise<Document> {
+    async addOperation(drive: string, id: string, operation: Operation) {
         // retrieves document from storage
         const document = await (id
             ? this.storage.getDocument(drive, id)
             : this.storage.getDrive(drive));
-
-        // retrieves the document's document model and
-        // applies operation using its reducer
-        const documentModel = this._getDocumentModel(document.documentType);
-        const signalResults: Promise<unknown>[] = [];
-        const newDocument = documentModel.reducer(
-            document,
-            operation,
-            signal => {
-                let result: Promise<unknown> | undefined = undefined;
-                switch (signal.type) {
-                    case 'CREATE_CHILD_DOCUMENT':
-                        result = this.createDocument(drive, signal.input);
-                        break;
-                    case 'DELETE_CHILD_DOCUMENT':
-                        result = this.deleteDocument(drive, signal.input.id);
-                        break;
-                }
-                if (result) {
-                    signalResults.push(result);
+        try {
+            // retrieves the document's document model and
+            // applies operation using its reducer
+            const documentModel = this._getDocumentModel(document.documentType);
+            const signalHandlers: Promise<SignalResult>[] = [];
+            const newDocument = documentModel.reducer(
+                document,
+                operation,
+                signal => {
+                    let handler: Promise<unknown> | undefined = undefined;
+                    switch (signal.type) {
+                        case 'CREATE_CHILD_DOCUMENT':
+                            handler = this.createDocument(drive, signal.input);
+                            break;
+                        case 'DELETE_CHILD_DOCUMENT':
+                            handler = this.deleteDocument(
+                                drive,
+                                signal.input.id
+                            );
+                            break;
+                        case 'COPY_CHILD_DOCUMENT':
+                            handler = this.getDocument(
+                                drive,
+                                signal.input.id
+                            ).then(documentToCopy =>
+                                this.createDocument(drive, {
+                                    id: signal.input.newId,
+                                    documentType: documentToCopy.documentType,
+                                    document: documentToCopy
+                                })
+                            );
+                            break;
+                    }
+                    if (handler) {
+                        signalHandlers.push(
+                            handler.then(result => ({ signal, result }))
+                        );
+                    }
                 }
+            );
+            const signals = await Promise.all(signalHandlers);
+
+            // saves the updated state of the document and returns it
+            if (id) {
+                await this.storage.saveDocument(drive, id, newDocument);
+            } else if (isDocumentDrive(newDocument)) {
+                await this.storage.saveDrive(newDocument);
+            } else {
+                throw new Error('Invalid document');
             }
-        );
-        await Promise.all(signalResults);
-        // saves the updated state of the document and returns it
-        if (id) {
-            await this.storage.saveDocument(drive, id, newDocument);
-        } else if (isDocumentDrive(newDocument)) {
-            await this.storage.saveDrive(newDocument);
-        } else {
-            throw new Error('Invalid document');
+            return {
+                success: true,
+                document: newDocument,
+                operation,
+                signals
+            };
+        } catch (error) {
+            return {
+                success: false,
+                error: error as Error,
+                document,
+                operation,
+                signals: []
+            };
         }
-        return newDocument;
+    }
+
+    async addOperations(drive: string, id: string, operations: Operation[]) {
+        const results: IOperationResult[] = [];
+        for (const operation of operations) {
+            results.push(await this.addOperation(drive, id, operation));
+        }
+        return results;
+    }
+
+    addDriveOperation(
+        drive: string,
+        operation: Operation<DocumentDriveAction | BaseAction>
+    ) {
+        return this.addOperation(drive, '', operation) as Promise<
+            IOperationResult<DocumentDriveDocument>
+        >;
+    }
+
+    addDriveOperations(
+        drive: string,
+        operations: Operation<DocumentDriveAction | BaseAction>[]
+    ) {
+        return this.addOperations(drive, '', operations) as Promise<
+            IOperationResult<DocumentDriveDocument>[]
+        >;
     }
 }

package/src/server/types.ts

@@ -1,8 +1,14 @@
-import {
+import type {
+    DocumentDriveAction,
     DocumentDriveDocument,
     DocumentDriveState
 } from 'document-model-libs/document-drive';
-import { Document, Operation } from 'document-model/document';
+import type {
+    BaseAction,
+    Document,
+    Operation,
+    Signal
+} from 'document-model/document';
 
 export type DriveInput = Omit<
     DocumentDriveState,
@@ -15,9 +21,18 @@ export type CreateDocumentInput = {
     document?: Document;
 };
 
-export interface SortOptions {
-    afterNodePath?: string;
-}
+export type SignalResult = {
+    signal: Signal;
+    result: unknown; // infer from return types on document-model
+};
+
+export type IOperationResult<T extends Document = Document> = {
+    success: boolean;
+    error?: Error;
+    operation: Operation;
+    document: T;
+    signals: SignalResult[];
+};
 
 export interface IDocumentDriveServer {
     getDrives(): Promise<string[]>;
@@ -34,5 +49,19 @@ export interface IDocumentDriveServer {
         drive: string,
         id: string,
         operation: Operation
-    ): Promise<Document>;
+    ): Promise<IOperationResult>;
+    addOperations(
+        drive: string,
+        id: string,
+        operations: Operation[]
+    ): Promise<IOperationResult[]>;
+
+    addDriveOperation(
+        drive: string,
+        operation: Operation<DocumentDriveAction | BaseAction>
+    ): Promise<IOperationResult<DocumentDriveDocument>>;
+    addDriveOperations(
+        drive: string,
+        operations: Operation<DocumentDriveAction | BaseAction>[]
+    ): Promise<IOperationResult<DocumentDriveDocument>[]>;
 }

package/src/storage/browser.ts

@@ -0,0 +1,100 @@
+import { DocumentDriveDocument } from 'document-model-libs/document-drive';
+import { Document } from 'document-model/document';
+import { IDriveStorage } from './types';
+
+export class BrowserStorage implements IDriveStorage {
+    private db: Promise<LocalForage>;
+
+    static DBName = 'DOCUMENT_DRIVES';
+    static SEP = ':';
+    static DRIVES_KEY = 'DRIVES';
+
+    constructor() {
+        this.db = import('localforage').then(localForage =>
+            localForage.createInstance({
+                name: BrowserStorage.DBName
+            })
+        );
+    }
+
+    buildKey(...args: string[]) {
+        return args.join(BrowserStorage.SEP);
+    }
+
+    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`);
+        }
+        return document;
+    }
+
+    async saveDocument(drive: string, id: string, document: Document) {
+        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 getDrives() {
+        const drives =
+            (await (
+                await this.db
+            ).getItem<DocumentDriveDocument[]>(BrowserStorage.DRIVES_KEY)) ??
+            [];
+        return drives.map(drive => drive.state.id);
+    }
+
+    async getDrive(id: string) {
+        const drives =
+            (await (
+                await this.db
+            ).getItem<DocumentDriveDocument[]>(BrowserStorage.DRIVES_KEY)) ??
+            [];
+        const drive = drives.find(drive => drive.state.id === id);
+        if (!drive) {
+            throw new Error(`Drive with id ${id} not found`);
+        }
+        return drive;
+    }
+
+    async saveDrive(drive: DocumentDriveDocument) {
+        const db = await this.db;
+        const drives =
+            (await db.getItem<DocumentDriveDocument[]>(
+                BrowserStorage.DRIVES_KEY
+            )) ?? [];
+        const index = drives.findIndex(d => d.state.id === drive.state.id);
+        if (index > -1) {
+            drives[index] = drive;
+        } else {
+            drives.push(drive);
+        }
+        await db.setItem(BrowserStorage.DRIVES_KEY, drives);
+    }
+
+    async deleteDrive(id: string) {
+        const documents = await this.getDocuments(id);
+        await Promise.all(documents.map(doc => this.deleteDocument(id, doc)));
+        const db = await this.db;
+        const drives =
+            (await db.getItem<DocumentDriveDocument[]>(
+                BrowserStorage.DRIVES_KEY
+            )) ?? [];
+        await db.setItem(
+            BrowserStorage.DRIVES_KEY,
+            drives.filter(drive => drive.state.id !== id)
+        );
+    }
+}

package/src/storage/index.ts

@@ -1,3 +1,4 @@
+export { BrowserStorage } from './browser';
 export { FilesystemStorage } from './filesystem';
 export { MemoryStorage } from './memory';
 export type * from './types';

package/src/storage/memory.ts

@@ -56,6 +56,7 @@ export class MemoryStorage implements IDriveStorage {
     }
 
     async deleteDrive(id: string) {
+        delete this.documents[id];
         delete this.drives[id];
     }
 }