document-drive 1.0.0-experimental.10 → 1.0.0-experimental.100

package/CHANGELOG.md

@@ -1,3 +1,73 @@
+# [1.0.0-alpha.65](https://github.com/powerhouse-inc/document-drive/compare/v1.0.0-alpha.64...v1.0.0-alpha.65) (2024-05-30)
+
+
+### Features
+
+* fetch resulting state for last unskipped operation ([8297353](https://github.com/powerhouse-inc/document-drive/commit/8297353dc8eaca107d8134580dee67c3265b05b5))
+
+# [1.0.0-alpha.64](https://github.com/powerhouse-inc/document-drive/compare/v1.0.0-alpha.63...v1.0.0-alpha.64) (2024-05-30)
+
+
+### Features
+
+* update document-model lib version ([#180](https://github.com/powerhouse-inc/document-drive/issues/180)) ([83cec58](https://github.com/powerhouse-inc/document-drive/commit/83cec58cb02388a3b2a643dd5af6c31cd850242d))
+
+# [1.0.0-alpha.63](https://github.com/powerhouse-inc/document-drive/compare/v1.0.0-alpha.62...v1.0.0-alpha.63) (2024-05-30)
+
+
+### Bug Fixes
+
+* operations query ([8dd11c7](https://github.com/powerhouse-inc/document-drive/commit/8dd11c72058452f3e8febac472d01ad56d959e17))
+
+# [1.0.0-alpha.62](https://github.com/powerhouse-inc/document-drive/compare/v1.0.0-alpha.61...v1.0.0-alpha.62) (2024-05-30)
+
+
+### Bug Fixes
+
+* added drive and documentId filter ([718405f](https://github.com/powerhouse-inc/document-drive/commit/718405febbe8e53a3fd392cdd4acf2b041347eaf))
+
+# [1.0.0-alpha.61](https://github.com/powerhouse-inc/document-drive/compare/v1.0.0-alpha.60...v1.0.0-alpha.61) (2024-05-30)
+
+
+### Features
+
+* store resulting state as bytes and only retrieve state for last op of each scope ([c6a5004](https://github.com/powerhouse-inc/document-drive/commit/c6a5004a3dd07ee1ce2f5521bb7a6aa5e970465e))
+
+# [1.0.0-alpha.60](https://github.com/powerhouse-inc/document-drive/compare/v1.0.0-alpha.59...v1.0.0-alpha.60) (2024-05-29)
+
+
+### Features
+
+* avoid duplicated getDocument call ([c0684bc](https://github.com/powerhouse-inc/document-drive/commit/c0684bc0746d8bafb9393cdaeebfb60b38a8a32f))
+
+# [1.0.0-alpha.59](https://github.com/powerhouse-inc/document-drive/compare/v1.0.0-alpha.58...v1.0.0-alpha.59) (2024-05-28)
+
+
+### Features
+
+* enable operation id ([#174](https://github.com/powerhouse-inc/document-drive/issues/174)) ([1d77fd2](https://github.com/powerhouse-inc/document-drive/commit/1d77fd2f6a4618371c6fc4c072d4eab7d27a662a))
+
+# [1.0.0-alpha.58](https://github.com/powerhouse-inc/document-drive/compare/v1.0.0-alpha.57...v1.0.0-alpha.58) (2024-05-28)
+
+
+### Features
+
+* don't save queue job result ([efbf239](https://github.com/powerhouse-inc/document-drive/commit/efbf239e5f77592267446d5c11d670a82f1f6e58))
+
+# [1.0.0-alpha.57](https://github.com/powerhouse-inc/document-drive/compare/v1.0.0-alpha.56...v1.0.0-alpha.57) (2024-05-22)
+
+
+### Features
+
+* new release ([17796e8](https://github.com/powerhouse-inc/document-drive/commit/17796e8577d16d3095a8adf3c40e7bd7146b6142))
+
+# [1.0.0-alpha.56](https://github.com/powerhouse-inc/document-drive/compare/v1.0.0-alpha.55...v1.0.0-alpha.56) (2024-05-22)
+
+
+### Features
+
+* add queues and append only conflict resolution ([d17abd6](https://github.com/powerhouse-inc/document-drive/commit/d17abd664a7381f80faa6530f83ca9e224282ba1)), closes [#153](https://github.com/powerhouse-inc/document-drive/issues/153)
+
 # 1.0.0-experimental.1 (2024-05-15)
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "document-drive",
-    "version": "1.0.0-experimental.10",
+    "version": "1.0.0-experimental.100",
     "license": "AGPL-3.0-only",
     "type": "module",
     "module": "./src/index.ts",
@@ -34,11 +34,11 @@
         "test:watch": "vitest watch"
     },
     "peerDependencies": {
-        "document-model": "1.1.0-experimental.1",
-        "document-model-libs": "^1.37.0"
+        "document-model": "1.3.0",
+        "document-model-libs": "^1.53.1"
     },
     "optionalDependencies": {
-        "@prisma/client": "5.11.0",
+        "@prisma/client": "5.14.0",
         "localforage": "^1.10.0",
         "redis": "^4.6.13",
         "sequelize": "^6.35.2",
@@ -65,8 +65,8 @@
         "@typescript-eslint/eslint-plugin": "^6.21.0",
         "@typescript-eslint/parser": "^6.21.0",
         "@vitest/coverage-v8": "^1.4.0",
-        "document-model": "1.1.0-experimental.1",
-        "document-model-libs": "1.50.0-arbitrum.1",
+        "document-model": "^1.3.0",
+        "document-model-libs": "^1.53.1",
         "eslint": "^8.57.0",
         "eslint-config-prettier": "^9.1.0",
         "fake-indexeddb": "^5.0.2",
@@ -74,7 +74,7 @@
         "msw": "^2.2.13",
         "prettier": "^3.2.5",
         "prettier-plugin-organize-imports": "^3.2.4",
-        "prisma": "^5.12.1",
+        "prisma": "^5.14.0",
         "semantic-release": "^23.0.8",
         "sequelize": "^6.37.2",
         "sqlite3": "^5.1.7",

package/src/queue/base.ts

@@ -10,7 +10,6 @@ export class MemoryQueue<T, R> implements IQueue<T, R> {
     private blocked = false;
     private deleted = false;
     private items: IJob<T>[] = [];
-    private results = new Map<JobId, R>();
     private dependencies = new Array<IJob<OperationJob>>();
 
     constructor(id: string) {
@@ -25,15 +24,6 @@ export class MemoryQueue<T, R> implements IQueue<T, R> {
         return this.deleted;
     }
 
-    async setResult(jobId: string, result: R): Promise<void> {
-        this.results.set(jobId, result);
-        return Promise.resolve();
-    }
-
-    async getResult(jobId: string): Promise<R | undefined> {
-        return Promise.resolve(this.results.get(jobId));
-    }
-
     async addJob(data: IJob<T>) {
         this.items.push(data);
         return Promise.resolve();
@@ -157,11 +147,6 @@ export class BaseQueueManager implements IQueueManager {
         return jobId;
     }
 
-    async getResult(driveId: string, documentId: string, jobId: JobId): Promise<IOperationResult | undefined> {
-        const queue = this.getQueue(driveId, documentId);
-        return queue.getResult(jobId);
-    }
-
     getQueue(driveId: string, documentId?: string) {
         const queueId = this.getQueueId(driveId, documentId);
         let queue = this.queues.find((q) => q.getId() === queueId);
@@ -237,7 +222,6 @@ export class BaseQueueManager implements IQueueManager {
 
         try {
             const result = await this.delegate.processOperationJob(nextJob);
-            await queue.setResult(nextJob.jobId, result);
 
             // unblock the document queues of each add_file operation
             const addFileOperations = nextJob.operations.filter((op) => op.type === "ADD_FILE");
@@ -252,7 +236,7 @@ export class BaseQueueManager implements IQueueManager {
         } catch (e) {
             this.emit("jobFailed", nextJob, e as Error);
         } finally {
-            queue.setBlocked(false);
+            await queue.setBlocked(false);
             await this.processNextJob();
         }
     }

package/src/queue/redis.ts

@@ -1,5 +1,5 @@
 import { RedisClientType } from "redis";
-import { IJob, IQueue, IQueueManager, OperationJob } from "./types";
+import { IJob, IQueue, IQueueManager, IServerDelegate, OperationJob } from "./types";
 import { BaseQueueManager } from "./base";
 
 export class RedisQueue<T, R> implements IQueue<T, R> {
@@ -10,18 +10,7 @@ export class RedisQueue<T, R> implements IQueue<T, R> {
         this.client = client;
         this.id = id;
         this.client.hSet("queues", id, "true");
-
-    }
-
-    async setResult(jobId: string, result: any): Promise<void> {
-        await this.client.hSet(this.id + "-results", jobId, JSON.stringify(result));
-    }
-    async getResult(jobId: string): Promise<any> {
-        const results = await this.client.hGet(this.id + "-results", jobId);
-        if (!results) {
-            return null;
-        }
-        return JSON.parse(results);
+        this.client.hSet(this.id, "blocked", "false");
     }
 
     async addJob(data: any) {
@@ -44,13 +33,13 @@ export class RedisQueue<T, R> implements IQueue<T, R> {
         if (blocked) {
             await this.client.hSet(this.id, "blocked", "true");
         } else {
-            await this.client.hDel(this.id, "blocked");
+            await this.client.hSet(this.id, "blocked", "false");
         }
     }
 
     async isBlocked() {
         const blockedResult = await this.client.hGet(this.id, "blocked");
-        if (blockedResult) {
+        if (blockedResult === "true") {
             return true;
         }
 
@@ -80,7 +69,6 @@ export class RedisQueue<T, R> implements IQueue<T, R> {
     }
 
     async removeDependencies(job: IJob<OperationJob>) {
-        const allDeps1 = await this.client.lLen(this.id + "-deps");
         await this.client.lRem(this.id + "-deps", 1, JSON.stringify(job));
         const allDeps = await this.client.lLen(this.id + "-deps");
         if (allDeps > 0) {
@@ -91,15 +79,15 @@ export class RedisQueue<T, R> implements IQueue<T, R> {
     }
 
     async isDeleted() {
-        const deleted = await this.client.hGet(this.id, "deleted");
-        return deleted === "true";
+        const active = await this.client.hGet("queues", this.id);
+        return active === "false";
     }
 
     async setDeleted(deleted: boolean) {
         if (deleted) {
-            await this.client.hSet(this.id, "deleted", "true");
+            await this.client.hSet("queues", this.id, "false");
         } else {
-            await this.client.hDel(this.id, "deleted");
+            await this.client.hSet("queues", this.id, "true");
         }
     }
 }
@@ -115,10 +103,12 @@ export class RedisQueueManager extends BaseQueueManager implements IQueueManager
 
     async init(delegate: IServerDelegate, onError: (error: Error) => void): Promise<void> {
         await super.init(delegate, onError);
-        // load all queues
         const queues = await this.client.hGetAll("queues");
         for (const queueId in queues) {
-            this.queues.push(new RedisQueue(queueId, this.client));
+            const active = await this.client.hGet("queues", queueId);
+            if (active === "true") {
+                this.queues.push(new RedisQueue(queueId, this.client));
+            }
         }
     }
 

package/src/queue/types.ts

@@ -23,7 +23,6 @@ export interface IServerDelegate {
 
 export interface IQueueManager {
     addJob(job: OperationJob): Promise<JobId>;
-    getResult(driveId: string, documentId: string, jobId: JobId): Promise<IOperationResult | undefined>;
     getQueue(driveId: string, document?: string): IQueue<OperationJob, IOperationResult>;
     removeQueue(driveId: string, documentId?: string): void;
     getQueueByIndex(index: number): IQueue<OperationJob, IOperationResult> | null;
@@ -47,8 +46,6 @@ export interface IQueue<T, R> {
     isBlocked(): Promise<boolean>;
     isDeleted(): Promise<boolean>;
     setDeleted(deleted: boolean): Promise<void>;
-    setResult(jobId: JobId, result: R): Promise<void>;
-    getResult(jobId: JobId): Promise<R | undefined>;
     getJobs(): Promise<IJob<T>[]>;
     addDependencies(job: IJob<OperationJob>): Promise<void>;
     removeDependencies(job: IJob<OperationJob>): Promise<void>;

package/src/server/index.ts

@@ -20,7 +20,7 @@ import {
     DocumentModel,
     Operation,
     OperationScope,
-    State
+    utils as DocumentUtils
 } from 'document-model/document';
 import { createNanoEvents, Unsubscribe } from 'nanoevents';
 import { ICache } from '../cache';
@@ -425,7 +425,8 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
             type: operation.type,
             input: operation.input as object,
             skip: operation.skip,
-            context: operation.context
+            context: operation.context,
+            id: operation.id
         }));
     }
 
@@ -630,6 +631,7 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
 
     async _processOperations<T extends Document, A extends Action>(
         drive: string,
+        documentId: string | undefined,
         storageDocument: DocumentStorage<T>,
         operations: Operation<A | BaseAction>[]
     ) {
@@ -667,7 +669,7 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
                     : merge(trunk, invertedTrunk, reshuffleByTimestamp);
 
             const newOperations = newHistory.filter(
-                (op: any) => trunk.length < 1 || precedes(trunk[trunk.length - 1]!, op)
+                (op) => trunk.length < 1 || precedes(trunk[trunk.length - 1]!, op)
             );
 
             for (const nextOperation of newOperations) {
@@ -676,15 +678,20 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
                 // when dealing with a merge (tail.length > 0) we have to skip hash validation
                 // for the operations that were re-indexed (previous hash becomes invalid due the new position in the history)
                 if (tail.length > 0) {
-                    skipHashValidation = [...invertedTrunk, ...tail].some(
-                        invertedTrunkOp =>
-                            invertedTrunkOp.hash === nextOperation.hash
+                    const sourceOperation = operations.find(
+                        op => op.hash === nextOperation.hash
                     );
+
+                    skipHashValidation =
+                        !sourceOperation ||
+                        sourceOperation.index !== nextOperation.index ||
+                        sourceOperation.skip !== nextOperation.skip;
                 }
 
                 try {
                     const appliedResult = await this._performOperation(
                         drive,
+                        documentId,
                         document,
                         nextOperation,
                         skipHashValidation
@@ -720,6 +727,10 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
     private _buildDocument<T extends Document>(
         documentStorage: DocumentStorage<T>, options?: GetDocumentOptions
     ): T {
+        if (documentStorage.state && (!options || options.checkHashes === false)) {
+            return documentStorage as T;
+        }
+
         const documentModel = this._getDocumentModel(
             documentStorage.documentType
         );
@@ -728,11 +739,7 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
             documentStorage.operations,
             options.revisions
         ) : documentStorage.operations;
-        const operations = baseUtils.documentHelpers.grabageCollectDocumentOperations(revisionOperations);
-
-        if (documentStorage.state && (!options || options.checkHashes === false)) {
-            return documentStorage as T;
-        }
+        const operations = baseUtils.documentHelpers.garbageCollectDocumentOperations(revisionOperations);
 
         return baseUtils.replayDocument(
             documentStorage.initialState,
@@ -741,12 +748,17 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
             undefined,
             documentStorage,
             undefined,
-            { checkHashes: options?.checkHashes ?? true }
+            {
+                ...options,
+                checkHashes: options?.checkHashes ?? true,
+                reuseOperationResultingState: options?.checkHashes ?? true
+            }
         ) as T;
     }
 
     private async _performOperation<T extends Document>(
         drive: string,
+        id: string | undefined,
         document: T,
         operation: Operation,
         skipHashValidation = false
@@ -756,6 +768,25 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
         const signalResults: SignalResult[] = [];
         let newDocument = document;
 
+        const scope = operation.scope;
+        const documentOperations = DocumentUtils.documentHelpers.garbageCollectDocumentOperations(
+            {
+                ...document.operations,
+                [scope]: DocumentUtils.documentHelpers.skipHeaderOperations(
+                    document.operations[scope],
+                    operation,
+                ),
+            },
+        );
+
+        const lastRemainingOperation = documentOperations[scope].at(-1);
+        // if the latest operation doesn't have a resulting state then tries
+        // to retrieve it from the db to avoid rerunning all the operations
+        if (lastRemainingOperation && !lastRemainingOperation.resultingState) {
+            lastRemainingOperation.resultingState = await (id ? this.storage.getOperationResultingState?.(drive, id, lastRemainingOperation.index, lastRemainingOperation.scope, "main") :
+                this.storage.getDriveOperationResultingState?.(drive, lastRemainingOperation.index, lastRemainingOperation.scope, "main"))
+        }
+
         const operationSignals: (() => Promise<SignalResult>)[] = [];
         newDocument = documentModel.reducer(
             newDocument,
@@ -792,7 +823,7 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
                     );
                 }
             },
-            { skip: operation.skip }
+            { skip: operation.skip, reuseOperationResultingState: true }
         ) as T;
 
         const appliedOperation = newDocument.operations[operation.scope].filter(
@@ -837,7 +868,6 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
         callback: (document: DocumentStorage) => Promise<{
             operations: Operation[];
             header: DocumentHeader;
-            newState: State<any, any> | undefined;
         }>
     ) {
         if (!this.storage.addDocumentOperationsWithTransaction) {
@@ -884,7 +914,6 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
                     }
                 });
                 const unsubscribeError = this.queueManager.on('jobFailed', (job, error) => {
-                    console.log("test")
                     if (job.jobId === jobId) {
                         unsubscribe();
                         unsubscribeError();
@@ -913,6 +942,7 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
             await this._addOperations(drive, id, async documentStorage => {
                 const result = await this._processOperations(
                     drive,
+                    id,
                     documentStorage,
                     operations
                 );
@@ -1098,7 +1128,7 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
                 const result = await this._processOperations<
                     DocumentDriveDocument,
                     DocumentDriveAction
-                >(drive, documentStorage, operations.slice());
+                >(drive, undefined, documentStorage, operations.slice());
 
                 document = result.document;
                 operationsApplied.push(...result.operationsApplied);
@@ -1259,7 +1289,7 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
         const document = await this.getDrive(drive);
         const operations = this._buildOperations(document, actions);
         const result = await this.queueDriveOperations(drive, operations);
-        return result as IOperationResult<DocumentDriveDocument>;
+        return result;
     }
 
     async addInternalListener(

package/src/server/listener/transmitter/pull-responder.ts

@@ -1,4 +1,4 @@
-import { ListenerFilter, Trigger, z } from 'document-model-libs/document-drive';
+import { ListenerFilter, Trigger } from 'document-model-libs/document-drive';
 import { Operation, OperationScope } from 'document-model/document';
 import { PULL_DRIVE_INTERVAL } from '../..';
 import { generateUUID } from '../../../utils';
@@ -153,6 +153,7 @@ export class PullResponderTransmitter implements IPullResponderTransmitter {
                                 scope
                                 branch
                                 operations {
+                                    id
                                     timestamp
                                     skip
                                     type
@@ -237,13 +238,11 @@ export class PullResponderTransmitter implements IPullResponderTransmitter {
             const listenerRevisions: ListenerRevisionWithError[] = [];
 
             for (const strand of strands) {
-                const operations: Operation[] = strand.operations.map(
-                    (op) => ({
-                        ...op,
-                        scope: strand.scope,
-                        branch: strand.branch
-                    })
-                );
+                const operations: Operation[] = strand.operations.map(op => ({
+                    ...op,
+                    scope: strand.scope,
+                    branch: strand.branch
+                }));
 
                 let error: Error | undefined = undefined;
                 try {

package/src/server/types.ts

@@ -14,6 +14,7 @@ import type {
     Document,
     Operation,
     OperationScope,
+    ReducerOptions,
     Signal,
     State
 } from 'document-model/document';
@@ -116,6 +117,7 @@ export type OperationUpdate = {
     input: object;
     hash: string;
     context?: ActionContext;
+    id?: string;
 };
 
 export type StrandUpdate = {
@@ -140,7 +142,7 @@ export type PartialRecord<K extends keyof any, T> = {
 
 export type RevisionsFilter = PartialRecord<OperationScope, number>;
 
-export type GetDocumentOptions = {
+export type GetDocumentOptions = ReducerOptions & {
     revisions?: RevisionsFilter;
     checkHashes?: boolean;
 };

package/src/storage/prisma.ts

@@ -1,30 +1,44 @@
-import { PrismaClient, Prisma } from '@prisma/client';
+import { Prisma, PrismaClient } from '@prisma/client';
 import { PrismaClientKnownRequestError } from '@prisma/client/runtime/library';
-import { backOff, IBackOffOptions } from "exponential-backoff";
 import {
     DocumentDriveAction,
     DocumentDriveLocalState,
     DocumentDriveState
 } from 'document-model-libs/document-drive';
 import type {
+    Action,
+    AttachmentInput,
+    DocumentOperations,
+    FileRegistry,
     BaseAction,
+    Document,
     DocumentHeader,
     ExtendedState,
     Operation,
     OperationScope,
     State
 } from 'document-model/document';
+import { IBackOffOptions, backOff } from 'exponential-backoff';
 import { ConflictOperationError } from '../server/error';
 import { logger } from '../utils/logger';
 import { DocumentDriveStorage, DocumentStorage, IDriveStorage } from './types';
 
-type Transaction = Omit<
-    PrismaClient<Prisma.PrismaClientOptions, never>,
-    '$connect' | '$disconnect' | '$on' | '$transaction' | '$use' | '$extends'
-> | ExtendedPrismaClient;
+type Transaction =
+    | Omit<
+        PrismaClient<Prisma.PrismaClientOptions, never>,
+        | '$connect'
+        | '$disconnect'
+        | '$on'
+        | '$transaction'
+        | '$use'
+        | '$extends'
+    >
+    | ExtendedPrismaClient;
 
 function storageToOperation(
-    op: Prisma.$OperationPayload['scalars']
+    op: Prisma.$OperationPayload['scalars'] & {
+        attachments?: AttachmentInput[];
+    }
 ): Operation {
     const operation: Operation = {
         skip: op.skip,
@@ -34,7 +48,10 @@ function storageToOperation(
         input: JSON.parse(op.input),
         type: op.type,
         scope: op.scope as OperationScope,
-        // attachments: fileRegistry
+        resultingState: op.resultingState
+            ? op.resultingState.toString()
+            : undefined,
+        attachments: op.attachments
     };
     if (op.context) {
         operation.context = op.context as Prisma.JsonObject;
@@ -44,27 +61,32 @@ function storageToOperation(
 
 export type PrismaStorageOptions = {
     transactionRetryBackoff?: IBackOffOptions;
-}
+};
 
-function getRetryTransactionsClient<T extends PrismaClient>(prisma: T, backOffOptions?: Partial<IBackOffOptions>) {
+function getRetryTransactionsClient<T extends PrismaClient>(
+    prisma: T,
+    backOffOptions?: Partial<IBackOffOptions>
+) {
     return prisma.$extends({
         client: {
-            $transaction: (...args: Parameters<T["$transaction"]>) => {
+            $transaction: (...args: Parameters<T['$transaction']>) => {
                 // eslint-disable-next-line prefer-spread
                 return backOff(() => prisma.$transaction.apply(prisma, args), {
-                    retry: (e) => {
+                    retry: e => {
                         // Retry the transaction only if the error was due to a write conflict or deadlock
                         // See: https://www.prisma.io/docs/reference/api-reference/error-reference#p2034
-                        return (e as { code: string }).code === "P2034";
+                        return (e as { code: string }).code === 'P2034';
                     },
-                    ...backOffOptions,
+                    ...backOffOptions
                 });
             }
         }
     });
 }
 
-type ExtendedPrismaClient = ReturnType<typeof getRetryTransactionsClient<PrismaClient>>;
+type ExtendedPrismaClient = ReturnType<
+    typeof getRetryTransactionsClient<PrismaClient>
+>;
 
 export class PrismaStorage implements IDriveStorage {
     private db: ExtendedPrismaClient;
@@ -73,9 +95,8 @@ export class PrismaStorage implements IDriveStorage {
         const backOffOptions = options?.transactionRetryBackoff;
         this.db = getRetryTransactionsClient(db, {
             ...backOffOptions,
-            jitter: backOffOptions?.jitter ?? "full"
+            jitter: backOffOptions?.jitter ?? 'full'
         });
-
     }
 
     async createDrive(id: string, drive: DocumentDriveStorage): Promise<void> {
@@ -136,8 +157,7 @@ export class PrismaStorage implements IDriveStorage {
                 initialState: JSON.stringify(document.initialState),
                 lastModified: document.lastModified,
                 revision: JSON.stringify(document.revision),
-                id,
-                state: JSON.stringify(document.state)
+                id
             }
         });
     }
@@ -147,14 +167,8 @@ export class PrismaStorage implements IDriveStorage {
         drive: string,
         id: string,
         operations: Operation[],
-        header: DocumentHeader,
-        newState: State<any, any> | undefined = undefined
+        header: DocumentHeader
     ): Promise<void> {
-        const document = await this.getDocument(drive, id, tx);
-        if (!document) {
-            throw new Error(`Document with id ${id} not found`);
-        }
-
         try {
             await tx.operation.createMany({
                 data: operations.map(op => ({
@@ -168,7 +182,10 @@ export class PrismaStorage implements IDriveStorage {
                     scope: op.scope,
                     branch: 'main',
                     skip: op.skip,
-                    context: op.context
+                    context: op.context,
+                    resultingState: op.resultingState
+                        ? Buffer.from(JSON.stringify(op.resultingState))
+                        : undefined
                 }))
             });
 
@@ -179,10 +196,34 @@ export class PrismaStorage implements IDriveStorage {
                 },
                 data: {
                     lastModified: header.lastModified,
-                    revision: JSON.stringify(header.revision),
-                    state: JSON.stringify(newState)
+                    revision: JSON.stringify(header.revision)
                 }
             });
+
+            await Promise.all(
+                operations
+                    .filter(o => o.attachments?.length)
+                    .map(op => {
+                        return tx.operation.update({
+                            where: {
+                                unique_operation: {
+                                    driveId: drive,
+                                    documentId: id,
+                                    index: op.index,
+                                    scope: op.scope,
+                                    branch: 'main'
+                                }
+                            },
+                            data: {
+                                attachments: {
+                                    createMany: {
+                                        data: op.attachments ?? []
+                                    }
+                                }
+                            }
+                        });
+                    })
+            );
         } catch (e) {
             // P2002: Unique constraint failed
             // Operation with existing index
@@ -209,6 +250,7 @@ export class PrismaStorage implements IDriveStorage {
                 );
 
                 if (!existingOperation || !conflictOp) {
+                    console.error(e);
                     throw e;
                 } else {
                     throw new ConflictOperationError(
@@ -228,7 +270,7 @@ export class PrismaStorage implements IDriveStorage {
         callback: (document: DocumentStorage) => Promise<{
             operations: Operation[];
             header: DocumentHeader;
-            newState?: State<any, any> | undefined
+            newState?: State<any, any> | undefined;
         }>
     ) {
         let result: {
@@ -237,24 +279,25 @@ export class PrismaStorage implements IDriveStorage {
             newState?: State<any, any> | undefined;
         } | null = null;
 
-        await this.db.$transaction(async tx => {
-            const document = await this.getDocument(drive, id, tx);
-            if (!document) {
-                throw new Error(`Document with id ${id} not found`);
-            }
-            result = await callback(document);
-
-            const { operations, header, newState } = result;
-            return this._addDocumentOperations(
-                tx,
-                drive,
-                id,
-                operations,
-                header,
-                newState
-            );
-        }, { isolationLevel: "Serializable" });
+        await this.db.$transaction(
+            async tx => {
+                const document = await this.getDocument(drive, id, tx);
+                if (!document) {
+                    throw new Error(`Document with id ${id} not found`);
+                }
+                result = await callback(document);
 
+                const { operations, header, newState } = result;
+                return this._addDocumentOperations(
+                    tx,
+                    drive,
+                    id,
+                    operations,
+                    header
+                );
+            },
+            { isolationLevel: 'Serializable' }
+        );
 
         // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
         if (!result) {
@@ -268,14 +311,14 @@ export class PrismaStorage implements IDriveStorage {
         drive: string,
         id: string,
         operations: Operation[],
-        header: DocumentHeader,
+        header: DocumentHeader
     ): Promise<void> {
         return this._addDocumentOperations(
             this.db,
             drive,
             id,
             operations,
-            header,
+            header
         );
     }
 
@@ -299,25 +342,18 @@ export class PrismaStorage implements IDriveStorage {
             where: {
                 id: id,
                 driveId: driveId
-            },
+            }
         });
         return count > 0;
     }
 
     async getDocument(driveId: string, id: string, tx?: Transaction) {
-        const result = await (tx ?? this.db).document.findFirst({
+        const prisma = tx ?? this.db;
+        const result = await prisma.document.findUnique({
             where: {
-                id: id,
-                driveId: driveId
-            },
-            include: {
-                operations: {
-                    orderBy: {
-                        index: 'asc'
-                    },
-                    include: {
-                        attachments: true
-                    }
+                id_driveId: {
+                    driveId,
+                    id
                 }
             }
         });
@@ -326,8 +362,72 @@ export class PrismaStorage implements IDriveStorage {
             throw new Error(`Document with id ${id} not found`);
         }
 
+        // retrieves operations with resulting state
+        // for the last operation of each scope
+        const operations = await prisma.$queryRaw<
+            Prisma.$OperationPayload['scalars'][]
+        >`
+            WITH ranked_operations AS (
+            SELECT
+                *,
+                ROW_NUMBER() OVER (PARTITION BY scope ORDER BY index DESC) AS rn
+            FROM "Operation"
+            )
+            SELECT
+            "id",
+            "opId",
+            "scope",
+            "branch",
+            "index",
+            "skip",
+            "hash",
+            "timestamp",
+            "input",
+            "type",
+            "context",
+            CASE
+                WHEN rn = 1 THEN "resultingState"
+                ELSE NULL
+            END AS "resultingState"
+            FROM ranked_operations
+            WHERE "driveId" = ${driveId} AND "documentId" = ${id}
+            ORDER BY scope, index;
+        `;
+
+        const operationIds = operations.map(o => o.id);
+        const attachments = await prisma.attachment.findMany({
+            where: {
+                operationId: {
+                    in: operationIds
+                }
+            }
+        });
+
+        const fileRegistry: FileRegistry = {};
+        const operationsByScope = operations.reduce<DocumentOperations<Action>>(
+            (acc, operation) => {
+                const scope = operation.scope as OperationScope;
+                if (!acc[scope]) {
+                    acc[scope] = [];
+                }
+                const result = storageToOperation(operation);
+                result.attachments = attachments.filter(
+                    a => a.operationId === operation.id
+                );
+                result.attachments.forEach(({ hash, ...file }) => {
+                    fileRegistry[hash] = file;
+                });
+                acc[scope].push(result);
+                return acc;
+            },
+            {
+                global: [],
+                local: []
+            }
+        );
+
         const dbDoc = result;
-        const doc = {
+        const doc: Document = {
             created: dbDoc.created.toISOString(),
             name: dbDoc.name ? dbDoc.name : '',
             documentType: dbDoc.documentType,
@@ -335,22 +435,19 @@ export class PrismaStorage implements IDriveStorage {
                 DocumentDriveState,
                 DocumentDriveLocalState
             >,
-            state: JSON.parse(dbDoc.state) as State<unknown, unknown>,
+            state: undefined,
             lastModified: new Date(dbDoc.lastModified).toISOString(),
-            operations: {
-                global: dbDoc.operations
-                    .filter(op => op.scope === 'global' && !op.clipboard)
-                    .map(storageToOperation),
-                local: dbDoc.operations
-                    .filter(op => op.scope === 'local' && !op.clipboard)
-                    .map(storageToOperation)
-            },
-            clipboard: dbDoc.operations
-                .filter(op => op.clipboard)
-                .map(storageToOperation),
-            revision: JSON.parse(dbDoc.revision) as Record<OperationScope, number>
+            operations: operationsByScope,
+            clipboard: [],
+            revision: JSON.parse(dbDoc.revision) as Record<
+                OperationScope,
+                number
+            >,
+            attachments: {}
         };
 
+
+
         return doc;
     }
 
@@ -408,4 +505,23 @@ export class PrismaStorage implements IDriveStorage {
         });
         await this.deleteDocument('drives', id);
     }
+
+    async getOperationResultingState(driveId: string, documentId: string, index: number, scope: string, branch: string): Promise<unknown> {
+        const operation = await this.db.operation.findUnique({
+            where: {
+                unique_operation: {
+                    driveId,
+                    documentId,
+                    index,
+                    scope,
+                    branch
+                }
+            }
+        });
+        return operation?.resultingState?.toString();
+    }
+
+    getDriveOperationResultingState(drive: string, index: number, scope: string, branch: string): Promise<unknown> {
+        return this.getOperationResultingState("drives", drive, index, scope, branch);
+    }
 }

package/src/storage/sequelize.ts

@@ -25,8 +25,8 @@ export class SequelizeStorage implements IDriveStorage {
                 type: DataTypes.STRING,
                 primaryKey: true
             },
-            id: DataTypes.STRING,
-        })
+            id: DataTypes.STRING
+        });
         const Document = this.db.define('document', {
             id: {
                 type: DataTypes.STRING,
@@ -155,7 +155,7 @@ export class SequelizeStorage implements IDriveStorage {
         drive: string,
         id: string,
         operations: Operation[],
-        header: DocumentHeader,
+        header: DocumentHeader
     ): Promise<void> {
         const document = await this.getDocument(drive, id);
         if (!document) {
@@ -177,7 +177,8 @@ export class SequelizeStorage implements IDriveStorage {
                 timestamp: op.timestamp,
                 type: op.type,
                 scope: op.scope,
-                branch: 'main'
+                branch: 'main',
+                opId: op.id
             }))
         );
 
@@ -284,8 +285,8 @@ export class SequelizeStorage implements IDriveStorage {
             where: {
                 id: id,
                 driveId: driveId
-            },
-        })
+            }
+        });
 
         return count > 0;
     }
@@ -323,6 +324,7 @@ export class SequelizeStorage implements IDriveStorage {
                     input: JSON;
                     type: string;
                     scope: string;
+                    opId?: string;
                 }
             ];
             revision: Required<Record<OperationScope, number>>;
@@ -348,13 +350,15 @@ export class SequelizeStorage implements IDriveStorage {
                 input: JSON;
                 type: string;
                 scope: string;
+                opId?: string;
             }) => ({
                 hash: op.hash,
                 index: op.index,
                 timestamp: new Date(op.timestamp).toISOString(),
                 input: op.input,
                 type: op.type,
-                scope: op.scope as OperationScope
+                scope: op.scope as OperationScope,
+                id: op.opId
                 // attachments: fileRegistry
             })
         );

package/src/storage/types.ts

@@ -39,10 +39,10 @@ export interface IStorage {
         callback: (document: DocumentStorage) => Promise<{
             operations: Operation[];
             header: DocumentHeader;
-            newState: State<any, any> | undefined
         }>
     ): Promise<void>;
     deleteDocument(drive: string, id: string): Promise<void>;
+    getOperationResultingState?(drive: string, id: string, index: number, scope: string, branch: string): Promise<unknown>;
 }
 
 export interface IDriveStorage extends IStorage {
@@ -64,4 +64,5 @@ export interface IDriveStorage extends IStorage {
             header: DocumentHeader;
         }>
     ): Promise<void>;
+    getDriveOperationResultingState?(drive: string, index: number, scope: string, branch: string): Promise<unknown>;
 }

package/src/queue/manager.ts

@@ -1,22 +0,0 @@
-import { Unsubscribe } from "nanoevents";
-import { IOperationResult } from "../server";
-import { IQueueManager, QueueEvents } from "./types";
-
-export class BaseQueueManager implements IQueueManager {
-
-    constructor() {
-    }
-    addJob(job: OperationJob): Promise<string> {
-        throw new Error("Method not implemented.");
-    }
-    getResult(driveId: string, documentId: string, jobId: JobId): Promise<IOperationResult | undefined> {
-        throw new Error("Method not implemented.");
-    }
-    init(processor: OperationJobProcessor, onError: (error: Error) => void): Promise<void> {
-        throw new Error("Method not implemented.");
-    }
-    on<K extends keyof QueueEvents>(this: this, event: K, cb: QueueEvents[K]): Unsubscribe {
-        throw new Error("Method not implemented.");
-    }
-
-}