document-drive 1.0.0-experimental.4 → 1.0.0-experimental.6

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "document-drive",
-    "version": "1.0.0-experimental.4",
+    "version": "1.0.0-experimental.6",
     "license": "AGPL-3.0-only",
     "type": "module",
     "module": "./src/index.ts",

package/src/server/index.ts

@@ -28,7 +28,7 @@ import { MemoryStorage } from '../storage/memory';
 import type {
     DocumentDriveStorage,
     DocumentStorage,
-    IDriveStorage
+    IDriveStorage,
 } from '../storage/types';
 import { generateUUID, isBefore, isDocumentDrive } from '../utils';
 import {
@@ -438,7 +438,7 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
         return documentModel;
     }
 
-    async addDrive(drive: DriveInput) {
+    async addDrive(drive: DriveInput): Promise<DocumentDriveDocument> {
         const id = drive.global.id || generateUUID();
         if (!id) {
             throw new Error('Invalid Drive Id');
@@ -459,7 +459,7 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
         return document;
     }
 
-    async addRemoteDrive(url: string, options: RemoteDriveOptions) {
+    async addRemoteDrive(url: string, options: RemoteDriveOptions): Promise<DocumentDriveDocument> {
         const { id, name, slug, icon } = await requestPublicDrive(url);
         const {
             pullFilter,
@@ -560,8 +560,8 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
         }
         const documentStorage =
             await this.storage.getDocument(drive, id);
+        const document = this._buildDocument(documentStorage, options)
 
-        const document = this._buildDocument(documentStorage, options);
         this.cache.setDocument(drive, id, document).catch(logger.error);
         return document;
     }
@@ -574,11 +574,41 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
         driveId: string,
         input: CreateDocumentInput
     ) {
-        const documentModel = this._getDocumentModel(input.documentType);
-        // TODO validate input.document is of documentType
-        const document = input.document ?? documentModel.utils.createDocument();
+        // if a document was provided then checks if it's valid
+        if (input.document) {
+            if (input.documentType !== input.document.documentType) {
+                throw new Error(`Provided document is not ${input.documentType}`);
+            }
+            this._buildDocument(input.document);
+        }
 
-        await this.storage.createDocument(driveId, input.id, document);
+        // if no document was provided then create a new one
+        const document = input.document ??
+            this._getDocumentModel(input.documentType).utils.createDocument();
+
+        // stores document information
+        const documentStorage: DocumentStorage = {
+            name: document.name,
+            revision: document.revision,
+            documentType: document.documentType,
+            created: document.created,
+            lastModified: document.lastModified,
+            operations: { global: [], local: [] },
+            initialState: document.initialState,
+            clipboard: [],
+        };
+        await this.storage.createDocument(driveId, input.id, documentStorage);
+
+        // if the document contains operations then
+        // stores the operations in the storage
+        const operations = Object.values(document.operations).flat();
+        if (operations.length) {
+            if (isDocumentDrive(document)) {
+                await this.storage.addDriveOperations(driveId, operations as Operation<DocumentDriveAction>[], document);
+            } else {
+                await this.storage.addDocumentOperations(driveId, input.id, operations, document)
+            }
+        }
 
         return document;
     }
@@ -610,6 +640,7 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
             const storageDocumentOperations =
                 storageDocument.operations[scope as OperationScope];
 
+            // TODO two equal operations done by two clients will be considered the same, ie: { type: "INCREMENT" }
             const branch = removeExistingOperations(
                 operationsByScope[scope as OperationScope] || [],
                 storageDocumentOperations
@@ -702,7 +733,7 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
             undefined,
             documentStorage,
             undefined,
-            { checkHashes: false }
+            { checkHashes: options?.checkHashes ?? true }
         ) as T;
     }
 
@@ -788,8 +819,8 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
         };
     }
 
-    addOperation(drive: string, id: string, operation: Operation) {
-        return this.addOperations(drive, id, [operation]);
+    addOperation(drive: string, id: string, operation: Operation, forceSync = true): Promise<IOperationResult> {
+        return this.addOperations(drive, id, [operation], forceSync);
     }
 
     private async _addOperations(
@@ -823,22 +854,19 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
         }
     }
 
