cojson 0.19.2 → 0.19.4

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({