cojson 0.19.3 → 0.19.5

package/src/coValues/group.ts

@@ -3,6 +3,7 @@ import type { CoID } from "../coValue.js";
 import type {
   AvailableCoValueCore,
   CoValueCore,
+  DecryptedTransaction,
 } from "../coValueCore/coValueCore.js";
 import type { CoValueUniqueness } from "../coValueCore/verifiedState.js";
 import type {
@@ -161,6 +162,40 @@ function rotateReadKeyIfNeeded(group: RawGroup) {
   }
 }
 
+class TimeBasedEntry<T> {
+  changes: { madeAt: number; value: T }[] = [];
+
+  addChange(madeAt: number, value: T) {
+    const changes = this.changes;
+    const newChange = { madeAt, value };
+    // Insert the change in chronological order
+    // Find the correct position by searching backwards from the end
+    let insertIndex = changes.length;
+    while (insertIndex > 0 && changes[insertIndex - 1]!.madeAt > madeAt) {
+      insertIndex--;
+    }
+
+    // Insert at the correct position to maintain chronological order
+    if (insertIndex === changes.length) {
+      changes.push(newChange);
+    } else {
+      changes.splice(insertIndex, 0, newChange);
+    }
+  }
+
+  getLatest() {
+    return this.changes[this.changes.length - 1]?.value;
+  }
+
+  getAtTime(atTime?: number) {
+    if (atTime === undefined) {
+      return this.getLatest();
+    }
+
+    return this.changes.findLast((change) => change.madeAt <= atTime)?.value;
+  }
+}
+
 /** A `Group` is a scope for permissions of its members (`"reader" | "writer" | "admin"`), applying to objects owned by that group.
  *
  *  A `Group` object exposes methods for permission management and allows you to create new CoValues owned by that group.
@@ -189,6 +224,19 @@ export class RawGroup<
 
   _lastReadableKeyId?: KeyID;
 
+  // Not using class field initializers because they run after that the CoMap constructor
+  // calls processNewTransactions, which would reset the parentGroupsChanges map
+  private declare parentGroupsChanges: Map<
+    CoID<RawGroup>,
+    TimeBasedEntry<ParentGroupReferenceRole>
+  >;
+
+  protected resetInternalState() {
+    super.resetInternalState();
+    this.parentGroupsChanges = new Map();
+    this._lastReadableKeyId = undefined;
+  }
+
   constructor(
     core: AvailableCoValueCore,
     options?: {
@@ -200,6 +248,45 @@ export class RawGroup<
     this.migrate();
   }
 
+  // We override the handleNewTransaction hook from CoMap to build the parent group cache
+  override handleNewTransaction(transaction: DecryptedTransaction): void {
+    if (!this.parentGroupsChanges) {
+      this.parentGroupsChanges = new Map();
+    }
+
+    // Build parent group cache incrementally
+    for (const changeValue of transaction.changes) {
+      const change = changeValue as {
+        op: "set" | "del";
+        key: string;
+        value?: any;
+      };
+      if (change.op === "set" && isParentGroupReference(change.key)) {
+        this.updateParentGroupCache(
+          change.key,
+          change.value as ParentGroupReferenceRole,
+          transaction.madeAt,
+        );
+      }
+    }
+  }
+
+  private updateParentGroupCache(
+    key: string,
+    value: any,
+    timestamp: number,
+  ): void {
+    const parentGroupId = key.substring(7) as CoID<RawGroup>; // Remove 'parent_' prefix
+
+    let entry = this.parentGroupsChanges.get(parentGroupId);
+    if (!entry) {
+      entry = new TimeBasedEntry<ParentGroupReferenceRole>();
+      this.parentGroupsChanges.set(parentGroupId, entry);
+    }
+
+    entry.addChange(timestamp, value as ParentGroupReferenceRole);
+  }
+
   migrate() {
     if (!this.core.isGroup()) {
       return;
@@ -247,15 +334,13 @@ export class RawGroup<
 
     let roleInfo: Role | undefined = roleHere;
 
-    for (const key of Object.keys(this.ops)) {
-      if (!isParentGroupReference(key)) continue;
+    for (const [parentGroupId, entry] of this.parentGroupsChanges.entries()) {
+      const role = entry.getAtTime(this.atTimeFilter);
 
-      const group = this.getParentGroupFromKey(key, this.atTimeFilter);
+      if (!role || role === "revoked") continue;
 
-      if (!group) continue;
-
-      const role = this.get(key) ?? "extend";
-      const parentRole = group.roleOfInternal(accountID);
+      const parentGroup = this.getParentGroup(parentGroupId, this.atTimeFilter);
+      const parentRole = parentGroup.roleOfInternal(accountID);
 
       if (!isInheritableRole(parentRole)) {
         continue;
@@ -277,13 +362,9 @@ export class RawGroup<
     return roleInfo;
   }
 
-  getParentGroupFromKey(key: ParentGroupReference, atTime?: number) {
-    if (this.get(key) === "revoked") {
-      return null;
-    }
-
+  getParentGroup(id: CoID<RawGroup>, atTime?: number) {
     const parent = this.core.node.expectCoValueLoaded(
-      getParentGroupId(key),
+      id,
       "Expected parent group to be loaded",
     );
 
@@ -296,21 +377,15 @@ export class RawGroup<
     }
   }
 
-  getParentGroups(atTime?: number) {
+  getParentGroups() {
     const groups: RawGroup[] = [];
 
-    for (const key of Object.keys(this.ops)) {
-      if (!isParentGroupReference(key)) continue;
+    for (const [parentGroupId, entry] of this.parentGroupsChanges.entries()) {
+      const role = entry.getAtTime(this.atTimeFilter);
 
-      const group = this.getParentGroupFromKey(key, atTime);
+      if (!role || role === "revoked") continue;
 
-      if (group) {
-        if (atTime) {
-          groups.push(group.atTime(atTime));
-        } else {
-          groups.push(group);
-        }
-      }
+      groups.push(this.getParentGroup(parentGroupId, this.atTimeFilter));
     }
 
     return groups;

package/src/storage/sqlite/client.ts

@@ -8,6 +8,7 @@ import { logger } from "../../logger.js";
 import type { NewContentMessage } from "../../sync.js";
 import type {
   DBClientInterfaceSync,
+  DBTransactionInterfaceSync,
   SessionRow,
   SignatureAfterRow,
   StoredCoValueRow,
@@ -31,7 +32,9 @@ export function getErrorMessage(error: unknown) {
   return error instanceof Error ? error.message : "Unknown error";
 }
 
-export class SQLiteClient implements DBClientInterfaceSync {
+export class SQLiteClient
+  implements DBClientInterfaceSync, DBTransactionInterfaceSync
+{
   private readonly db: SQLiteDatabaseDriver;
 
   constructor(db: SQLiteDatabaseDriver) {
@@ -187,8 +190,8 @@ export class SQLiteClient implements DBClientInterfaceSync {
     );
   }
 
-  transaction(operationsCallback: () => unknown) {
-    this.db.transaction(operationsCallback);
+  transaction(operationsCallback: (tx: DBTransactionInterfaceSync) => unknown) {
+    this.db.transaction(() => operationsCallback(this));
     return undefined;
   }
 }

package/src/storage/sqliteAsync/client.ts

@@ -8,6 +8,7 @@ import { logger } from "../../logger.js";
 import type { NewContentMessage } from "../../sync.js";
 import type {
   DBClientInterfaceAsync,
+  DBTransactionInterfaceAsync,
   SessionRow,
   SignatureAfterRow,
   StoredCoValueRow,
@@ -31,7 +32,9 @@ export function getErrorMessage(error: unknown) {
   return error instanceof Error ? error.message : "Unknown error";
 }
 
-export class SQLiteClientAsync implements DBClientInterfaceAsync {
+export class SQLiteClientAsync
+  implements DBClientInterfaceAsync, DBTransactionInterfaceAsync
+{
   private readonly db: SQLiteDatabaseDriverAsync;
 
   constructor(db: SQLiteDatabaseDriverAsync) {
@@ -194,7 +197,9 @@ export class SQLiteClientAsync implements DBClientInterfaceAsync {
     );
   }
 
-  async transaction(operationsCallback: () => unknown) {
-    return this.db.transaction(operationsCallback);
+  async transaction(
+    operationsCallback: (tx: DBTransactionInterfaceAsync) => Promise<unknown>,
+  ) {
+    return this.db.transaction(() => operationsCallback(this));
   }
 }

package/src/storage/storageAsync.ts

@@ -25,6 +25,7 @@ import {
 import type {
   CorrectionCallback,
   DBClientInterfaceAsync,
+  DBTransactionInterfaceAsync,
   SignatureAfterRow,
   StoredCoValueRow,
   StoredSessionRow,
@@ -280,8 +281,8 @@ export class StorageApiAsync implements StorageAPI {
     let invalidAssumptions = false;
 
     for (const sessionID of Object.keys(msg.new) as SessionID[]) {
-      await this.dbClient.transaction(async () => {
-        const sessionRow = await this.dbClient.getSingleCoValueSession(
+      await this.dbClient.transaction(async (tx) => {
+        const sessionRow = await tx.getSingleCoValueSession(
           storedCoValueRowID,
           sessionID,
         );
@@ -301,6 +302,7 @@ export class StorageApiAsync implements StorageAPI {
           invalidAssumptions = true;
         } else {
           const newLastIdx = await this.putNewTxs(
+            tx,
             msg,
             sessionID,
             sessionRow,
@@ -321,6 +323,7 @@ export class StorageApiAsync implements StorageAPI {
   }
 
   private async putNewTxs(
+    tx: DBTransactionInterfaceAsync,
     msg: NewContentMessage,
     sessionID: SessionID,
     sessionRow: StoredSessionRow | undefined,
@@ -363,13 +366,13 @@ export class StorageApiAsync implements StorageAPI {
       bytesSinceLastSignature,
     };
 
-    const sessionRowID: number = await this.dbClient.addSessionUpdate({
+    const sessionRowID: number = await tx.addSessionUpdate({
       sessionUpdate,
       sessionRow,
     });
 
     if (shouldWriteSignature) {
-      await this.dbClient.addSignatureAfter({
+      await tx.addSignatureAfter({
         sessionRowID,
         idx: newLastIdx - 1,
         signature: msg.new[sessionID].lastSignature,
@@ -378,7 +381,7 @@ export class StorageApiAsync implements StorageAPI {
 
     await Promise.all(
       actuallyNewTransactions.map((newTransaction, i) =>
-        this.dbClient.addTransaction(sessionRowID, nextIdx + i, newTransaction),
+        tx.addTransaction(sessionRowID, nextIdx + i, newTransaction),
       ),
     );
 

package/src/storage/storageSync.ts

@@ -25,6 +25,7 @@ import {
 import type {
   CorrectionCallback,
   DBClientInterfaceSync,
+  DBTransactionInterfaceSync,
   SignatureAfterRow,
   StoredCoValueRow,
   StoredSessionRow,
@@ -257,8 +258,8 @@ export class StorageApiSync implements StorageAPI {
     let invalidAssumptions = false;
 
     for (const sessionID of Object.keys(msg.new) as SessionID[]) {
-      this.dbClient.transaction(() => {
-        const sessionRow = this.dbClient.getSingleCoValueSession(
+      this.dbClient.transaction((tx) => {
+        const sessionRow = tx.getSingleCoValueSession(
           storedCoValueRowID,
           sessionID,
         );
@@ -275,6 +276,7 @@ export class StorageApiSync implements StorageAPI {
           invalidAssumptions = true;
         } else {
           const newLastIdx = this.putNewTxs(
+            tx,
             msg,
             sessionID,
             sessionRow,
@@ -295,6 +297,7 @@ export class StorageApiSync implements StorageAPI {
   }
 
   private putNewTxs(
+    tx: DBTransactionInterfaceSync,
     msg: NewContentMessage,
     sessionID: SessionID,
     sessionRow: StoredSessionRow | undefined,
@@ -338,13 +341,13 @@ export class StorageApiSync implements StorageAPI {
       bytesSinceLastSignature,
     };
 
-    const sessionRowID: number = this.dbClient.addSessionUpdate({
+    const sessionRowID: number = tx.addSessionUpdate({
       sessionUpdate,
       sessionRow,
     });
 
     if (shouldWriteSignature) {
-      this.dbClient.addSignatureAfter({
+      tx.addSignatureAfter({
         sessionRowID,
         idx: newLastIdx - 1,
         signature: msg.new[sessionID].lastSignature,
@@ -352,7 +355,7 @@ export class StorageApiSync implements StorageAPI {
     }
 
     actuallyNewTransactions.map((newTransaction, i) =>
-      this.dbClient.addTransaction(sessionRowID, nextIdx + i, newTransaction),
+      tx.addTransaction(sessionRowID, nextIdx + i, newTransaction),
     );
 
     return newLastIdx;

package/src/storage/types.ts

@@ -61,34 +61,12 @@ export type SignatureAfterRow = {
   signature: Signature;
 };
 
-export interface DBClientInterfaceAsync {
-  getCoValue(
-    coValueId: string,
-  ): Promise<StoredCoValueRow | undefined> | undefined;
-
-  upsertCoValue(
-    id: string,
-    header?: CoValueHeader,
-  ): Promise<number | undefined>;
-
-  getCoValueSessions(coValueRowId: number): Promise<StoredSessionRow[]>;
-
+export interface DBTransactionInterfaceAsync {
   getSingleCoValueSession(
     coValueRowId: number,
     sessionID: SessionID,
   ): Promise<StoredSessionRow | undefined>;
 
-  getNewTransactionInSession(
-    sessionRowId: number,
-    fromIdx: number,
-    toIdx: number,
-  ): Promise<TransactionRow[]>;
-
-  getSignatures(
-    sessionRowId: number,
-    firstNewTxIdx: number,
-  ): Promise<SignatureAfterRow[]>;
-
   addSessionUpdate({
     sessionUpdate,
     sessionRow,
@@ -112,32 +90,41 @@ export interface DBClientInterfaceAsync {
     idx: number;
     signature: Signature;
   }): Promise<unknown>;
-
-  transaction(callback: () => unknown): Promise<unknown>;
 }
 
-export interface DBClientInterfaceSync {
-  getCoValue(coValueId: string): StoredCoValueRow | undefined;
-
-  upsertCoValue(id: string, header?: CoValueHeader): number | undefined;
+export interface DBClientInterfaceAsync {
+  getCoValue(
+    coValueId: string,
+  ): Promise<StoredCoValueRow | undefined> | undefined;
 
-  getCoValueSessions(coValueRowId: number): StoredSessionRow[];
+  upsertCoValue(
+    id: string,
+    header?: CoValueHeader,
+  ): Promise<number | undefined>;
 
-  getSingleCoValueSession(
-    coValueRowId: number,
-    sessionID: SessionID,
-  ): StoredSessionRow | undefined;
+  getCoValueSessions(coValueRowId: number): Promise<StoredSessionRow[]>;
 
   getNewTransactionInSession(
     sessionRowId: number,
     fromIdx: number,
     toIdx: number,
-  ): TransactionRow[];
+  ): Promise<TransactionRow[]>;
 
   getSignatures(
     sessionRowId: number,
     firstNewTxIdx: number,
-  ): Pick<SignatureAfterRow, "idx" | "signature">[];
+  ): Promise<SignatureAfterRow[]>;
+
+  transaction(
+    callback: (tx: DBTransactionInterfaceAsync) => Promise<unknown>,
+  ): Promise<unknown>;
+}
+
+export interface DBTransactionInterfaceSync {
+  getSingleCoValueSession(
+    coValueRowId: number,
+    sessionID: SessionID,
+  ): StoredSessionRow | undefined;
 
   addSessionUpdate({
     sessionUpdate,
@@ -162,6 +149,25 @@ export interface DBClientInterfaceSync {
     idx: number;
     signature: Signature;
   }): number | undefined | unknown;
+}
+
+export interface DBClientInterfaceSync {
+  getCoValue(coValueId: string): StoredCoValueRow | undefined;
+
+  upsertCoValue(id: string, header?: CoValueHeader): number | undefined;
+
+  getCoValueSessions(coValueRowId: number): StoredSessionRow[];
+
+  getNewTransactionInSession(
+    sessionRowId: number,
+    fromIdx: number,
+    toIdx: number,
+  ): TransactionRow[];
+
+  getSignatures(
+    sessionRowId: number,
+    firstNewTxIdx: number,
+  ): Pick<SignatureAfterRow, "idx" | "signature">[];
 
-  transaction(callback: () => unknown): unknown;
+  transaction(callback: (tx: DBTransactionInterfaceSync) => unknown): unknown;
 }

package/src/tests/coList.test.ts

@@ -1,12 +1,10 @@
 import { beforeEach, describe, expect, test } from "vitest";
 import { expectList } from "../coValue.js";
 import { WasmCrypto } from "../crypto/WasmCrypto.js";
-import { LocalNode } from "../localNode.js";
-import { expectGroup } from "../typeUtils/expectGroup.js";
 import {
+  hotSleep,
   loadCoValueOrFail,
   nodeWithRandomAgentAndSessionID,
-  randomAgentAndSessionID,
   setupTestNode,
   waitFor,
 } from "./testUtils.js";
@@ -429,6 +427,41 @@ test("Should ignore unknown meta transactions", () => {
   expect(content.toJSON()).toEqual(["first"]);
 });
 
+describe("CoList Time Travel", () => {
+  test("atTime should return a time travel entity", () => {
+    const node = nodeWithRandomAgentAndSessionID();
+    const coValue = node.createCoValue({
+      type: "colist",
+      ruleset: { type: "unsafeAllowAll" },
+      meta: null,
+      ...Crypto.createdNowUnique(),
+    });
+
+    const content = expectList(coValue.getCurrentContent());
+
+    const beforeA = hotSleep(10);
+    content.append("first", 0, "trusting");
+
+    const beforeB = hotSleep(10);
+    content.append("second", 0, "trusting");
+
+    const beforeC = hotSleep(10);
+    content.delete(0, "trusting");
+
+    const beforeD = hotSleep(10);
+    content.prepend("third", 0, "trusting");
+
+    expect(content.toJSON()).toEqual(["third", "second"]);
+
+    expect(content.atTime(0).toJSON()).toEqual([]);
+    expect(content.atTime(beforeA).toJSON()).toEqual([]);
+    expect(content.atTime(beforeB).toJSON()).toEqual(["first"]);
+    expect(content.atTime(beforeC).toJSON()).toEqual(["first", "second"]);
+    expect(content.atTime(beforeD).toJSON()).toEqual(["second"]);
+    expect(content.atTime(Date.now()).toJSON()).toEqual(["third", "second"]);
+  });
+});
+
 describe("CoList Branching", () => {
   test("should handle concurrent appends from multiple branches", async () => {
     const client1 = setupTestNode({