document-drive 0.0.21 → 0.0.23

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "document-drive",
-    "version": "0.0.21",
+    "version": "0.0.23",
     "license": "AGPL-3.0-only",
     "type": "module",
     "module": "./src/index.ts",
@@ -25,26 +25,29 @@
         "test:watch": "vitest watch"
     },
     "peerDependencies": {
-        "document-model": "^1.0.17",
-        "document-model-libs": "^1.1.26",
+        "document-model": "^1.0.20",
+        "document-model-libs": "^1.1.27",
         "localforage": "^1.10.0"
     },
     "dependencies": {
+        "@prisma/client": "5.7.1",
         "sanitize-filename": "^1.6.3"
     },
     "devDependencies": {
-        "@typescript-eslint/eslint-plugin": "^6.12.0",
-        "@typescript-eslint/parser": "^6.12.0",
+        "@total-typescript/ts-reset": "^0.5.1",
+        "@typescript-eslint/eslint-plugin": "^6.18.1",
+        "@typescript-eslint/parser": "^6.18.1",
         "@vitest/coverage-v8": "^0.34.6",
-        "document-model": "^1.0.17",
-        "document-model-libs": "^1.1.26",
-        "eslint": "^8.54.0",
-        "eslint-config-prettier": "^9.0.0",
+        "document-model": "^1.0.20",
+        "document-model-libs": "^1.1.27",
+        "eslint": "^8.56.0",
+        "eslint-config-prettier": "^9.1.0",
         "fake-indexeddb": "^5.0.1",
         "localforage": "^1.10.0",
-        "prettier": "^3.1.0",
+        "prettier": "^3.1.1",
         "prettier-plugin-organize-imports": "^3.2.4",
-        "typescript": "^5.3.2",
+        "prisma": "^5.8.0",
+        "typescript": "^5.3.3",
         "vitest": "^0.34.6"
     }
 }

package/src/server/index.ts

@@ -1,17 +1,17 @@
+import { DocumentDriveAction, utils } from 'document-model-libs/document-drive';
 import {
-    DocumentDriveAction,
-    DocumentDriveDocument,
-    utils
-} from 'document-model-libs/document-drive';
-import { BaseAction, DocumentModel, Operation } from 'document-model/document';
-import { IDriveStorage } from '../storage';
+    BaseAction,
+    DocumentModel,
+    Operation,
+    utils as baseUtils
+} from 'document-model/document';
+import { DocumentStorage, IDriveStorage } from '../storage';
 import { MemoryStorage } from '../storage/memory';
 import { isDocumentDrive } from '../utils';
 import {
     CreateDocumentInput,
     DriveInput,
     IDocumentDriveServer,
-    IOperationResult,
     SignalResult
 } from './types';
 
@@ -39,11 +39,23 @@ export class DocumentDriveServer implements IDocumentDriveServer {
         return documentModel;
     }
 
