document-drive 0.0.23 → 0.0.25

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "document-drive",
-    "version": "0.0.23",
+    "version": "0.0.25",
     "license": "AGPL-3.0-only",
     "type": "module",
     "module": "./src/index.ts",
@@ -25,29 +25,33 @@
         "test:watch": "vitest watch"
     },
     "peerDependencies": {
-        "document-model": "^1.0.20",
-        "document-model-libs": "^1.1.27",
-        "localforage": "^1.10.0"
+        "@prisma/client": "5.7.1",
+        "document-model": "^1.0.22",
+        "document-model-libs": "^1.1.31",
+        "localforage": "^1.10.0",
+        "sequelize": "^6.35.2",
+        "sqlite3": "^5.1.7"
     },
     "dependencies": {
-        "@prisma/client": "5.7.1",
         "sanitize-filename": "^1.6.3"
     },
     "devDependencies": {
+        "@prisma/client": "5.7.1",
         "@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.20",
-        "document-model-libs": "^1.1.27",
+        "document-model": "^1.0.22",
+        "document-model-libs": "^1.1.31",
         "eslint": "^8.56.0",
         "eslint-config-prettier": "^9.1.0",
         "fake-indexeddb": "^5.0.1",
         "localforage": "^1.10.0",
         "prettier": "^3.1.1",
         "prettier-plugin-organize-imports": "^3.2.4",
-        "prisma": "^5.8.0",
-        "typescript": "^5.3.3",
+        "sequelize": "^6.35.2",
+        "sqlite3": "^5.1.7",
+        "typescript": "^5.3.2",
         "vitest": "^0.34.6"
     }
 }

package/src/storage/prisma.ts

