cojson 0.8.38 → 0.8.41

package/src/coValues/coMap.ts

@@ -1,7 +1,8 @@
 import { CoID, RawCoValue } from "../coValue.js";
-import { CoValueCore, DecryptedTransaction } from "../coValueCore.js";
+import { CoValueCore } from "../coValueCore.js";
 import { AgentID, TransactionID } from "../ids.js";
 import { JsonObject, JsonValue } from "../jsonValue.js";
+import { CoValueKnownState } from "../sync.js";
 import { accountOrAgentIDfromSessionID } from "../typeUtils/accountOrAgentIDfromSessionID.js";
 import { isCoValue } from "../typeUtils/isCoValue.js";
 import { RawAccountID } from "./account.js";
@@ -46,14 +47,14 @@ export class RawCoMapView<
   /** @internal */
   latestTxMadeAt: number;
   /** @internal */
-  cachedOps?: {
+  ops: {
     [Key in keyof Shape & string]?: MapOp<Key, Shape[Key]>[];
   };
   /** @internal */
-  validSortedTransactions?: DecryptedTransaction[];
+  knownTransactions: CoValueKnownState["sessions"];
 
   /** @internal */
-  options?: { ignorePrivateTransactions: boolean; atTime?: number };
+  ignorePrivateTransactions: boolean;
   /** @internal */
   atTimeFilter?: number = undefined;
   /** @category 6. Meta */
@@ -64,123 +65,81 @@ export class RawCoMapView<
     core: CoValueCore,
     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.latest = {};
     this.latestTxMadeAt = 0;
-    this.options = options;
-    this.cachedOps = options?.cachedOps;
-    this.validSortedTransactions = options?.validSortedTransactions;
+    this.ignorePrivateTransactions =
+      options?.ignorePrivateTransactions ?? false;
+    this.ops = {};
+    this.latest = {};
+    this.knownTransactions = {};
 
-    this.processLatestTransactions();
+    this.processNewTransactions();
   }
 
-  /** @internal */
-  private getValidSortedTransactions() {
-    if (this.validSortedTransactions) {
-      return this.validSortedTransactions;
+  processNewTransactions() {
+    if (this.isTimeTravelEntity()) {
+      throw new Error("Cannot process transactions on a time travel entity");
     }
 
-    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 { ops } = this;
 
-    const { latest } = this;
+    const changedEntries = new Map<
+      keyof typeof ops,
+      NonNullable<(typeof ops)[keyof typeof ops]>
+    >();
 
-    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;
-      }
+    const nextValidTransactions = this.core.getValidTransactions({
+      ignorePrivateTransactions: this.ignorePrivateTransactions,
+      knownTransactions: this.knownTransactions,
+    });
 
+    for (const { txID, changes, madeAt } of nextValidTransactions) {
       for (let changeIdx = 0; changeIdx < changes.length; changeIdx++) {
         const change = changes[changeIdx] as MapOpPayload<
           keyof Shape & string,
           Shape[keyof Shape & string]
         >;
-        const entry = latest[change.key];
-        if (!entry) {
-          latest[change.key] = {
-            txID,
-            madeAt,
-            changeIdx,
-            change,
-          };
-        } else if (madeAt >= entry.madeAt) {
-          entry.txID = txID;
-          entry.madeAt = madeAt;
-          entry.changeIdx = changeIdx;
-          entry.change = change;
-        }
-      }
-    }
-  }
-
-  revalidateTransactions() {
-    this.resetCachedValues();
-    this.processLatestTransactions();
-  }
-
-  private getOps() {
-    if (this.cachedOps) {
-      return this.cachedOps;
-    }
+        const entry = {
+          txID,
+          madeAt,
+          changeIdx,
+          change,
+        };
 
-    const ops: {
-      [Key in keyof Shape & string]?: MapOp<Key, Shape[Key]>[];
-    } = {};
+        if (madeAt > this.latestTxMadeAt) {
+          this.latestTxMadeAt = madeAt;
+        }
 
-    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 = ops[change.key];
+        const entries = ops[change.key];
         if (!entries) {
-          entries = [];
+          const entries = [entry];
           ops[change.key] = entries;
+          changedEntries.set(change.key, entries);
+        } else {
+          entries.push(entry);
+          changedEntries.set(change.key, entries);
         }
-        entries.push({
-          txID,
-          madeAt,
-          changeIdx,
-          change,
-        });
+        this.knownTransactions[txID.sessionID] = Math.max(
+          this.knownTransactions[txID.sessionID] ?? 0,
+          txID.txIndex,
+        );
       }
     }
 