-    addDrive(drive: DriveInput) {
+    async addDrive(drive: DriveInput) {
+        const id = drive.global.id;
+        if (!id) {
+            throw new Error('Invalid Drive Id');
+        }
+        try {
+            const driveStorage = await this.storage.getDrive(id);
+            if (driveStorage) {
+                throw new Error('Drive already exists');
+            }
+        } catch {
+            // ignore error has it means drive does not exist already
+        }
         const document = utils.createDocument({
             state: drive
         });
-        return this.storage.saveDrive(document);
+        return this.storage.createDrive(id, document);
     }
 
     deleteDrive(id: string) {
@@ -54,12 +66,38 @@ export class DocumentDriveServer implements IDocumentDriveServer {
         return this.storage.getDrives();
     }
 
-    getDrive(drive: string) {
-        return this.storage.getDrive(drive);
+    async getDrive(drive: string) {
+        const driveStorage = await this.storage.getDrive(drive);
+        const documentModel = this._getDocumentModel(driveStorage.documentType);
+        const document = baseUtils.replayDocument(
+            driveStorage.initialState,
+            driveStorage.operations,
+            documentModel.reducer,
+            undefined,
+            driveStorage
+        );
+        if (!isDocumentDrive(document)) {
+            throw new Error(
+                `Document with id ${drive} is not a Document Drive`
+            );
+        } else {
+            return document;
+        }
     }
 
-    getDocument(drive: string, id: string) {
-        return this.storage.getDocument(drive, id);
+    async getDocument(drive: string, id: string) {
+        const { initialState, operations, ...header } =
+            await this.storage.getDocument(drive, id);
+
+        const documentModel = this._getDocumentModel(header.documentType);
+
+        return baseUtils.replayDocument(
+            initialState,
+            operations,
+            documentModel.reducer,
+            undefined,
+            header
+        );
     }
 
     getDocuments(drive: string) {
@@ -72,25 +110,35 @@ export class DocumentDriveServer implements IDocumentDriveServer {
         // TODO validate input.document is of documentType
         const document = input.document ?? documentModel.utils.createDocument();
 
-        return this.storage.saveDocument(driveId, input.id, document);
+        return this.storage.createDocument(driveId, input.id, document);
     }
 
-    async deleteDocument(driveId: string, id: string): Promise<void> {
+    async deleteDocument(driveId: string, id: string) {
         return this.storage.deleteDocument(driveId, id);
     }
 
-    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));
-        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,
+    private async _performOperations(
+        drive: string,
+        documentStorage: DocumentStorage,
+        operations: Operation[]
+    ) {
+        const documentModel = this._getDocumentModel(
+            documentStorage.documentType
+        );
+        const document = baseUtils.replayDocument(
+            documentStorage.initialState,
+            documentStorage.operations,
+            documentModel.reducer,
+            undefined,
+            documentStorage
+        );
+
+        const signalResults: SignalResult[] = [];
+        let newDocument = document;
+        for (const operation of operations) {
+            const operationSignals: Promise<SignalResult>[] = [];
+            newDocument = documentModel.reducer(
+                newDocument,
                 operation,
                 signal => {
                     let handler: Promise<unknown> | undefined = undefined;
@@ -118,62 +166,105 @@ export class DocumentDriveServer implements IDocumentDriveServer {
                             break;
                     }
                     if (handler) {
-                        signalHandlers.push(
+                        operationSignals.push(
                             handler.then(result => ({ signal, result }))
                         );
                     }
                 }
             );
-            const signals = await Promise.all(signalHandlers);
+            const results = await Promise.all(operationSignals);
+            signalResults.push(...results);
+        }
+        return { document: newDocument, signals: signalResults };
+    }
+
+    addOperation(drive: string, id: string, operation: Operation) {
+        return this.addOperations(drive, id, [operation]);
+    }
+
+    async addOperations(drive: string, id: string, operations: Operation[]) {
+        // retrieves document from storage
+        const documentStorage = await this.storage.getDocument(drive, id);
+        try {
+            // retrieves the document's document model and
+            // applies the operations using its reducer
+            const { document, signals } = await this._performOperations(
+                drive,
+                documentStorage,
+                operations
+            );
 
             // 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 this.storage.addDocumentOperations(
+                drive,
+                id,
+                operations,
+                document
+            );
+
             return {
                 success: true,
-                document: newDocument,
-                operation,
+                document,
+                operations,
                 signals
             };
         } catch (error) {
             return {
                 success: false,
                 error: error as Error,
-                document,
-                operation,
+                document: undefined,
+                operations,
                 signals: []
             };
         }
     }
 
-    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>
-        >;
+        return this.addDriveOperations(drive, [operation]);
     }
 
-    addDriveOperations(
+    async addDriveOperations(
         drive: string,
         operations: Operation<DocumentDriveAction | BaseAction>[]
     ) {
-        return this.addOperations(drive, '', operations) as Promise<
-            IOperationResult<DocumentDriveDocument>[]
-        >;
+        // retrieves document from storage
+        const documentStorage = await this.storage.getDrive(drive);
+        try {
+            // retrieves the document's document model and
+            // applies the operations using its reducer
+            const { document, signals } = await this._performOperations(
+                drive,
+                documentStorage,
+                operations
+            );
+
+            if (isDocumentDrive(document)) {
+                await this.storage.addDriveOperations(
+                    drive,
+                    operations, // TODO check?
+                    document
+                );
+            } else {
+                throw new Error('Invalid Document Drive document');
+            }
+
+            return {
+                success: true,
+                document,
+                operations,
+                signals
+            };
+        } catch (error) {
+            return {
+                success: false,
+                error: error as Error,
+                document: undefined,
+                operations,
+                signals: []
+            };
+        }
     }
 }

package/src/server/types.ts

@@ -31,8 +31,8 @@ export type SignalResult = {
 export type IOperationResult<T extends Document = Document> = {
     success: boolean;
     error?: Error;
-    operation: Operation;
-    document: T;
+    operations: Operation[];
+    document: T | undefined;
     signals: SignalResult[];
 };
 
@@ -56,7 +56,7 @@ export interface IDocumentDriveServer {
         drive: string,
         id: string,
         operations: Operation[]
-    ): Promise<IOperationResult[]>;
+    ): Promise<IOperationResult>;
 
     addDriveOperation(
         drive: string,
@@ -65,5 +65,5 @@ export interface IDocumentDriveServer {
     addDriveOperations(
         drive: string,
         operations: Operation<DocumentDriveAction | BaseAction>[]
-    ): Promise<IOperationResult<DocumentDriveDocument>[]>;
+    ): Promise<IOperationResult<DocumentDriveDocument>>;
 }

package/src/storage/browser.ts

@@ -1,6 +1,12 @@
-import { DocumentDriveDocument } from 'document-model-libs/document-drive';
-import { Document } from 'document-model/document';
-import { IDriveStorage } from './types';
+import { DocumentDriveAction } from 'document-model-libs/document-drive';
+import {
+    BaseAction,
+    Document,
+    DocumentHeader,
+    Operation
+} from 'document-model/document';
+import { mergeOperations } from '..';
+import { DocumentDriveStorage, DocumentStorage, IDriveStorage } from './types';
 
 export class BrowserStorage implements IDriveStorage {
     private db: Promise<LocalForage>;
@@ -39,7 +45,7 @@ export class BrowserStorage implements IDriveStorage {
         return document;
     }
 
-    async saveDocument(drive: string, id: string, document: Document) {
+    async createDocument(drive: string, id: string, document: DocumentStorage) {
         await (await this.db).setItem(this.buildKey(drive, id), document);
     }
 
@@ -47,56 +53,80 @@ export class BrowserStorage implements IDriveStorage {
         await (await this.db).removeItem(this.buildKey(drive, id));
     }
 
+    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
+        );
+
+        await (
+            await this.db
+        ).setItem(this.buildKey(drive, id), {
+            ...document,
+            ...header,
+            operations: mergedOperations
+        });
+    }
+
     async getDrives() {
-        const drives =
-            (await (
-                await this.db
-            ).getItem<DocumentDriveDocument[]>(BrowserStorage.DRIVES_KEY)) ??
-            [];
-        return drives.map(drive => drive.state.global.id);
+        const keys = (await (await this.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 drives =
-            (await (
-                await this.db
-            ).getItem<DocumentDriveDocument[]>(BrowserStorage.DRIVES_KEY)) ??
-            [];
-        const drive = drives.find(drive => drive.state.global.id === id);
+        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 saveDrive(drive: DocumentDriveDocument) {
+    async createDrive(id: string, drive: DocumentDriveStorage) {
         const db = await this.db;
-        const drives =
-            (await db.getItem<DocumentDriveDocument[]>(
-                BrowserStorage.DRIVES_KEY
-            )) ?? [];
-        const index = drives.findIndex(
-            d => d.state.global.id === drive.state.global.id
-        );
-        if (index > -1) {
-            drives[index] = drive;
-        } else {
-            drives.push(drive);
-        }
-        await db.setItem(BrowserStorage.DRIVES_KEY, drives);
+        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)));
-        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.global.id !== id)
+        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);
+
+        (await this.db).setItem(this.buildKey(BrowserStorage.DRIVES_KEY, id), {
+            ...drive,
+            ...header,
+            operations: mergedOperations
+        });
+        return;
+    }
 }

package/src/storage/filesystem.ts

@@ -1,5 +1,5 @@
-import { DocumentDriveDocument } from 'document-model-libs/document-drive';
-import { Document } from 'document-model/document';
+import { DocumentDriveAction } from 'document-model-libs/document-drive';
+import { BaseAction, DocumentHeader, Operation } from 'document-model/document';
 import type { Dirent } from 'fs';
 import {
     existsSync,
@@ -11,8 +11,8 @@ import {
 import fs from 'fs/promises';
 import path from 'path';
 import sanitize from 'sanitize-filename';
-import { isDocumentDrive } from '../utils';
-import { IDriveStorage } from './types';
+import { mergeOperations } from '..';
+import { DocumentDriveStorage, DocumentStorage, IDriveStorage } from './types';
 
 type FSError = {
     errno: number;
@@ -81,14 +81,14 @@ export class FilesystemStorage implements IDriveStorage {
             const content = readFileSync(this._buildDocumentPath(drive, id), {
                 encoding: 'utf-8'
             });
-            return JSON.parse(content);
+            return JSON.parse(content) as Promise<DocumentStorage>;
         } catch (error) {
             console.error(error);
             throw new Error(`Document with id ${id} not found`);
         }
     }
 
-    async saveDocument(drive: string, id: string, document: Document) {
+    async createDocument(drive: string, id: string, document: DocumentStorage) {
         const documentPath = this._buildDocumentPath(drive, id);
         await ensureDir(path.dirname(documentPath));
         await writeFileSync(documentPath, JSON.stringify(document), {
@@ -100,6 +100,29 @@ export class FilesystemStorage implements IDriveStorage {
         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
+        );
+
+        this.createDocument(drive, id, {
+            ...document,
+            ...header,
+            operations: mergedOperations
+        });
+    }
+
     async getDrives() {
         const files = await readdirSync(this.drivesPath, {
             withFileTypes: true
@@ -120,25 +143,18 @@ export class FilesystemStorage implements IDriveStorage {
     }
 
     async getDrive(id: string) {
-        let document: Document;
         try {
-            document = await this.getDocument(FilesystemStorage.DRIVES_DIR, id);
+            return (await this.getDocument(
+                FilesystemStorage.DRIVES_DIR,
+                id
+            )) as DocumentDriveStorage;
         } catch {
             throw new Error(`Drive with id ${id} not found`);
         }
-        if (isDocumentDrive(document)) {
-            return document;
-        } else {
-            throw new Error('Invalid drive document');
-        }
     }
 
-    saveDrive(drive: DocumentDriveDocument) {
-        return this.saveDocument(
-            FilesystemStorage.DRIVES_DIR,
-            drive.state.global.id,
-            drive
-        );
+    createDrive(id: string, drive: DocumentDriveStorage) {
+        return this.createDocument(FilesystemStorage.DRIVES_DIR, id, drive);
     }
 
     async deleteDrive(id: string) {
@@ -148,4 +164,19 @@ export class FilesystemStorage implements IDriveStorage {
             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);
+
+        this.createDrive(id, {
+            ...drive,
+            ...header,
+            operations: mergedOperations
+        });
+    }
 }

package/src/storage/index.ts

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

package/src/storage/memory.ts

@@ -1,10 +1,16 @@
-import { DocumentDriveDocument } from 'document-model-libs/document-drive';
-import { Document } from 'document-model/document';
-import { IDriveStorage } from './types';
+import { DocumentDriveAction } from 'document-model-libs/document-drive';
+import {
+    BaseAction,
+    Document,
+    DocumentHeader,
+    Operation
+} from 'document-model/document';
+import { mergeOperations } from '..';
+import { DocumentDriveStorage, DocumentStorage, IDriveStorage } from './types';
 
 export class MemoryStorage implements IDriveStorage {
-    private documents: Record<string, Record<string, Document>>;
-    private drives: Record<string, DocumentDriveDocument>;
+    private documents: Record<string, Record<string, DocumentStorage>>;
+    private drives: Record<string, DocumentDriveStorage>;
 
     constructor() {
         this.documents = {};
@@ -32,6 +38,51 @@ export class MemoryStorage implements IDriveStorage {
         this.documents[drive]![id] = document;
     }
 
+    async createDocument(drive: string, id: string, document: DocumentStorage) {
+        this.documents[drive] = this.documents[drive] ?? {};
+        const {
+            operations,
+            initialState,
+            name,
+            revision,
+            documentType,
+            created,
+            lastModified
+        } = document;
+        this.documents[drive]![id] = {
+            operations,
+            initialState,
+            name,
+            revision,
+            documentType,
+            created,
+            lastModified
+        };
+    }
+
+    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`);
@@ -51,8 +102,23 @@ export class MemoryStorage implements IDriveStorage {
         return drive;
     }
 
-    async saveDrive(drive: DocumentDriveDocument) {
-        this.drives[drive.state.global.id] = drive;
+    async createDrive(id: string, drive: DocumentDriveStorage) {
+        this.drives[id] = drive;
+    }
+
+    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) {

package/src/storage/prisma.ts

@@ -0,0 +1,248 @@
+import { PrismaClient, type Prisma } from '@prisma/client';
+import {
+    DocumentDriveLocalState,
+    DocumentDriveState
+} from 'document-model-libs/document-drive';
+import {
+    Document,
+    DocumentHeader,
+    ExtendedState,
+    Operation,
+    OperationScope
+} from 'document-model/document';
+import { DocumentDriveStorage, DocumentStorage, IDriveStorage } from './types';
+
+export class PrismaStorage implements IDriveStorage {
+    private db: PrismaClient;
+
+    constructor(db: PrismaClient) {
+        this.db = db;
+    }
+    async createDrive(id: string, drive: DocumentDriveStorage): Promise<void> {
+        await this.createDocument(
+            'drives',
+            id,
+            drive as DocumentStorage
+        );
+    }
+    async addDriveOperations(
+        id: string,
+        operations: Operation[],
+        header: DocumentHeader
+    ): Promise<void> {
+        await this.addDocumentOperations('drives', id, operations, header);
+    }
+    async createDocument(
+        drive: string,
+        id: string,
+        document: DocumentStorage
+    ): Promise<void> {
+        await this.db.document.upsert({
+            where: {
+                id_driveId: {
+                    id,
+                    driveId: drive
+                }
+            },
+            update: {},
+            create: {
+                name: document.name,
+                documentType: document.documentType,
+                driveId: drive,
+                initialState: document.initialState as Prisma.InputJsonObject,
+                lastModified: document.lastModified,
+                revision: document.revision,
+                id
+            }
+        });
+    }
+    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`);
+        }
+
+        try {
+            await Promise.all(
+                operations.map(async op => {
+                    return this.db.operation.upsert({
+                        where: {
+                            driveId_documentId_scope_branch_index: {
+                                driveId: drive,
+                                documentId: id,
+                                scope: op.scope,
+                                branch: 'main',
+                                index: op.index
+                            }
+                        },
+                        create: {
+                            driveId: drive,
+                            documentId: id,
+                            hash: op.hash,
+                            index: op.index,
+                            input: op.input as Prisma.InputJsonObject,
+                            timestamp: op.timestamp,
+                            type: op.type,
+                            scope: op.scope,
+                            branch: 'main'
+                        },
+                        update: {
+                            driveId: drive,
+                            documentId: id,
+                            hash: op.hash,
+                            index: op.index,
+                            input: op.input as Prisma.InputJsonObject,
+                            timestamp: op.timestamp,
+                            type: op.type,
+                            scope: op.scope,
+                            branch: 'main'
+                        }
+                    });
+                })
+            );
+
+            await this.db.document.update({
+                where: {
+                    id_driveId: {
+                        id,
+                        driveId: 'drives'
+                    }
+                },
+                data: {
+                    lastModified: header.lastModified,
+                    revision: header.revision
+                }
+            });
+        } catch (e) {
+            console.log(e);
+        }
+
+        await this.db.document.upsert({
+            where: {
+                id_driveId: {
+                    id: 'drives',
+                    driveId: id
+                }
+            },
+            create: {
+                id: 'drives',
+                driveId: id,
+                documentType: header.documentType,
+                initialState: document.initialState,
+                lastModified: header.lastModified,
+                revision: header.revision,
+                created: header.created
+            },
+            update: {
+                lastModified: header.lastModified,
+                revision: header.revision
+            }
+        });
+    }
+
+    async getDocuments(drive: string) {
+        const docs = await this.db.document.findMany({
+            where: {
+                AND: {
+                    driveId: drive,
+                    NOT: {
+                        id: 'drives'
+                    }
+                }
+            }
+        });
+
+        return docs.map(doc => doc.id);
+    }
+
+    async getDocument(driveId: string, id: string) {
+        const result = await this.db.document.findFirst({
+            where: {
+                id: id,
+                driveId: driveId
+            },
+            include: {
+                operations: {
+                    include: {
+                        attachments: true
+                    }
+                }
+            }
+        });
+
+        if (result === null) {
+            throw new Error(`Document with id ${id} not found`);
+        }
+
+        const dbDoc = result;
+
+        const doc = {
+            created: dbDoc.created.toISOString(),
+            name: dbDoc.name ? dbDoc.name : '',
+            documentType: dbDoc.documentType,
+            initialState: dbDoc.initialState as ExtendedState<
+                DocumentDriveState,
+                DocumentDriveLocalState
+            >,
+            lastModified: dbDoc.lastModified.toISOString(),
+            operations: {
+                global: dbDoc.operations
+                    .filter(op => op.scope === 'global')
+                    .map(op => ({
+                        hash: op.hash,
+                        index: op.index,
+                        timestamp: new Date(op.timestamp).toISOString(),
+                        input: op.input,
+                        type: op.type,
+                        scope: op.scope as OperationScope
+                        // attachments: fileRegistry
+                    })),
+                local: dbDoc.operations
+                    .filter(op => op.scope === 'local')
+                    .map(op => ({
+                        hash: op.hash,
+                        index: op.index,
+                        timestamp: new Date(op.timestamp).toISOString(),
+                        input: op.input,
+                        type: op.type,
+                        scope: op.scope as OperationScope
+                        // attachments: fileRegistry
+                    }))
+            },
+            revision: dbDoc.revision
+        };
+
+        return doc;
+    }
+
+    async deleteDocument(drive: string, id: string) {
+        await this.db.document.deleteMany({
+            where: {
+                driveId: drive,
+                id: id
+            }
+        });
+    }
+
+    async getDrives() {
+        return this.getDocuments('drives');
+    }
+
+    async getDrive(id: string) {
+        return this.getDocument('drives', id) as Promise<DocumentDriveStorage>;
+    }
+
+    async deleteDrive(id: string) {
+        await this.deleteDocument('drives', id);
+        await this.db.document.deleteMany({
+            where: {
+                driveId: id
+            }
+        });
+    }
+}

package/src/storage/types.ts

@@ -1,16 +1,45 @@
-import { DocumentDriveDocument } from 'document-model-libs/document-drive';
-import { Document } from 'document-model/document';
+import type {
+    DocumentDriveAction,
+    DocumentDriveDocument
+} from 'document-model-libs/document-drive';
+import type {
+    BaseAction,
+    Document,
+    DocumentHeader,
+    Operation
+} from 'document-model/document';
+
+export type DocumentStorage<D extends Document = Document> = Omit<
+    D,
+    'state' | 'attachments'
+>;
+export type DocumentDriveStorage = DocumentStorage<DocumentDriveDocument>;
 
 export interface IStorage {
     getDocuments: (drive: string) => Promise<string[]>;
-    getDocument(drive: string, id: string): Promise<Document>;
-    saveDocument(drive: string, id: string, document: Document): Promise<void>;
+    getDocument(drive: string, id: string): Promise<DocumentStorage>;
+    createDocument(
+        drive: string,
+        id: string,
+        document: DocumentStorage
+    ): Promise<void>;
+    addDocumentOperations(
+        drive: string,
+        id: string,
+        operations: Operation[],
+        header: DocumentHeader
+    ): Promise<void>;
     deleteDocument(drive: string, id: string): Promise<void>;
 }
 
 export interface IDriveStorage extends IStorage {
     getDrives(): Promise<string[]>;
-    getDrive(id: string): Promise<DocumentDriveDocument>;
-    saveDrive(drive: DocumentDriveDocument): Promise<void>;
+    getDrive(id: string): Promise<DocumentDriveStorage>;
+    createDrive(id: string, drive: DocumentDriveStorage): Promise<void>;
     deleteDrive(id: string): Promise<void>;
+    addDriveOperations(
+        id: string,
+        operations: Operation<DocumentDriveAction | BaseAction>[],
+        header: DocumentHeader
+    ): Promise<void>;
 }

package/src/utils.ts

@@ -3,7 +3,13 @@ import {
     documentModel as DocumentDriveModel,
     z
 } from 'document-model-libs/document-drive';
-import { Document } from 'document-model/document';
+import {
+    Action,
+    BaseAction,
+    Document,
+    DocumentOperations,
+    Operation
+} from 'document-model/document';
 
 export function isDocumentDrive(
     document: Document
@@ -13,3 +19,14 @@ export function isDocumentDrive(
         z.DocumentDriveStateSchema().safeParse(document.state.global).success
     );
 }
+
+export function mergeOperations<A extends Action = Action>(
+    currentOperations: DocumentOperations<A>,
+    newOperations: Operation<A | BaseAction>[]
+): DocumentOperations<A> {
+    return newOperations.reduce((acc, curr) => {
+        const operations = acc[curr.scope] ?? [];
+        acc[curr.scope] = [...operations, curr] as Operation<A>[];
+        return acc;
+    }, currentOperations);
+}