cojson 0.20.2 → 0.20.4

package/src/tests/group.parentGroupCache.test.ts

@@ -140,7 +140,7 @@ describe("Parent Group Cache", () => {
             value: "revoked",
           },
         ],
-        "private",
+        "trusting",
         undefined,
         t2,
       );
@@ -153,7 +153,7 @@ describe("Parent Group Cache", () => {
             value: "extend",
           },
         ],
-        "private",
+        "trusting",
         undefined,
         t1,
       );

package/src/tests/permissions.test.ts

@@ -1,4 +1,4 @@
-import { expect, test, vi } from "vitest";
+import { beforeEach, describe, expect, test, vi } from "vitest";
 import { expectMap } from "../coValue.js";
 import { ControlledAgent } from "../coValues/account.js";
 import { WasmCrypto } from "../crypto/WasmCrypto.js";
@@ -13,6 +13,8 @@ import {
   loadCoValueOrFail,
   newGroup,
   newGroupHighLevel,
+  setupTestAccount,
+  setupTestNode,
   waitFor,
 } from "./testUtils.js";
 import { Role } from "../permissions.js";
@@ -2727,3 +2729,118 @@ test("Can revoke read permission from 'everyone'", async () => {
   // Verify the new account cannot read after revocation
   expect(childContent2.get("foo")).toEqual("bar");
 });
+
+describe("Private transactions in groups", () => {
+  beforeEach(async () => {
+    setupTestNode({ isSyncServer: true });
+  });
+
+  test("Admins can make private transactions directly in accounts", async () => {
+    const alice = await setupTestAccount();
+
+    const group = alice.node.createGroup();
+    const map = group.createMap();
+
+    // Count valid transactions before attempting private transaction
+    const validTransactionsBefore = alice.account.core.getValidTransactions();
+    const countBefore = validTransactionsBefore.length;
+
+    alice.account.set("root", map.id, "private");
+
+    const validTransactions = alice.account.core.getValidTransactions();
+    expect(validTransactions).toHaveLength(countBefore + 1);
+
+    expect(alice.account.get("root")).toEqual(map.id);
+    expect(alice.account.core.getCurrentReadKey()).not.toBeUndefined();
+  });
+
+  test("Admins cannot make private transactions directly in groups", async () => {
+    const alice = await setupTestAccount();
+
+    const group = alice.node.createGroup();
+    const map = group.createMap();
+
+    // Count valid transactions before attempting private transaction
+    const validTransactionsBefore = group.core.getValidTransactions();
+    const countBefore = validTransactionsBefore.length;
+
+    // Attempt to make a private transaction directly on the group
+    group.set("root", map.id, "private");
+
+    // Verify the transaction is marked invalid (count should not increase)
+    const validTransactions = group.core.getValidTransactions();
+    expect(validTransactions).toHaveLength(countBefore);
+
+    // Verify the change didn't take effect
+    expect(group.get("root")).toBeUndefined();
+  });
+
+  test("Writers cannot make private transactions directly in groups", async () => {
+    const alice = await setupTestAccount({ connected: true });
+    const bob = await setupTestAccount({ connected: true });
+
+    const group = alice.node.createGroup();
+    const map = group.createMap();
+
+    group.addMember(bob.account, "writer");
+
+    // Count valid transactions before attempting private transaction
+    const validTransactionsBefore = group.core.getValidTransactions();
+    const countBefore = validTransactionsBefore.length;
+
+    const groupAsBob = await loadCoValueOrFail(bob.node, group.id);
+
+    // Attempt to make a private transaction directly on the group
+    groupAsBob.set("root", map.id, "private");
+
+    // Verify the transaction is marked invalid (count should not increase)
+    const validTransactions = groupAsBob.core.getValidTransactions();
+    expect(validTransactions).toHaveLength(countBefore);
+
+    // Verify the change didn't take effect
+    expect(groupAsBob.get("root")).toBeUndefined();
+  });
+
+  test("Managers cannot make private transactions directly in groups", async () => {
+    const alice = await setupTestAccount({ connected: true });
+    const bob = await setupTestAccount({ connected: true });
+
+    const group = alice.node.createGroup();
+    const map = group.createMap();
+
+    group.addMember(bob.account, "manager");
+
+    // Count valid transactions before attempting private transaction
+    const validTransactionsBefore = group.core.getValidTransactions();
+    const countBefore = validTransactionsBefore.length;
+
+    const groupAsBob = await loadCoValueOrFail(bob.node, group.id);
+
+    // Attempt to make a private transaction directly on the group
+    groupAsBob.set("root", map.id, "private");
+
+    // Verify the transaction is marked invalid (count should not increase)
+    const validTransactions = groupAsBob.core.getValidTransactions();
+    expect(validTransactions).toHaveLength(countBefore);
+
+    // Verify the change didn't take effect
+    expect(groupAsBob.get("root")).toBeUndefined();
+  });
+
+  test("A Group with a private transaction can be loaded without issues", async () => {
+    const alice = await setupTestAccount({ connected: true });
+    const bob = await setupTestAccount({ connected: true });
+
+    const group = alice.node.createGroup();
+    const map = group.createMap();
+
+    // Attempt to make a private transaction directly on the group
+    group.set("root", map.id, "private");
+    group.addMember(bob.account, "reader");
+
+    const groupAsBob = await loadCoValueOrFail(bob.node, group.id);
+
+    expect(groupAsBob.myRole()).toBe("reader");
+    expect(groupAsBob.core.getCurrentReadKey()).not.toBeUndefined();
+  });
+});

package/src/tests/testStorage.ts

@@ -92,6 +92,14 @@ class LibSQLSqliteSyncDriver implements SQLiteDatabaseDriver {
   }
 }
 
+function deleteDb(dbPath: string) {
+  try {
+    unlinkSync(dbPath);
+  } catch (error) {
+    console.error(error);
+  }
+}
+
 export async function createAsyncStorage({
   filename,
   nodeName = "client",
@@ -101,12 +109,14 @@ export async function createAsyncStorage({
   nodeName: string;
   storageName: string;
 }) {
+  const dbPath = getDbPath(filename);
   const storage = await getSqliteStorageAsync(
-    new LibSQLSqliteAsyncDriver(getDbPath(filename)),
+    new LibSQLSqliteAsyncDriver(dbPath),
   );
 
   onTestFinished(async () => {
     await storage.close();
+    deleteDb(dbPath);
   });
 
   trackStorageMessages(storage, nodeName, storageName);
@@ -123,10 +133,16 @@ export function createSyncStorage({
   nodeName: string;
   storageName: string;
 }) {
+  const dbPath = getDbPath(filename);
   const storage = getSqliteStorage(
     new LibSQLSqliteSyncDriver(getDbPath(filename)),
   );
 
+  onTestFinished(() => {
+    storage.close();
+    deleteDb(dbPath);
+  });
+
   trackStorageMessages(storage, nodeName, storageName);
 
   return storage;
@@ -159,17 +175,7 @@ export async function getCoValueStoredSessions(
 }
 
 export function getDbPath(defaultDbPath?: string) {
-  const dbPath = defaultDbPath ?? join(tmpdir(), `test-${randomUUID()}.db`);
-
-  if (!defaultDbPath) {
-    onTestFinished(() => {
-      setTimeout(() => {
-        unlinkSync(dbPath);
-      }, 100);
-    });
-  }
-
-  return dbPath;
+  return defaultDbPath ?? join(tmpdir(), `test-${randomUUID()}.db`);
 }
 
 function trackStorageMessages(