cojson 0.8.35 → 0.8.37

package/src/coValues/coMap.ts

@@ -1,5 +1,5 @@
 import { CoID, RawCoValue } from "../coValue.js";
-import { CoValueCore } from "../coValueCore.js";
+import { CoValueCore, DecryptedTransaction } from "../coValueCore.js";
 import { AgentID, TransactionID } from "../ids.js";
 import { JsonObject, JsonValue } from "../jsonValue.js";
 import { accountOrAgentIDfromSessionID } from "../typeUtils/accountOrAgentIDfromSessionID.js";
@@ -11,7 +11,8 @@ type MapOp<K extends string, V extends JsonValue | undefined> = {
   txID: TransactionID;
   madeAt: number;
   changeIdx: number;
-} & MapOpPayload<K, V>;
+  change: MapOpPayload<K, V>;
+};
 // TODO: add after TransactionID[] for conflicts/ordering
 
 export type MapOpPayload<K extends string, V extends JsonValue | undefined> =
@@ -39,10 +40,21 @@ export class RawCoMapView<
   /** @category 6. Meta */
   core: CoValueCore;
   /** @internal */
-  ops: {
+  latest: {
+    [Key in keyof Shape & string]?: MapOp<Key, Shape[Key]>;
+  };
+  /** @internal */
+  latestTxMadeAt: number;
+  /** @internal */
+  cachedOps?: {
     [Key in keyof Shape & string]?: MapOp<Key, Shape[Key]>[];
   };
   /** @internal */
+  validSortedTransactions?: DecryptedTransaction[];
+
+  /** @internal */
+  options?: { ignorePrivateTransactions: boolean; atTime?: number };
+  /** @internal */
   atTimeFilter?: number = undefined;
   /** @category 6. Meta */
   readonly _shape!: Shape;
@@ -50,33 +62,126 @@ export class RawCoMapView<
   /** @internal */
   constructor(
     core: CoValueCore,
-    options?: { ignorePrivateTransactions: true },
+    options?: {
+      ignorePrivateTransactions: boolean;
+      atTime?: number;
+      validSortedTransactions?: DecryptedTransaction[];
+      cachedOps?: {
+        [Key in keyof Shape & string]?: MapOp<Key, Shape[Key]>[];
+      };
+    },
   ) {
     this.id = core.id as CoID<this>;
     this.core = core;
-    this.ops = {};
+    this.latest = {};
+    this.latestTxMadeAt = 0;
+    this.options = options;
+    this.cachedOps = options?.cachedOps;
+    this.validSortedTransactions = options?.validSortedTransactions;
+
+    this.processLatestTransactions();
+  }
+
+  /** @internal */
+  private getValidSortedTransactions() {
+    if (this.validSortedTransactions) {
+      return this.validSortedTransactions;
+    }
+
+    const validSortedTransactions = this.core.getValidSortedTransactions({
+      ignorePrivateTransactions:
+        this.options?.ignorePrivateTransactions ?? false,
+    });
+
+    this.validSortedTransactions = validSortedTransactions;
+
+    return validSortedTransactions;
+  }
+
+  private resetCachedValues() {
+    this.validSortedTransactions = undefined;
+    this.cachedOps = undefined;
+  }
+
+  private processLatestTransactions() {
+    // Reset all internal state and cached values
+    this.latest = {};
+    this.latestTxMadeAt = 0;
+
+    const { latest } = this;
+
+    const atTimeFilter = this.options?.atTime;
+
+    for (const { txID, changes, madeAt } of this.getValidSortedTransactions()) {
+      if (atTimeFilter && madeAt > atTimeFilter) {
+        continue;
+      }
+
+      if (madeAt > this.latestTxMadeAt) {
+        this.latestTxMadeAt = madeAt;
+      }
+
+      for (let changeIdx = 0; changeIdx < changes.length; changeIdx++) {
+        const change = changes[changeIdx] as MapOpPayload<
+          keyof Shape & string,
+          Shape[keyof Shape & string]
+        >;
+        let entry = latest[change.key];
+        if (!entry) {
+          entry = {
+            txID,
+            madeAt,
+            changeIdx,
+            change,
+          };
+          latest[change.key] = entry;
+        } else if (madeAt >= entry.madeAt) {
+          entry.txID = txID;
+          entry.madeAt = madeAt;
+          entry.changeIdx = changeIdx;
+          entry.change = change;
+        }
+      }
+    }
+  }
 
-    for (const { txID, changes, madeAt } of core.getValidSortedTransactions(
-      options,
-    )) {
+  revalidateTransactions() {
+    this.resetCachedValues();
+    this.processLatestTransactions();
+  }
+
+  private getOps() {
+    if (this.cachedOps) {
+      return this.cachedOps;
+    }
+
+    const ops: {
+      [Key in keyof Shape & string]?: MapOp<Key, Shape[Key]>[];
+    } = {};
+
+    for (const { txID, changes, madeAt } of this.getValidSortedTransactions()) {
       for (let changeIdx = 0; changeIdx < changes.length; changeIdx++) {
         const change = changes[changeIdx] as MapOpPayload<
           keyof Shape & string,
           Shape[keyof Shape & string]
         >;
-        let entries = this.ops[change.key];
+        let entries = ops[change.key];
         if (!entries) {
           entries = [];
-          this.ops[change.key] = entries;
+          ops[change.key] = entries;
         }
         entries.push({
           txID,
           madeAt,
           changeIdx,
-          ...change,
+          change,
         });
       }
     }
+
+    this.cachedOps = ops;
+
+    return ops;
   }
 
   /** @category 6. Meta */
@@ -91,13 +196,19 @@ export class RawCoMapView<
 
   /** @category 4. Time travel */
   atTime(time: number): this {
-    const clone = Object.create(this) as this;
-    clone.id = this.id;
-    clone.type = this.type;
-    clone.core = this.core;
-    clone.ops = this.ops;
-    clone.atTimeFilter = time;
-    return clone;
+    if (time >= this.latestTxMadeAt) {
+      return this;
+    } else {
+      const clone = new RawCoMapView(this.core, {
+        ignorePrivateTransactions:
+          this.options?.ignorePrivateTransactions ?? false,
+        atTime: time,
+        cachedOps: this.cachedOps,
+        validSortedTransactions: this.validSortedTransactions,
+      });
+      Object.setPrototypeOf(clone, this);
+      return clone as this;
+    }
   }
 
   /** @internal */
@@ -108,10 +219,12 @@ export class RawCoMapView<
       return undefined;
     }
 
-    if (this.atTimeFilter) {
-      return this.ops[key]?.filter((op) => op.madeAt <= this.atTimeFilter!);
+    const atTimeFilter = this.options?.atTime;
+
+    if (atTimeFilter) {
+      return this.getOps()[key]?.filter((op) => op.madeAt <= atTimeFilter);
     } else {
-      return this.ops[key];
+      return this.getOps()[key];
     }
   }
 
@@ -120,18 +233,14 @@ export class RawCoMapView<
    *
    * @category 1. Reading */
   keys<K extends keyof Shape & string = keyof Shape & string>(): K[] {
-    return (Object.keys(this.ops) as K[]).filter((key) => {
-      const ops = this.ops[key];
-      if (!ops) {
-        return undefined;
-      }
+    return (Object.keys(this.latest) as K[]).filter((key) => {
+      const latestChange = this.latest[key];
 
-      const includeUntil = this.atTimeFilter;
-      const lastEntry = includeUntil
-        ? ops.findLast((entry) => entry.madeAt <= includeUntil)
-        : ops[ops.length - 1]!;
+      if (!latestChange) {
+        return false;
+      }
 
-      if (lastEntry?.op === "del") {
+      if (latestChange.change.op === "del") {
         return false;
       } else {
         return true;
@@ -145,20 +254,15 @@ export class RawCoMapView<
    * @category 1. Reading
    **/
   get<K extends keyof Shape & string>(key: K): Shape[K] | undefined {
-    const ops = this.ops[key];
-    if (!ops) {
+    const latestChange = this.latest[key];
+    if (!latestChange) {
       return undefined;
     }
 
-    const includeUntil = this.atTimeFilter;
-    const lastEntry = includeUntil
-      ? ops.findLast((entry) => entry.madeAt <= includeUntil)
-      : ops[ops.length - 1]!;
-
-    if (lastEntry?.op === "del") {
+    if (latestChange.change.op === "del") {
       return undefined;
     } else {
-      return lastEntry?.value;
+      return latestChange.change.value as Shape[K];
     }
   }
 
@@ -170,7 +274,7 @@ export class RawCoMapView<
       [K in keyof Shape & string]: Shape[K];
     }> = {};
 
-    for (const key of this.keys()) {
+    for (const key of Object.keys(this.latest) as (keyof Shape & string)[]) {
       const value = this.get(key);
       if (value !== undefined) {
         object[key] = value;
@@ -190,34 +294,21 @@ export class RawCoMapView<
   }
 
   /** @category 5. Edit history */
-  nthEditAt<K extends keyof Shape & string>(
-    key: K,
-    n: number,
-  ):
-    | {
-        by: RawAccountID | AgentID;
-        tx: TransactionID;
-        at: Date;
-        value?: Shape[K];
-      }
-    | undefined {
-    const ops = this.timeFilteredOps(key);
-    if (!ops || ops.length <= n) {
+  nthEditAt<K extends keyof Shape & string>(key: K, n: number) {
+    const ops = this.getOps()[key];
+
+    const atTimeFilter = this.options?.atTime;
+    const entry = ops?.[n];
+
+    if (!entry) {
       return undefined;
     }
 
-    const entry = ops[n]!;
-
-    if (this.atTimeFilter && entry.madeAt > this.atTimeFilter) {
+    if (atTimeFilter && entry.madeAt > atTimeFilter) {
       return undefined;
     }
 
-    return {
-      by: accountOrAgentIDfromSessionID(entry.txID.sessionID),
-      tx: entry.txID,
-      at: new Date(entry.madeAt),
-      value: entry.op === "del" ? undefined : entry.value,
-    };
+    return operationToEditEntry(entry);
   }
 
   /** @category 5. Edit history */
@@ -232,10 +323,13 @@ export class RawCoMapView<
       }
     | undefined {
     const ops = this.timeFilteredOps(key);
-    if (!ops || ops.length === 0) {
+    const lastEntry = ops?.[ops.length - 1];
+
+    if (!lastEntry) {
       return undefined;
     }
-    return this.nthEditAt(key, ops.length - 1);
+
+    return operationToEditEntry(lastEntry);
   }
 
   /** @category 5. Edit history */
@@ -245,8 +339,8 @@ export class RawCoMapView<
       return;
     }
 
-    for (let i = 0; i < ops.length; i++) {
-      yield this.nthEditAt(key, i)!;
+    for (const entry of ops) {
+      yield operationToEditEntry(entry);
     }
   }
 
@@ -292,9 +386,7 @@ export class RawCoMap<
       privacy,
     );
 
-    const after = new RawCoMap(this.core) as this;
-
-    this.ops = after.ops;
+    this.revalidateTransactions();
   }
 
   /** Delete the given key (setting it to undefined).
@@ -319,8 +411,18 @@ export class RawCoMap<
       privacy,
     );
 
-    const after = new RawCoMap(this.core) as this;
-
-    this.ops = after.ops;
+    this.revalidateTransactions();
   }
 }
+
+export function operationToEditEntry<
+  K extends string,
+  V extends JsonValue | undefined,
+>(op: MapOp<K, V>) {
+  return {
+    by: accountOrAgentIDfromSessionID(op.txID.sessionID),
+    tx: op.txID,
+    at: new Date(op.madeAt),
+    value: op.change.op === "del" ? undefined : op.change.value,
+  };
+}

package/src/permissions.ts

@@ -59,46 +59,47 @@ export function determineValidTransactions(
       throw new Error("Group must be a map");
     }
 
-    return [...coValue.sessionLogs.entries()].flatMap(
-      ([sessionID, sessionLog]) => {
-        const transactor = accountOrAgentIDfromSessionID(sessionID);
-
-        return sessionLog.transactions
-          .filter((tx) => {
-            const groupAtTime = groupContent.atTime(tx.madeAt);
-            const effectiveTransactor = agentInAccountOrMemberInGroup(
-              transactor,
-              groupAtTime,
-            );
-
-            if (!effectiveTransactor) {
-              return false;
-            }
-
-            const transactorRoleAtTxTime =
-              groupAtTime.roleOfInternal(effectiveTransactor)?.role ||
-              groupAtTime.roleOfInternal(EVERYONE)?.role;
-
-            return (
-              transactorRoleAtTxTime === "admin" ||
-              transactorRoleAtTxTime === "writer"
-            );
-          })
-          .map((tx, txIndex) => ({
-            txID: { sessionID: sessionID, txIndex },
-            tx,
-          }));
-      },
-    );
+    const validTransactions: ValidTransactionsResult[] = [];
+
+    for (const [sessionID, sessionLog] of coValue.sessionLogs.entries()) {
+      const transactor = accountOrAgentIDfromSessionID(sessionID);
+
+      sessionLog.transactions.forEach((tx, txIndex) => {
+        const groupAtTime = groupContent.atTime(tx.madeAt);
+        const effectiveTransactor = agentInAccountOrMemberInGroup(
+          transactor,
+          groupAtTime,
+        );
+
+        if (!effectiveTransactor) {
+          return;
+        }
+
+        const transactorRoleAtTxTime =
+          groupAtTime.roleOfInternal(effectiveTransactor)?.role ||
+          groupAtTime.roleOfInternal(EVERYONE)?.role;
+
+        if (
+          transactorRoleAtTxTime !== "admin" &&
+          transactorRoleAtTxTime !== "writer"
+        ) {
+          return;
+        }
+
+        validTransactions.push({ txID: { sessionID, txIndex }, tx });
+      });
+    }
+
+    return validTransactions;
   } else if (coValue.header.ruleset.type === "unsafeAllowAll") {
-    return [...coValue.sessionLogs.entries()].flatMap(
-      ([sessionID, sessionLog]) => {
-        return sessionLog.transactions.map((tx, txIndex) => ({
-          txID: { sessionID: sessionID, txIndex },
-          tx,
-        }));
-      },
-    );
+    const validTransactions: ValidTransactionsResult[] = [];
+
+    for (const [sessionID, sessionLog] of coValue.sessionLogs.entries()) {
+      sessionLog.transactions.forEach((tx, txIndex) => {
+        validTransactions.push({ txID: { sessionID, txIndex }, tx });
+      });
+    }
+    return validTransactions;
   } else {
     throw new Error(
       "Unknown ruleset type " +

package/src/tests/coMap.test.ts

@@ -1,5 +1,6 @@
 import { expect, test } from "vitest";
 import { expectMap } from "../coValue.js";
+import { operationToEditEntry } from "../coValues/coMap.js";
 import { WasmCrypto } from "../crypto/WasmCrypto.js";
 import { LocalNode } from "../localNode.js";
 import { accountOrAgentIDfromSessionID } from "../typeUtils/accountOrAgentIDfromSessionID.js";
@@ -82,6 +83,29 @@ test("Can get CoMap entry values at different points in time", () => {
   expect(content.atTime(beforeA).get("hello")).toEqual(undefined);
   expect(content.atTime(beforeB).get("hello")).toEqual("A");
   expect(content.atTime(beforeC).get("hello")).toEqual("B");
+
+  const ops = content.timeFilteredOps("hello");
+
+  expect(content.atTime(beforeC).lastEditAt("hello")).toEqual(
+    operationToEditEntry(ops![1]!),
+  );
+  expect(content.atTime(beforeC).nthEditAt("hello", 0)).toEqual(
+    operationToEditEntry(ops![0]!),
+  );
+  expect(content.atTime(beforeC).nthEditAt("hello", 2)).toEqual(undefined);
+
+  expect([...content.atTime(beforeC).editsAt("hello")]).toEqual([
+    operationToEditEntry(ops![0]!),
+    operationToEditEntry(ops![1]!),
+  ]);
+
+  expect(content.atTime(beforeB).asObject()).toEqual({
+    hello: "A",
+  });
+
+  expect(content.atTime(beforeC).asObject()).toEqual({
+    hello: "B",
+  });
 });
 
 test("Can get all historic values of key in CoMap", () => {