cojson 0.19.3 → 0.19.4

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