document-drive 1.8.5 → 1.10.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "document-drive",
-  "version": "1.8.5",
+  "version": "1.10.0",
   "license": "AGPL-3.0-only",
   "type": "module",
   "module": "./src/index.ts",
@@ -33,9 +33,9 @@
     "nanoevents": "^9.0.0",
     "sanitize-filename": "^1.6.3",
     "uuid": "^9.0.1",
-    "document-model": "2.10.0",
-    "document-model-libs": "1.120.4",
-    "@powerhousedao/scalars": "1.12.0"
+    "@powerhousedao/scalars": "1.13.0",
+    "document-model": "2.11.0",
+    "document-model-libs": "1.121.1"
   },
   "optionalDependencies": {
     "@prisma/client": "^5.18.0",
@@ -44,7 +44,7 @@
     "redis": "^4.6.15",
     "sequelize": "^6.37.3",
     "sqlite3": "^5.1.7",
-    "@powerhousedao/scalars": "1.12.0"
+    "@powerhousedao/scalars": "1.13.0"
   },
   "devDependencies": {
     "@prisma/client": "5.17.0",
@@ -66,8 +66,8 @@
     "nanoevents": "^9.0.0",
     "sanitize-filename": "^1.6.3",
     "uuid": "^9.0.1",
-    "document-model": "2.10.0",
-    "document-model-libs": "1.120.4"
+    "document-model": "2.11.0",
+    "document-model-libs": "1.121.1"
   },
   "scripts": {
     "check-types": "tsc --build",
@@ -79,6 +79,6 @@
     "test:watch": "vitest watch",
     "clean": "rimraf dist",
     "clean:node_modules": "rimraf node_modules",
-    "build": "prisma generate"
+    "postinstall": "prisma generate"
   }
 }

package/src/index.ts

@@ -2,5 +2,3 @@ export * from "./server";
 export * from "./server/error";
 export * from "./storage";
 export * from "./utils";
-
-export const test = "test";

package/src/server/index.ts

@@ -100,7 +100,7 @@ import {
   type SignalResult,
   type SynchronizationUnit,
 } from "./types";
-import { filterOperationsByRevision } from "./utils";
+import { filterOperationsByRevision, isAtRevision } from "./utils";
 
 export * from "./listener";
 export type * from "./types";