-    this.cachedOps = ops;
+    for (const entries of changedEntries.values()) {
+      entries.sort(this.core.compareTransactions);
+    }
 
-    return ops;
+    for (const [key, entries] of changedEntries.entries()) {
+      this.latest[key] = entries[entries.length - 1];
+    }
+  }
+
+  isTimeTravelEntity() {
+    return Boolean(this.atTimeFilter);
   }
 
   /** @category 6. Meta */
@@ -198,14 +157,11 @@ export class RawCoMapView<
     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);
+      const clone = Object.create(this) as RawCoMapView<Shape, Meta>;
+
+      clone.atTimeFilter = time;
+      clone.latest = {};
+
       return clone as this;
     }
   }
@@ -218,12 +174,12 @@ export class RawCoMapView<
       return undefined;
     }
 
-    const atTimeFilter = this.options?.atTime;
+    const atTimeFilter = this.atTimeFilter;
 
     if (atTimeFilter) {
-      return this.getOps()[key]?.filter((op) => op.madeAt <= atTimeFilter);
+      return this.ops[key]?.filter((op) => op.madeAt <= atTimeFilter);
     } else {
-      return this.getOps()[key];
+      return this.ops[key];
     }
   }
 
@@ -232,36 +188,64 @@ export class RawCoMapView<
    *
    * @category 1. Reading */
   keys<K extends keyof Shape & string = keyof Shape & string>(): K[] {
-    return (Object.keys(this.latest) as K[]).filter((key) => {
-      const latestChange = this.latest[key];
+    return (Object.keys(this.ops) as K[]).filter((key) => {
+      const entry = this.getRaw(key);
 
-      if (!latestChange) {
+      if (entry === undefined) {
         return false;
       }
 
-      if (latestChange.change.op === "del") {
+      if (entry.change.op === "del") {
         return false;
-      } else {
-        return true;
       }
+
+      return true;
     });
   }
 
+  getRaw<K extends keyof Shape & string>(key: K) {
+    let latestChange = this.latest[key];
+
+    if (latestChange === undefined) {
+      const entries = this.ops[key];
+
+      // Time travel values are lazily computed
+      if (entries && !(key in this.latest)) {
+        const atTimeFilter = this.atTimeFilter;
+
+        if (!atTimeFilter) {
+          latestChange = entries[entries.length - 1];
+        } else {
+          latestChange = entries.findLast((op) => op.madeAt <= atTimeFilter);
+        }
+
+        this.latest[key] = latestChange;
+      }
+
+      if (latestChange === undefined) {
+        return undefined;
+      }
+    }
+
+    return latestChange;
+  }
+
   /**
    * Returns the current value for the given key.
    *
    * @category 1. Reading
    **/
   get<K extends keyof Shape & string>(key: K): Shape[K] | undefined {
-    const latestChange = this.latest[key];
-    if (!latestChange) {
+    const entry = this.getRaw(key);
+
+    if (entry === undefined) {
       return undefined;
     }
 
-    if (latestChange.change.op === "del") {
+    if (entry.change.op === "del") {
       return undefined;
     } else {
-      return latestChange.change.value as Shape[K];
+      return entry.change.value as Shape[K];
     }
   }
 
@@ -273,7 +257,7 @@ export class RawCoMapView<
       [K in keyof Shape & string]: Shape[K];
     }> = {};
 
-    for (const key of Object.keys(this.latest) as (keyof Shape & string)[]) {
+    for (const key of Object.keys(this.ops) as (keyof Shape & string)[]) {
       const value = this.get(key);
       if (value !== undefined) {
         object[key] = value;
@@ -294,9 +278,9 @@ export class RawCoMapView<
 
   /** @category 5. Edit history */
   nthEditAt<K extends keyof Shape & string>(key: K, n: number) {
-    const ops = this.getOps()[key];
+    const ops = this.ops[key];
 
-    const atTimeFilter = this.options?.atTime;
+    const atTimeFilter = this.atTimeFilter;
     const entry = ops?.[n];
 
     if (!entry) {
@@ -321,24 +305,31 @@ export class RawCoMapView<
         value?: Shape[K];
       }
     | undefined {
-    const ops = this.timeFilteredOps(key);
-    const lastEntry = ops?.[ops.length - 1];
+    const entry = this.getRaw(key);
 
-    if (!lastEntry) {
+    if (!entry) {
       return undefined;
     }
 
-    return operationToEditEntry(lastEntry);
+    return operationToEditEntry(entry);
   }
 
   /** @category 5. Edit history */
   *editsAt<K extends keyof Shape & string>(key: K) {
-    const ops = this.timeFilteredOps(key);
-    if (!ops) {
+    const entries = this.ops[key];
+
+    if (!entries) {
       return;
     }
 
-    for (const entry of ops) {
+    const atTimeFilter = this.atTimeFilter;
+
+    for (const entry of entries) {
+      // Entries are sorted by madeAt
+      if (atTimeFilter && entry.madeAt > atTimeFilter) {
+        return;
+      }
+
       yield operationToEditEntry(entry);
     }
   }
@@ -374,6 +365,10 @@ export class RawCoMap<
     value: Shape[K],
     privacy: "private" | "trusting" = "private",
   ): void {
+    if (this.isTimeTravelEntity()) {
+      throw new Error("Cannot set value on a time travel entity");
+    }
+
     this.core.makeTransaction(
       [
         {
@@ -385,7 +380,7 @@ export class RawCoMap<
       privacy,
     );
 
-    this.revalidateTransactions();
+    this.processNewTransactions();
   }
 
   /** Delete the given key (setting it to undefined).
@@ -400,6 +395,10 @@ export class RawCoMap<
     key: keyof Shape & string,
     privacy: "private" | "trusting" = "private",
   ) {
+    if (this.isTimeTravelEntity()) {
+      throw new Error("Cannot delete value on a time travel entity");
+    }
+
     this.core.makeTransaction(
       [
         {
@@ -410,7 +409,7 @@ export class RawCoMap<
       privacy,
     );
 
-    this.revalidateTransactions();
+    this.processNewTransactions();
   }
 }
 

package/src/coValues/coStream.ts

@@ -3,6 +3,7 @@ import { CoID, RawCoValue } from "../coValue.js";
 import { CoValueCore } from "../coValueCore.js";
 import { AgentID, SessionID, TransactionID } from "../ids.js";
 import { JsonObject, JsonValue } from "../jsonValue.js";
+import { CoValueKnownState } from "../sync.js";
 import { accountOrAgentIDfromSessionID } from "../typeUtils/accountOrAgentIDfromSessionID.js";
 import { isAccountID } from "../typeUtils/isAccountID.js";
 import { isCoValue } from "../typeUtils/isCoValue.js";
@@ -52,13 +53,16 @@ export class RawCoStreamView<
   items: {
     [key: SessionID]: CoStreamItem<Item>[];
   };
+  /** @internal */
+  knownTransactions: CoValueKnownState["sessions"];
   readonly _item!: Item;
 
   constructor(core: CoValueCore) {
     this.id = core.id as CoID<this>;
     this.core = core;
     this.items = {};
-    this.fillFromCoValue();
+    this.knownTransactions = {};
+    this.processNewTransactions();
   }
 
   get headerMeta(): Meta {
@@ -75,14 +79,13 @@ export class RawCoStreamView<
   }
 
   /** @internal */
-  protected fillFromCoValue() {
-    this.items = {};
+  protected processNewTransactions() {
+    const changeEntries = new Set<CoStreamItem<Item>[]>();
 
-    for (const {
-      txID,
-      madeAt,
-      changes,
-    } of this.core.getValidSortedTransactions()) {
+    for (const { txID, madeAt, changes } of this.core.getValidTransactions({
+      ignorePrivateTransactions: false,
+      knownTransactions: this.knownTransactions,
+    })) {
       for (const changeUntyped of changes) {
         const change = changeUntyped as Item;
         let entries = this.items[txID.sessionID];
@@ -91,7 +94,21 @@ export class RawCoStreamView<
           this.items[txID.sessionID] = entries;
         }
         entries.push({ value: change, madeAt, tx: txID });
+        changeEntries.add(entries);
       }
+      this.knownTransactions[txID.sessionID] = Math.max(
+        this.knownTransactions[txID.sessionID] ?? 0,
+        txID.txIndex,
+      );
+    }
+
+    for (const entries of changeEntries) {
+      entries.sort(
+        (a, b) =>
+          a.madeAt - b.madeAt ||
+          (a.tx.sessionID < b.tx.sessionID ? -1 : 1) ||
+          a.tx.txIndex - b.tx.txIndex,
+      );
     }
   }
 
@@ -255,7 +272,7 @@ export class RawCoStream<
 {
   push(item: Item, privacy: "private" | "trusting" = "private"): void {
     this.core.makeTransaction([isCoValue(item) ? item.id : item], privacy);
-    this.fillFromCoValue();
+    this.processNewTransactions();
   }
 }
 
@@ -343,7 +360,7 @@ export class RawBinaryCoStream<
   ): void {
     this.core.makeTransaction([item], privacy);
     if (updateView) {
-      this.fillFromCoValue();
+      this.processNewTransactions();
     }
   }