@@ -1,10 +1,9 @@
-import { PrismaClient, type Prisma } from '@prisma/client';
+import { type Prisma } from '@prisma/client';
 import {
     DocumentDriveLocalState,
     DocumentDriveState
 } from 'document-model-libs/document-drive';
 import {
-    Document,
     DocumentHeader,
     ExtendedState,
     Operation,
@@ -13,17 +12,13 @@ import {
 import { DocumentDriveStorage, DocumentStorage, IDriveStorage } from './types';
 
 export class PrismaStorage implements IDriveStorage {
-    private db: PrismaClient;
+    private db: Prisma.TransactionClient;
 
-    constructor(db: PrismaClient) {
+    constructor(db: Prisma.TransactionClient) {
         this.db = db;
     }
     async createDrive(id: string, drive: DocumentDriveStorage): Promise<void> {
-        await this.createDocument(
-            'drives',
-            id,
-            drive as DocumentStorage
-        );
+        await this.createDocument('drives', id, drive as DocumentStorage);
     }
     async addDriveOperations(
         id: string,
@@ -214,7 +209,7 @@ export class PrismaStorage implements IDriveStorage {
                         // attachments: fileRegistry
                     }))
             },
-            revision: dbDoc.revision
+            revision: dbDoc.revision as Required<Record<OperationScope, number>>
         };
 
         return doc;

package/src/storage/sequelize.ts

@@ -0,0 +1,375 @@
+import {
+    DocumentDriveLocalState,
+    DocumentDriveState
+} from 'document-model-libs/document-drive';
+import {
+    AttachmentInput,
+    DocumentHeader,
+    ExtendedState,
+    Operation,
+    OperationScope
+} from 'document-model/document';
+import { DataTypes, Options, Sequelize } from 'sequelize';
+import { DocumentDriveStorage, DocumentStorage, IDriveStorage } from './types';
+
+export class SequelizeStorage implements IDriveStorage {
+    private db: Sequelize;
+
+    constructor(options: Options) {
+        this.db = new Sequelize(options);
+    }
+
+    public syncModels() {
+        const Document = this.db.define('document', {
+            id: {
+                type: DataTypes.STRING,
+                primaryKey: true
+            },
+            driveId: {
+                type: DataTypes.STRING,
+                primaryKey: true
+            },
+            name: DataTypes.STRING,
+            documentType: DataTypes.STRING,
+            initialState: DataTypes.JSON,
+            lastModified: DataTypes.DATE,
+            revision: DataTypes.JSON
+        });
+
+        const Operation = this.db.define('operation', {
+            driveId: {
+                type: DataTypes.STRING,
+                primaryKey: true
+            },
+            documentId: {
+                type: DataTypes.STRING,
+                primaryKey: true
+            },
+            hash: DataTypes.STRING,
+            index: {
+                type: DataTypes.INTEGER,
+                primaryKey: true
+            },
+            input: DataTypes.JSON,
+            timestamp: DataTypes.DATE,
+            type: DataTypes.STRING,
+            scope: {
+                type: DataTypes.STRING,
+                primaryKey: true
+            },
+            branch: {
+                type: DataTypes.STRING,
+                primaryKey: true
+            }
+        });
+
+        const Attachment = this.db.define('attachment', {
+            driveId: {
+                type: DataTypes.STRING,
+                primaryKey: true
+            },
+            documentId: {
+                type: DataTypes.STRING,
+                primaryKey: true
+            },
+            scope: {
+                type: DataTypes.STRING,
+                primaryKey: true
+            },
+            branch: {
+                type: DataTypes.STRING,
+                primaryKey: true
+            },
+            index: {
+                type: DataTypes.STRING,
+                primaryKey: true
+            },
+            hash: {
+                type: DataTypes.STRING,
+                primaryKey: true
+            },
+            mimeType: DataTypes.STRING,
+            fileName: DataTypes.STRING,
+            extension: DataTypes.STRING,
+            data: DataTypes.BLOB
+        });
+
+        Operation.hasMany(Attachment, {
+            onDelete: 'CASCADE'
+        });
+        Attachment.belongsTo(Operation);
+        Document.hasMany(Operation, {
+            onDelete: 'CASCADE'
+        });
+        Operation.belongsTo(Document);
+
+        return this.db.sync({ force: true });
+    }
+
+    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> {
+        const Document = this.db.models.document;
+
+        if (!Document) {
+            throw new Error('Document model not found');
+        }
+
+        await Document.create({
+            id: id,
+            driveId: drive,
+            name: document.name,
+            documentType: document.documentType,
+            initialState: document.initialState,
+            lastModified: document.lastModified,
+            revision: document.revision
+        });
+    }
+    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 Operation = this.db.models.operation;
+        if (!Operation) {
+            throw new Error('Operation model not found');
+        }
+
+        await Promise.all(
+            operations.map(async op => {
+                return Operation.create({
+                    driveId: drive,
+                    documentId: id,
+                    hash: op.hash,
+                    index: op.index,
+                    input: op.input,
+                    timestamp: op.timestamp,
+                    type: op.type,
+                    scope: op.scope,
+                    branch: 'main'
+                }).then(async () => {
+                    if (op.attachments) {
+                        await this._addDocumentOperationAttachments(
+                            drive,
+                            id,
+                            op,
+                            op.attachments
+                        );
+                    }
+                });
+            })
+        );
+
+        const Document = this.db.models.document;
+        if (!Document) {
+            throw new Error('Document model not found');
+        }
+
+        await Document.update(
+            {
+                lastModified: header.lastModified,
+                revision: header.revision
+            },
+            {
+                where: {
+                    id: id,
+                    driveId: drive
+                }
+            }
+        );
+    }
+
+    async _addDocumentOperationAttachments(
+        driveId: string,
+        documentId: string,
+        operation: Operation,
+        attachments: AttachmentInput[]
+    ) {
+        const Attachment = this.db.models.attachment;
+        if (!Attachment) {
+            throw new Error('Attachment model not found');
+        }
+
+        await Promise.all(
+            attachments.map(async attachment => {
+                return Attachment.create({
+                    driveId: driveId,
+                    documentId: documentId,
+                    scope: operation.scope,
+                    branch: 'main',
+                    index: operation.index,
+                    mimeType: attachment.mimeType,
+                    fileName: attachment.fileName,
+                    extension: attachment.extension,
+                    data: attachment.data,
+                    hash: attachment.hash
+                });
+            })
+        );
+    }
+
+    async getDocuments(drive: string) {
+        const Document = this.db.models.document;
+        if (!Document) {
+            throw new Error('Document model not found');
+        }
+
+        const result = await Document.findAll({
+            attributes: ['id'],
+            where: {
+                driveId: drive
+            }
+        });
+
+        const ids = result.map((e: { dataValues: { id: string } }) => {
+            const { id } = e.dataValues;
+            return id;
+        });
+        return ids;
+    }
+
+    async getDocument(driveId: string, id: string) {
+        const Document = this.db.models.document;
+        if (!Document) {
+            throw new Error('Document model not found');
+        }
+
+        const entry = await Document.findOne({
+            where: {
+                id: id,
+                driveId: driveId
+            },
+            include: [
+                {
+                    model: this.db.models.operation,
+                    as: 'operations'
+                }
+            ]
+        });
+
+        if (entry === null) {
+            throw new Error(`Document with id ${id} not found`);
+        }
+
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+        const document: {
+            operations: [
+                {
+                    hash: string;
+                    index: number;
+                    timestamp: Date;
+                    input: JSON;
+                    type: string;
+                    scope: string;
+                }
+            ];
+            revision: Required<Record<OperationScope, number>>;
+            createdAt: Date;
+            name: string;
+            updatedAt: Date;
+            documentType: string;
+            initialState: ExtendedState<
+                DocumentDriveState,
+                DocumentDriveLocalState
+            >;
+        } = entry.dataValues;
+        const Operation = this.db.models.operation;
+        if (!Operation) {
+            throw new Error('Operation model not found');
+        }
+
+        const operations = document.operations.map(
+            (op: {
+                hash: string;
+                index: number;
+                timestamp: Date;
+                input: JSON;
+                type: string;
+                scope: string;
+            }) => ({
+                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
+            })
+        );
+
+        const doc = {
+            created: document.createdAt.toISOString(),
+            name: document.name ? document.name : '',
+            documentType: document.documentType,
+            initialState: document.initialState,
+            lastModified: document.updatedAt.toISOString(),
+            operations: {
+                global: operations.filter(
+                    (op: Operation) => op.scope === 'global'
+                ),
+                local: operations.filter(
+                    (op: Operation) => op.scope === 'local'
+                )
+            },
+            revision: document.revision
+        };
+
+        return doc;
+    }
+
+    async deleteDocument(drive: string, id: string) {
+        const Document = this.db.models.document;
+        if (!Document) {
+            throw new Error('Document model not found');
+        }
+
+        await Document.destroy({
+            where: {
+                id: id,
+                driveId: drive
+            }
+        });
+    }
+
+    async getDrives() {
+        return this.getDocuments('drives');
+    }
+
+    async getDrive(id: string) {
+        const doc = await this.getDocument('drives', id);
+        return doc as DocumentDriveStorage;
+    }
+
+    async deleteDrive(id: string) {
+        await this.deleteDocument('drives', id);
+
+        const Document = this.db.models.document;
+        if (!Document) {
+            throw new Error('Document model not found');
+        }
+
+        await Document.destroy({
+            where: {
+                driveId: id
+            }
+        });
+    }
+}