+    queueOperation(drive: string, id: string, operation: Operation, forceSync = true): Promise<IOperationResult> {
+        return this.queueOperations(drive, id, [operation], forceSync);
+    }
 
     async queueOperations(drive: string,
         id: string,
         operations: Operation[],
         forceSync = true) {
-        // try {
-        //     await this.getDocument(drive, id);
-        // } catch (error) {
-        //     logger.error('Error getting document', error);
-        //     throw error;
-        // }
 
         try {
             const jobId = await this.queueManager.addJob({ driveId: drive, documentId: id, operations, forceSync });
 
-            return new Promise((resolve, reject) => {
+            return new Promise<IOperationResult>((resolve, reject) => {
                 const unsubscribe = this.queueManager.on('jobCompleted', (job, result) => {
                     if (job.jobId === jobId) {
                         unsubscribe();
@@ -974,9 +1002,10 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
 
     addDriveOperation(
         drive: string,
-        operation: Operation<DocumentDriveAction | BaseAction>
+        operation: Operation<DocumentDriveAction | BaseAction>,
+        forceSync = true
     ) {
-        return this.addDriveOperations(drive, [operation]);
+        return this.addDriveOperations(drive, [operation], forceSync);
     }
 
     async clearStorage() {
@@ -1014,18 +1043,22 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
         }
     }
 
+    queueDriveOperation(drive: string, operation: Operation<DocumentDriveAction | BaseAction>, forceSync = true): Promise<IOperationResult<DocumentDriveDocument>> {
+        return this.queueDriveOperations(drive, [operation], forceSync);
+    }
+
     async queueDriveOperations(
         drive: string,
         operations: Operation<DocumentDriveAction | BaseAction>[],
         forceSync = true
-    ): Promise<IOperationResult> {
+    ): Promise<IOperationResult<DocumentDriveDocument>> {
         const jobId = await this.queueManager.addJob({ driveId: drive, operations, forceSync });
-        return new Promise((resolve, reject) => {
+        return new Promise<IOperationResult<DocumentDriveDocument>>((resolve, reject) => {
             const unsubscribe = this.queueManager.on('jobCompleted', (job, result) => {
                 if (job.jobId === jobId) {
                     unsubscribe();
                     unsubscribeError();
-                    resolve(result);
+                    resolve(result as IOperationResult<DocumentDriveDocument>);
                 }
             });
             const unsubscribeError = this.queueManager.on('jobFailed', (job, error) => {

package/src/server/types.ts

@@ -142,6 +142,7 @@ export type RevisionsFilter = PartialRecord<OperationScope, number>;
 
 export type GetDocumentOptions = {
     revisions?: RevisionsFilter;
+    checkHashes?: boolean;
 };
 
 export abstract class BaseDocumentDriveServer {
@@ -178,13 +179,39 @@ export abstract class BaseDocumentDriveServer {
         forceSync?: boolean
     ): Promise<IOperationResult>;
 
+    abstract queueOperation(
+        drive: string,
+        id: string,
+        operation: Operation,
+        forceSync?: boolean
+    ): Promise<IOperationResult>;
+    abstract queueOperations(
+        drive: string,
+        id: string,
+        operations: Operation[],
+        forceSync?: boolean
+    ): Promise<IOperationResult>;
+
     abstract addDriveOperation(
         drive: string,
-        operation: Operation<DocumentDriveAction | BaseAction>
+        operation: Operation<DocumentDriveAction | BaseAction>,
+        forceSync?: boolean
     ): Promise<IOperationResult<DocumentDriveDocument>>;
     abstract addDriveOperations(
         drive: string,
-        operations: Operation<DocumentDriveAction | BaseAction>[]
+        operations: Operation<DocumentDriveAction | BaseAction>[],
+        forceSync?: boolean
+    ): Promise<IOperationResult<DocumentDriveDocument>>;
+
+    abstract queueDriveOperation(
+        drive: string,
+        operation: Operation<DocumentDriveAction | BaseAction>,
+        forceSync?: boolean
+    ): Promise<IOperationResult<DocumentDriveDocument>>;
+    abstract queueDriveOperations(
+        drive: string,
+        operations: Operation<DocumentDriveAction | BaseAction>[],
+        forceSync?: boolean
     ): Promise<IOperationResult<DocumentDriveDocument>>;
 
     abstract addAction(

package/src/storage/prisma.ts

@@ -7,7 +7,6 @@ import {
     DocumentDriveState
 } from 'document-model-libs/document-drive';
 import type {
-    ActionContext,
     BaseAction,
     DocumentHeader,
     ExtendedState,
@@ -26,17 +25,20 @@ type Transaction = Omit<
 function storageToOperation(
     op: Prisma.$OperationPayload['scalars']
 ): Operation {
-    return {
+    const operation: Operation = {
         skip: op.skip,
         hash: op.hash,
         index: op.index,
         timestamp: new Date(op.timestamp).toISOString(),
-        input: op.input,
+        input: JSON.parse(op.input),
         type: op.type,
         scope: op.scope as OperationScope,
-        context: op.context ? op.context as ActionContext : undefined,
         // attachments: fileRegistry
     };
+    if (op.context) {
+        operation.context = op.context as Prisma.JsonObject;
+    }
+    return operation;
 }
 
 export type PrismaStorageOptions = {
@@ -157,7 +159,7 @@ export class PrismaStorage implements IDriveStorage {
                     documentId: id,
                     hash: op.hash,
                     index: op.index,
-                    input: op.input as Prisma.InputJsonObject,
+                    input: JSON.stringify(op.input),
                     timestamp: op.timestamp,
                     type: op.type,
                     scope: op.scope,

package/src/storage/types.ts

@@ -1,6 +1,6 @@
 import type {
     DocumentDriveAction,
-    DocumentDriveDocument
+    DocumentDriveDocument,
 } from 'document-model-libs/document-drive';
 import type {
     BaseAction,
@@ -8,12 +8,12 @@ import type {
     DocumentHeader,
     Operation
 } from 'document-model/document';
-import { GetDocumentOptions } from '../server';
 
 export type DocumentStorage<D extends Document = Document> = Omit<
     D,
     'state' | 'attachments'
 >;
+
 export type DocumentDriveStorage = DocumentStorage<DocumentDriveDocument>;
 
 export interface IStorage {

package/src/utils/index.ts

@@ -11,7 +11,16 @@ import {
     Operation,
     OperationScope
 } from 'document-model/document';
-import { ConflictOperationError, OperationError } from '../server/error';
+import { OperationError } from '../server/error';
+import { DocumentDriveStorage, DocumentStorage } from '../storage';
+
+export function isDocumentDriveStorage(
+    document: DocumentStorage
+): document is DocumentDriveStorage {
+    return (
+        document.documentType === DocumentDriveModel.id
+    );
+}
 
 export function isDocumentDrive(
     document: Document