cojson 0.18.4 → 0.18.6

package/src/coValues/coList.ts

@@ -1,11 +1,7 @@
 import { CoID, RawCoValue } from "../coValue.js";
-import {
-  AvailableCoValueCore,
-  CoValueCore,
-} from "../coValueCore/coValueCore.js";
+import { AvailableCoValueCore } from "../coValueCore/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 { isCoValue } from "../typeUtils/isCoValue.js";
 import { RawAccountID } from "./account.js";
@@ -39,12 +35,14 @@ type InsertionEntry<T extends JsonValue> = {
   madeAt: number;
   predecessors: OpID[];
   successors: OpID[];
-} & InsertionOpPayload<T>;
+  change: InsertionOpPayload<T>;
+};
 
 type DeletionEntry = {
   madeAt: number;
   deletionID: OpID;
-} & DeletionOpPayload;
+  change: DeletionOpPayload;
+};
 
 export class RawCoList<
   Item extends JsonValue = JsonValue,
@@ -109,6 +107,83 @@ export class RawCoList<
     this.processNewTransactions();
   }
 
+  private getInsertionsEntry(opID: OpID) {
+    const index = getSessionIndex(opID);
+
+    const sessionEntry = this.insertions[index];
+    if (!sessionEntry) {
+      return undefined;
+    }
+
+    const txEntry = sessionEntry[opID.txIndex];
+    if (!txEntry) {
+      return undefined;
+    }
+
+    return txEntry[opID.changeIdx];
+  }
+
+  private createInsertionsEntry(opID: OpID, value: InsertionEntry<Item>) {
+    const index = getSessionIndex(opID);
+
+    let sessionEntry = this.insertions[index];
+    if (!sessionEntry) {
+      sessionEntry = {};
+      this.insertions[index] = sessionEntry;
+    }
+
+    let txEntry = sessionEntry[opID.txIndex];
+    if (!txEntry) {
+      txEntry = {};
+      sessionEntry[opID.txIndex] = txEntry;
+    }
+
+    txEntry[opID.changeIdx] = value;
+  }
+
+  private isDeleted(opID: OpID) {
+    const index = getSessionIndex(opID);
+
+    const sessionEntry = this.deletionsByInsertion[index];
+
+    if (!sessionEntry) {
+      return false;
+    }
+
+    const txEntry = sessionEntry[opID.txIndex];
+
+    if (!txEntry) {
+      return false;
+    }
+
+    return Boolean(txEntry[opID.changeIdx]?.length);
+  }
+
+  private pushDeletionsByInsertionEntry(opID: OpID, value: DeletionEntry) {
+    const index = getSessionIndex(opID);
+
+    let sessionEntry = this.deletionsByInsertion[index];
+    if (!sessionEntry) {
+      sessionEntry = {};
+      this.deletionsByInsertion[index] = sessionEntry;
+    }
+
+    let txEntry = sessionEntry[opID.txIndex];
+    if (!txEntry) {
+      txEntry = {};
+      sessionEntry[opID.txIndex] = txEntry;
+    }
+
+    let list = txEntry[opID.changeIdx];
+
+    if (!list) {
+      list = [];
+      txEntry[opID.changeIdx] = list;
+    }
+
+    list.push(value);
+  }
+
   processNewTransactions() {
     const transactions = this.core.getValidSortedTransactions({
       ignorePrivateTransactions: false,
@@ -133,87 +208,51 @@ export class RawCoList<
       for (const [changeIdx, changeUntyped] of changes.entries()) {
         const change = changeUntyped as ListOpPayload<Item>;
 
+        const opID = {
+          sessionID: txID.sessionID,
+          txIndex: txID.txIndex,
+          branch: txID.branch,
+          changeIdx,
+        };
+
         if (change.op === "pre" || change.op === "app") {
-          let sessionEntry = this.insertions[txID.sessionID];
-          if (!sessionEntry) {
-            sessionEntry = {};
-            this.insertions[txID.sessionID] = sessionEntry;
-          }
-          let txEntry = sessionEntry[txID.txIndex];
-          if (!txEntry) {
-            txEntry = {};
-            sessionEntry[txID.txIndex] = txEntry;
-          }
-          txEntry[changeIdx] = {
+          this.createInsertionsEntry(opID, {
             madeAt,
             predecessors: [],
             successors: [],
-            ...change,
-          };
+            change,
+          });
+
           if (change.op === "pre") {
             if (change.before === "end") {
-              this.beforeEnd.push({
-                ...txID,
-                changeIdx,
-              });
+              this.beforeEnd.push(opID);
             } else {
-              const beforeEntry =
-                this.insertions[change.before.sessionID]?.[
-                  change.before.txIndex
-                ]?.[change.before.changeIdx];
+              const beforeEntry = this.getInsertionsEntry(change.before);
+
               if (!beforeEntry) {
                 continue;
               }
-              beforeEntry.predecessors.splice(0, 0, {
-                ...txID,
-                changeIdx,
-              });
+
+              beforeEntry.predecessors.push(opID);
             }
           } else {
             if (change.after === "start") {
-              this.afterStart.push({
-                ...txID,
-                changeIdx,
-              });
+              this.afterStart.push(opID);
             } else {
-              const afterEntry =
-                this.insertions[change.after.sessionID]?.[
-                  change.after.txIndex
-                ]?.[change.after.changeIdx];
+              const afterEntry = this.getInsertionsEntry(change.after);
+
               if (!afterEntry) {
                 continue;
               }
-              afterEntry.successors.push({
-                ...txID,
-                changeIdx,
-              });
+
+              afterEntry.successors.push(opID);
             }
           }
         } else if (change.op === "del") {
-          let sessionEntry =
-            this.deletionsByInsertion[change.insertion.sessionID];
-          if (!sessionEntry) {
-            sessionEntry = {};
-            this.deletionsByInsertion[change.insertion.sessionID] =
-              sessionEntry;
-          }
-          let txEntry = sessionEntry[change.insertion.txIndex];
-          if (!txEntry) {
-            txEntry = {};
-            sessionEntry[change.insertion.txIndex] = txEntry;
-          }
-          let changeEntry = txEntry[change.insertion.changeIdx];
-          if (!changeEntry) {
-            changeEntry = [];
-            txEntry[change.insertion.changeIdx] = changeEntry;
-          }
-          changeEntry.push({
+          this.pushDeletionsByInsertionEntry(change.insertion, {
             madeAt,
-            deletionID: {
-              ...txID,
-              changeIdx,
-            },
-            ...change,
+            deletionID: opID,
+            change,
           });
         } else {
           throw new Error(
@@ -324,10 +363,7 @@ export class RawCoList<
     while (todo.length > 0) {
       const currentOpID = todo[todo.length - 1]!;
 
-      const entry =
-        this.insertions[currentOpID.sessionID]?.[currentOpID.txIndex]?.[
-          currentOpID.changeIdx
-        ];
+      const entry = this.getInsertionsEntry(currentOpID);
 
       if (!entry) {
         throw new Error("Missing op " + currentOpID);
@@ -338,22 +374,19 @@ export class RawCoList<
 
       // We navigate the predecessors before processing the current opID in the list
       if (shouldTraversePredecessors) {
-        for (let i = entry.predecessors.length - 1; i >= 0; i--) {
-          todo.push(entry.predecessors[i]!);
+        for (const predecessor of entry.predecessors) {
+          todo.push(predecessor);
         }
         predecessorsVisited.add(currentOpID);
       } else {
         // Remove the current opID from the todo stack to consider it processed.
         todo.pop();
 
-        const deleted =
-          (this.deletionsByInsertion[currentOpID.sessionID]?.[
-            currentOpID.txIndex
-          ]?.[currentOpID.changeIdx]?.length || 0) > 0;
+        const deleted = this.isDeleted(currentOpID);
 
         if (!deleted) {
           arr.push({
-            value: entry.value,
+            value: entry.change.value,
             madeAt: entry.madeAt,
             opID: currentOpID,
           });
@@ -629,3 +662,10 @@ export class RawCoList<
     this._cachedEntries = undefined;
   }
 }
+
+function getSessionIndex(txID: TransactionID): SessionID {
+  if (txID.branch) {
+    return `${txID.sessionID}_branch_${txID.branch}`;
+  }
+  return txID.sessionID;
+}

package/src/exports.ts

@@ -1,6 +1,10 @@
 import { base64URLtoBytes, bytesToBase64url } from "./base64url.js";
 import { type RawCoValue } from "./coValue.js";
-import { CoValueCore, idforHeader } from "./coValueCore/coValueCore.js";
+import {
+  CoValueCore,
+  idforHeader,
+  type AvailableCoValueCore,
+} from "./coValueCore/coValueCore.js";
 import { CoValueUniqueness } from "./coValueCore/verifiedState.js";
 import {
   ControlledAccount,
@@ -171,6 +175,7 @@ export type {
   BinaryStreamStart,
   OpID,
   AccountRole,
+  AvailableCoValueCore,
 };
 
 export * from "./storage/index.js";

package/src/ids.ts

@@ -23,6 +23,7 @@ export function rawCoIDfromBytes(bytes: Uint8Array): RawCoID {
 export type TransactionID = {
   sessionID: SessionID;
   txIndex: number;
+  branch?: RawCoID;
 };
 
 export type AgentID = `sealer_z${string}/signer_z${string}`;

package/src/storage/storageAsync.ts

@@ -110,10 +110,14 @@ export class StorageApiAsync implements StorageAPI {
 
       let idx = 0;
 
-      signatures.push({
-        idx: sessionRow.lastIdx,
-        signature: sessionRow.lastSignature,
-      });
+      const lastSignature = signatures[signatures.length - 1];
+
+      if (lastSignature?.signature !== sessionRow.lastSignature) {
+        signatures.push({
+          idx: sessionRow.lastIdx,
+          signature: sessionRow.lastSignature,
+        });
+      }
 
       for (const signature of signatures) {
         const newTxsInSession = await this.dbClient.getNewTransactionInSession(

package/src/storage/storageSync.ts

@@ -113,10 +113,14 @@ export class StorageApiSync implements StorageAPI {
 
       let idx = 0;
 
-      signatures.push({
-        idx: sessionRow.lastIdx,
-        signature: sessionRow.lastSignature,
-      });
+      const lastSignature = signatures[signatures.length - 1];
+
+      if (lastSignature?.signature !== sessionRow.lastSignature) {
+        signatures.push({
+          idx: sessionRow.lastIdx,
+          signature: sessionRow.lastSignature,
+        });
+      }
 
       for (const signature of signatures) {
         const newTxsInSession = this.dbClient.getNewTransactionInSession(

package/src/tests/branching.test.ts

@@ -4,7 +4,7 @@ import {
   setupTestNode,
   loadCoValueOrFail,
 } from "./testUtils.js";
-import { expectMap } from "../coValue.js";
+import { expectList, expectMap, expectPlainText } from "../coValue.js";
 
 let jazzCloud: ReturnType<typeof setupTestNode>;
 
@@ -160,6 +160,108 @@ describe("Branching Logic", () => {
       expect(originalMap.get("key1")).toBe("branchValue1");
       expect(originalMap.get("key2")).toBe("branchValue2");
     });
+
+    test("should work with co.list", () => {
+      const node = createTestNode();
+      const group = node.createGroup();
+      const list = group.createList();
+
+      // Create a shopping list with grocery items
+      list.appendItems(["bread", "milk", "eggs"]);
+
+      // Remove milk from the list
+      list.delete(list.asArray().indexOf("milk"));
+
+      const branch = expectList(
+        list.core.createBranch("feature-branch", group.id).getCurrentContent(),
+      );
+
+      // Add more items to the branch
+      branch.appendItems(["cheese", "yogurt", "bananas"]);
+
+      // Remove yogurt from the branch
+      branch.delete(branch.asArray().indexOf("yogurt"));
+
+      const result = expectList(branch.core.mergeBranch().getCurrentContent());
+
+      expect(result.toJSON()).toEqual(["bread", "eggs", "cheese", "bananas"]);
+    });
+
+    test("should work with co.list when branching from different session", async () => {
+      const client = setupTestNode({
+        connected: true,
+      });
+      const group = client.node.createGroup();
+      const list = group.createList();
+
+      // Create a grocery list with initial items
+      list.appendItems(["bread", "milk"]);
+
+      const branch1 = expectList(
+        list.core.createBranch("feature-branch", group.id).getCurrentContent(),
+      );
+
+      // Add new items to first branch
+      branch1.appendItems(["cheese"]);
+
+      const branch2 = expectList(
+        list.core
+          .createBranch("feature-branch-2", group.id)
+          .getCurrentContent(),
+      );
+
+      // Add different items to second branch
+      branch2.appendItems(["apples", "oranges", "carrots"]);
+
+      const anotherSession = client.spawnNewSession();
+
+      const loadedBranch2 = await loadCoValueOrFail(
+        anotherSession.node,
+        branch2.id,
+      );
+
+      // Add more items and remove some existing ones
+      loadedBranch2.appendItems(["tomatoes", "lettuce", "cucumber"]);
+      loadedBranch2.delete(loadedBranch2.asArray().indexOf("lettuce"));
+      loadedBranch2.delete(loadedBranch2.asArray().indexOf("milk"));
+
+      loadedBranch2.core.mergeBranch();
+
+      await loadedBranch2.core.waitForSync();
+
+      branch1.core.mergeBranch();
+
+      expect(list.toJSON()).toEqual([
+        "bread",
+        "cheese",
+        "apples",
+        "oranges",
+        "carrots",
+        "tomatoes",
+        "cucumber",
+      ]);
+    });
+
+    test("should work with co.plainText when branching from different session", async () => {
+      const node = createTestNode();
+      const group = node.createGroup();
+      const plainText = group.createPlainText();
+
+      plainText.insertAfter(0, "hello");
+
+      const branch = expectPlainText(
+        plainText.core
+          .createBranch("feature-branch", group.id)
+          .getCurrentContent(),
+      );
+
+      // Add more items to the branch
+      branch.insertAfter("hello".length, "world");
+
+      branch.core.mergeBranch();
+
+      expect(plainText.toString()).toEqual("helloworld");
+    });
   });
 
   describe("Branch Loading and Checkout", () => {