@@ -1000,21 +1000,27 @@ export class BaseDocumentDriveServer
   }
 
   async getDrive(drive: string, options?: GetDocumentOptions) {
+    let document: DocumentDriveDocument | undefined;
     try {
-      const document = await this.cache.getDocument("drives", drive); // TODO support GetDocumentOptions
-      if (document && isDocumentDrive(document)) {
-        return document;
+      const cachedDocument = await this.cache.getDocument("drives", drive); // TODO support GetDocumentOptions
+      if (cachedDocument && isDocumentDrive(cachedDocument)) {
+        document = cachedDocument;
+        if (isAtRevision(document, options?.revisions)) {
+          return document;
+        }
       }
     } catch (e) {
       logger.error("Error getting drive from cache", e);
     }
-    const driveStorage = await this.storage.getDrive(drive);
-    const document = this._buildDocument(driveStorage, options);
-    if (!isDocumentDrive(document)) {
+    const driveStorage = document ?? (await this.storage.getDrive(drive));
+    const result = this._buildDocument(driveStorage, options);
+    if (!isDocumentDrive(result)) {
       throw new Error(`Document with id ${drive} is not a Document Drive`);
     } else {
-      this.cache.setDocument("drives", drive, document).catch(logger.error);
-      return document;
+      if (!options?.revisions) {
+        this.cache.setDocument("drives", drive, result).catch(logger.error);
+      }
+      return result;
     }
   }
 
@@ -1039,18 +1045,22 @@ export class BaseDocumentDriveServer
   }
 
   async getDocument(drive: string, id: string, options?: GetDocumentOptions) {
+    let cachedDocument: Document | undefined;
     try {
-      const document = await this.cache.getDocument(drive, id); // TODO support GetDocumentOptions
-      if (document) {
-        return document;
+      cachedDocument = await this.cache.getDocument(drive, id); // TODO support GetDocumentOptions
+      if (cachedDocument && isAtRevision(cachedDocument, options?.revisions)) {
+        return cachedDocument;
       }
     } catch (e) {
       logger.error("Error getting document from cache", e);
     }
-    const documentStorage = await this.storage.getDocument(drive, id);
+    const documentStorage =
+      cachedDocument ?? (await this.storage.getDocument(drive, id));
     const document = this._buildDocument(documentStorage, options);
 
-    this.cache.setDocument(drive, id, document).catch(logger.error);
+    if (!options?.revisions) {
+      this.cache.setDocument(drive, id, document).catch(logger.error);
+    }
     return document;
   }
 
@@ -1293,7 +1303,11 @@ export class BaseDocumentDriveServer
     documentStorage: DocumentStorage<T>,
     options?: GetDocumentOptions,
   ): T {
-    if (documentStorage.state && (!options || options.checkHashes === false)) {
+    if (
+      documentStorage.state &&
+      (!options || options.checkHashes === false) &&
+      isAtRevision(documentStorage as unknown as Document, options?.revisions)
+    ) {
       return documentStorage as T;
     }
 

package/src/server/listener/manager.ts

@@ -102,6 +102,8 @@ export class ListenerManager extends BaseListenerManager {
     const driveTransmitters = this.transmitters[drive] || {};
     driveTransmitters[listener.listenerId] = transmitter;
     this.transmitters[drive] = driveTransmitters;
+
+    this.triggerUpdate(true, { type: "local" });
     return Promise.resolve(transmitter);
   }
 

package/src/server/listener/transmitter/internal.ts

@@ -1,30 +1,41 @@
-import { Document, OperationScope } from "document-model/document";
+import { Document, Operation, OperationScope } from "document-model/document";
 import { logger } from "../../../utils/logger";
 import {
+  GetDocumentOptions,
   IBaseDocumentDriveServer,
   Listener,
   ListenerRevision,
-  OperationUpdate,
   StrandUpdate,
 } from "../../types";
-import { buildRevisionsFilter } from "../../utils";
-import { ITransmitter } from "./types";
+import { ITransmitter, StrandUpdateSource } from "./types";
+import { InferDocumentOperation } from "../../../read-mode/types";
 
-export interface IReceiver {
-  transmit: (strands: InternalTransmitterUpdate[]) => Promise<void>;
-  disconnect: () => Promise<void>;
+export interface IReceiver<
+  T extends Document = Document,
+  S extends OperationScope = OperationScope,
+> {
+  onStrands: (strands: InternalTransmitterUpdate<T, S>[]) => Promise<void>;
+  onDisconnect: () => Promise<void>;
 }
 
+export type InternalOperationUpdate<
+  D extends Document = Document,
+  S extends OperationScope = OperationScope,
+> = Omit<Operation<InferDocumentOperation<D>>, "scope"> & {
+  state: D["state"][S];
+  previousState: D["state"][S];
+};
+
 export type InternalTransmitterUpdate<
-  T extends Document = Document,
+  D extends Document = Document,
   S extends OperationScope = OperationScope,
 > = {
   driveId: string;
   documentId: string;
   scope: S;
   branch: string;
-  operations: OperationUpdate[];
-  state: T["state"][S];
+  operations: InternalOperationUpdate<D, S>[];
+  state: D["state"][S];
 };
 
 export interface IInternalTransmitter extends ITransmitter {
@@ -32,52 +43,80 @@ export interface IInternalTransmitter extends ITransmitter {
 }
 
 export class InternalTransmitter implements ITransmitter {
-  private drive: IBaseDocumentDriveServer;
-  private listener: Listener;
-  private receiver: IReceiver | undefined;
+  protected drive: IBaseDocumentDriveServer;
+  protected listener: Listener;
+  protected receiver: IReceiver | undefined;
 
   constructor(listener: Listener, drive: IBaseDocumentDriveServer) {
     this.listener = listener;
     this.drive = drive;
   }
 
+  async #buildInternalOperationUpdate(strand: StrandUpdate) {
+    const operations: InternalOperationUpdate[] = [];
+    const stateByIndex = new Map<number, unknown>();
+    const getStateByIndex = async (index: number) => {
+      const state = stateByIndex.get(index);
+      if (state) {
+        return state;
+      }
+
+      const getDocumentOptions: GetDocumentOptions = {
+        revisions: {
+          [strand.scope]: index,
+        },
+        checkHashes: false,
+      };
+      const document = await (strand.documentId
+        ? this.drive.getDocument(
+            strand.driveId,
+            strand.documentId,
+            getDocumentOptions,
+          )
+        : this.drive.getDrive(strand.driveId, getDocumentOptions));
+
+      if (index < 0) {
+        stateByIndex.set(index, document.initialState.state[strand.scope]);
+      } else {
+        stateByIndex.set(index, document.state[strand.scope]);
+      }
+      return stateByIndex.get(index);
+    };
+    for (const operation of strand.operations) {
+      operations.push({
+        ...operation,
+        state: await getStateByIndex(operation.index),
+        previousState: await getStateByIndex(operation.index - 1),
+      });
+    }
+    return operations;
+  }
+
   async transmit(
-    strands: InternalTransmitterUpdate[],
+    strands: StrandUpdate[],
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    _source: StrandUpdateSource,
   ): Promise<ListenerRevision[]> {
     if (!this.receiver) {
       return [];
     }
 
-    const retrievedDocuments = new Map<string, Document>();
     const updates: InternalTransmitterUpdate[] = [];
     for (const strand of strands) {
-      let document = retrievedDocuments.get(
-        `${strand.driveId}:${strand.documentId}`,
-      );
-      if (!document) {
-        const revisions = buildRevisionsFilter(
-          strands,
-          strand.driveId,
-          strand.documentId,
-        );
-        document = await (strand.documentId
-          ? this.drive.getDocument(strand.driveId, strand.documentId, {
-              revisions,
-            })
-          : this.drive.getDrive(strand.driveId, { revisions }));
-        retrievedDocuments.set(
-          `${strand.driveId}:${strand.documentId}`,
-          document,
-        );
-      }
-      updates.push({ ...strand, state: document.state[strand.scope] });
+      const operations = await this.#buildInternalOperationUpdate(strand);
+      const state = operations.at(-1)?.state ?? {};
+      updates.push({
+        ...strand,
+        operations,
+        state,
+      });
     }
     try {
-      await this.receiver.transmit(updates);
+      await this.receiver.onStrands(updates);
       return strands.map(({ operations, ...s }) => ({
         ...s,
         status: "SUCCESS",
-        revision: operations[operations.length - 1]?.index ?? -1,
+        revision: operations.at(operations.length - 1)?.index ?? -1,
       }));
     } catch (error) {
       logger.error(error);
@@ -85,7 +124,7 @@ export class InternalTransmitter implements ITransmitter {
       return strands.map(({ operations, ...s }) => ({
         ...s,
         status: "ERROR",
-        revision: (operations[0]?.index ?? 0) - 1,
+        revision: (operations.at(0)?.index ?? 0) - 1,
       }));
     }
   }
@@ -95,6 +134,10 @@ export class InternalTransmitter implements ITransmitter {
   }
 
   async disconnect(): Promise<void> {
-    await this.receiver?.disconnect();
+    await this.receiver?.onDisconnect();
+  }
+
+  getListener(): Listener {
+    return this.listener;
   }
 }

package/src/server/utils.ts

@@ -15,6 +15,18 @@ export function buildRevisionsFilter(
   }, {});
 }
 
+export function buildDocumentRevisionsFilter(
+  document: Document,
+): RevisionsFilter {
+  return Object.entries(document.operations).reduce<RevisionsFilter>(
+    (acc, [scope, operations]) => {
+      acc[scope as OperationScope] = operations.at(-1)?.index ?? -1;
+      return acc;
+    },
+    {} as RevisionsFilter,
+  );
+}
+
 export function filterOperationsByRevision(
   operations: Document["operations"],
   revisions?: RevisionsFilter,
@@ -24,11 +36,47 @@ export function filterOperationsByRevision(
   }
   return (Object.keys(operations) as OperationScope[]).reduce<
     Document["operations"]
-  >((acc, scope) => {
-    const revision = revisions[scope];
-    if (revision !== undefined) {
-      acc[scope] = operations[scope].filter((op) => op.index <= revision);
-    }
-    return acc;
-  }, operations);
+  >(
+    (acc, scope) => {
+      const revision = revisions[scope];
+      if (revision !== undefined) {
+        acc[scope] = operations[scope].filter((op) => op.index <= revision);
+      }
+      return acc;
+    },
+    { global: [], local: [] } as unknown as Document["operations"],
+  );
+}
+
+export function isAtRevision(
+  document: Document,
+  revisions?: RevisionsFilter,
+): boolean {
+  return (
+    !revisions ||
+    Object.entries(revisions).find(([scope, revision]) => {
+      const operation = document.operations[scope as OperationScope].at(-1);
+      if (revision === -1) {
+        return operation !== undefined;
+      }
+      return operation?.index !== revision;
+    }) === undefined
+  );
+}
+
+export function isAfterRevision(
+  document: Document,
+  revisions?: RevisionsFilter,
+): boolean {
+  return (
+    !revisions ||
+    Object.entries(revisions).every(([scope, revision]) => {
+      const operation = document.operations[scope as OperationScope].at(-1);
+
+      if (revision === -1) {
+        return operation !== undefined;
+      }
+      return operation && operation.index > revision;
+    })
+  );
 }