cojson 0.13.20 → 0.13.23

package/src/coValueCore/coValueCore.ts

@@ -311,14 +311,10 @@ export class CoValueCore {
     }
   }
 
-  contentInClonedNodeWithDifferentAccount(
-    controlledAccountOrAgent: ControlledAccountOrAgent,
-  ): RawCoValue {
-    const newNode = this.node.cloneWithDifferentAccount(
-      controlledAccountOrAgent,
-    );
-
-    return newNode.expectCoValueLoaded(this.id).getCurrentContent();
+  contentInClonedNodeWithDifferentAccount(account: ControlledAccountOrAgent) {
+    return this.node
+      .loadCoValueAsDifferentAgent(this.id, account.agentSecret, account.id)
+      .getCurrentContent();
   }
 
   knownState(): CoValueKnownState {

package/src/coValues/coStream.ts

@@ -319,11 +319,7 @@ export class RawBinaryCoStreamView<
     return lastItem?.type === "end";
   }
 
-  getBinaryChunks(
-    allowUnfinished?: boolean,
-  ):
-    | (BinaryStreamInfo & { chunks: Uint8Array[]; finished: boolean })
-    | undefined {
+  getBinaryStreamInfo(): BinaryStreamInfo | undefined {
     const items = this.getSingleStream();
 
     // No active streams
@@ -336,6 +332,27 @@ export class RawBinaryCoStreamView<
       return;
     }
 
+    return {
+      mimeType: start.mimeType,
+      fileName: start.fileName,
+      totalSizeBytes: start.totalSizeBytes,
+    };
+  }
+
+  getBinaryChunks(
+    allowUnfinished?: boolean,
+  ):
+    | (BinaryStreamInfo & { chunks: Uint8Array[]; finished: boolean })
+    | undefined {
+    const items = this.getSingleStream();
+
+    // No active streams
+    if (!items) return;
+
+    const info = this.getBinaryStreamInfo();
+
+    if (!info) return;
+
     const end = items[items.length - 1];
 
     if (end?.type !== "end" && !allowUnfinished) return;
@@ -360,9 +377,7 @@ export class RawBinaryCoStreamView<
     }
 
     return {
-      mimeType: start.mimeType,
-      fileName: start.fileName,
-      totalSizeBytes: start.totalSizeBytes,
+      ...info,
       chunks,
       finished,
     };

package/src/localNode.ts

@@ -433,32 +433,44 @@ export class LocalNode {
     groupOrOwnedValueID: CoID<T>,
     inviteSecret: InviteSecret,
   ): Promise<void> {
-    const groupOrOwnedValue = await this.load(groupOrOwnedValueID);
+    const value = await this.load(groupOrOwnedValueID);
 
-    if (groupOrOwnedValue === "unavailable") {
+    if (value === "unavailable") {
       throw new Error(
         "Trying to accept invite: Group/owned value unavailable from all peers",
       );
     }
 
-    if (
-      groupOrOwnedValue.core.verified.header.ruleset.type === "ownedByGroup"
-    ) {
-      return this.acceptInvite(
-        groupOrOwnedValue.core.verified.header.ruleset.group as CoID<RawGroup>,
-        inviteSecret,
-      );
-    } else if (
-      groupOrOwnedValue.core.verified.header.ruleset.type !== "group"
-    ) {
-      throw new Error("Can only accept invites to groups");
+    const ruleset = value.core.verified.header.ruleset;
+
+    let group: RawGroup;
+
+    if (ruleset.type === "unsafeAllowAll") {
+      throw new Error("Can only accept invites to values owned by groups");
     }
 
-    const group = expectGroup(groupOrOwnedValue);
+    if (ruleset.type === "ownedByGroup") {
+      const owner = await this.load(ruleset.group as CoID<RawGroup>);
+
+      if (owner === "unavailable") {
+        throw new Error(
+          "Trying to accept invite: CoValue owner unavailable from all peers",
+        );
+      }
+
+      group = expectGroup(owner);
+    } else {
+      group = expectGroup(value);
+    }
+
+    if (group.core.verified.header.meta?.type === "account") {
+      throw new Error("Can't accept invites to values owned by accounts");
+    }
 
     const inviteAgentSecret = this.crypto.agentSecretFromSecretSeed(
       secretSeedFromInviteSecret(inviteSecret),
     );
+
     const inviteAgentID = this.crypto.getAgentID(inviteAgentSecret);
 
     const inviteRole = await new Promise((resolve, reject) => {
@@ -493,9 +505,10 @@ export class LocalNode {
     }
 
     const groupAsInvite = expectGroup(
-      group.core.contentInClonedNodeWithDifferentAccount(
-        new ControlledAgent(inviteAgentSecret, this.crypto),
-      ),
+      this.loadCoValueAsDifferentAgent(
+        group.id,
+        inviteAgentSecret,
+      ).getCurrentContent(),
     );
 
     groupAsInvite.addMemberInternal(
@@ -524,7 +537,7 @@ export class LocalNode {
 
     if (!coValue.isAvailable()) {
       throw new Error(
-        `${expectation ? expectation + ": " : ""}CoValue ${id} not yet loaded. Current state: ${JSON.stringify(coValue)}`,
+        `${expectation ? expectation + ": " : ""}CoValue ${id} not yet loaded.`,
       );
     }
     return coValue;
@@ -621,46 +634,56 @@ export class LocalNode {
     return group;
   }
 
-  /** @internal */
-  cloneWithDifferentAccount(
-    controlledAccountOrAgent: ControlledAccountOrAgent,
-  ): LocalNode {
+  loadCoValueAsDifferentAgent(
+    id: RawCoID,
+    secret: AgentSecret,
+    accountId?: RawAccountID | AgentID,
+  ) {
+    const agent = new ControlledAgent(secret, this.crypto);
+
     const newNode = new LocalNode(
-      controlledAccountOrAgent.agentSecret,
-      this.crypto.newRandomSessionID(controlledAccountOrAgent.id),
+      secret,
+      this.crypto.newRandomSessionID(accountId || agent.id),
       this.crypto,
     );
 
-    newNode.cloneVerifiedStateFrom(this);
+    newNode.cloneVerifiedStateFrom(this, id);
 
-    return newNode;
+    return newNode.expectCoValueLoaded(id);
   }
 
   /** @internal */
-  cloneVerifiedStateFrom(otherNode: LocalNode) {
-    const coValuesToCopy = Array.from(otherNode.coValues.entries());
+  cloneVerifiedStateFrom(otherNode: LocalNode, id: RawCoID) {
+    const coValuesIdsToCopy = [id];
 
-    while (coValuesToCopy.length > 0) {
-      const [coValueID, coValue] = coValuesToCopy[coValuesToCopy.length - 1]!;
+    // Scan all the dependencies and add them to the list
+    for (let i = 0; i < coValuesIdsToCopy.length; i++) {
+      const coValueID = coValuesIdsToCopy[i]!;
+      const coValue = otherNode.getCoValue(coValueID);
 
       if (!coValue.isAvailable()) {
-        coValuesToCopy.pop();
         continue;
-      } else {
-        const allDepsCopied = coValue
-          .getDependedOnCoValues()
-          .every((dep) => this.coValues.get(dep)?.isAvailable());
-
-        if (!allDepsCopied) {
-          // move to end of queue
-          coValuesToCopy.unshift(coValuesToCopy.pop()!);
-          continue;
-        }
+      }
 
-        this.putCoValue(coValueID, coValue.verified);
+      for (const dep of coValue.getDependedOnCoValues()) {
+        coValuesIdsToCopy.push(dep);
+      }
+    }
 
-        coValuesToCopy.pop();
+    // Copy the coValue all the dependencies by following the dependency order
+    while (coValuesIdsToCopy.length > 0) {
+      const coValueID = coValuesIdsToCopy.pop()!;
+      const coValue = otherNode.getCoValue(coValueID);
+
+      if (!coValue.isAvailable()) {
+        continue;
       }
+
+      if (this.coValues.get(coValueID)?.isAvailable()) {
+        continue;
+      }
+
+      this.putCoValue(coValueID, coValue.verified);
     }
   }
 

package/src/tests/permissions.test.ts

@@ -512,7 +512,6 @@ test("Admins can set group read key and then use it to create private transactio
   const { node, groupCore, admin } = newGroup();
 
   const reader1 = createAccountInNode(node);
-
   const reader2 = createAccountInNode(node);
 
   const { secret: readKey, id: readKeyID } = Crypto.newRandomKeySecret();
@@ -583,6 +582,9 @@ test("Admins can set group read key and then use it to create private transactio
     childObject.contentInClonedNodeWithDifferentAccount(reader2),
   );
 
+  // Need to copy the account coValue to the new node to be able to read the readKey
+  childObjectAsReader2.core.node.cloneVerifiedStateFrom(node, reader2.id);
+
   expect(childObjectAsReader2.core.getCurrentReadKey().secret).toEqual(readKey);
   expect(childObjectAsReader2.get("foo")).toEqual("bar");
 });
@@ -1113,9 +1115,10 @@ test("Admins can create an adminInvite, which can add an admin (high-level)", as
   const invitedAdminSecret = Crypto.newRandomAgentSecret();
   const invitedAdminID = Crypto.getAgentID(invitedAdminSecret);
 
-  const nodeAsInvitedAdmin = node.cloneWithDifferentAccount(
-    new ControlledAgent(invitedAdminSecret, Crypto),
-  );
+  const nodeAsInvitedAdmin = node.loadCoValueAsDifferentAgent(
+    group.id,
+    invitedAdminSecret,
+  ).node;
 
   await nodeAsInvitedAdmin.acceptInvite(group.id, inviteSecret);
 
@@ -1219,9 +1222,10 @@ test("Admins can create a writerInvite, which can add a writer (high-level)", as
   const invitedWriterSecret = Crypto.newRandomAgentSecret();
   const invitedWriterID = Crypto.getAgentID(invitedWriterSecret);
 
-  const nodeAsInvitedWriter = node.cloneWithDifferentAccount(
-    new ControlledAgent(invitedWriterSecret, Crypto),
-  );
+  const nodeAsInvitedWriter = node.loadCoValueAsDifferentAgent(
+    group.id,
+    invitedWriterSecret,
+  ).node;
 
   await nodeAsInvitedWriter.acceptInvite(group.id, inviteSecret);
 
@@ -1308,9 +1312,10 @@ test("Admins can create a readerInvite, which can add a reader (high-level)", as
   const invitedReaderSecret = Crypto.newRandomAgentSecret();
   const invitedReaderID = Crypto.getAgentID(invitedReaderSecret);
 
-  const nodeAsInvitedReader = node.cloneWithDifferentAccount(
-    new ControlledAgent(invitedReaderSecret, Crypto),
-  );
+  const nodeAsInvitedReader = node.loadCoValueAsDifferentAgent(
+    group.id,
+    invitedReaderSecret,
+  ).node;
 
   await nodeAsInvitedReader.acceptInvite(group.id, inviteSecret);
 

package/src/tests/sync.invite.test.ts

@@ -0,0 +1,163 @@
+import { beforeEach, describe, expect, test } from "vitest";
+
+import { expectList, expectMap } from "../coValue";
+import { WasmCrypto } from "../crypto/WasmCrypto";
+import {
+  SyncMessagesLog,
+  loadCoValueOrFail,
+  setupTestNode,
+  waitFor,
+} from "./testUtils";
+
+const Crypto = await WasmCrypto.create();
+let jazzCloud = setupTestNode({ isSyncServer: true });
+
+beforeEach(async () => {
+  SyncMessagesLog.clear();
+  jazzCloud = setupTestNode({ isSyncServer: true });
+});
+
+describe("invitations sync", () => {
+  test("invite a client to a group", async () => {
+    const client = setupTestNode();
+    client.connectToSyncServer({
+      ourName: "invite-provider",
+    });
+    const client2 = setupTestNode();
+    client2.connectToSyncServer({
+      ourName: "invite-consumer",
+    });
+
+    const group = client.node.createGroup();
+    const map = group.createMap();
+    map.set("hello", "world");
+
+    await map.core.waitForSync();
+
+    const invite = group.createInvite("reader");
+
+    await group.core.waitForSync();
+    SyncMessagesLog.clear();
+
+    await client2.node.acceptInvite(map.id, invite);
+
+    const mapOnClient2 = await loadCoValueOrFail(client2.node, map.id);
+    expect(mapOnClient2.get("hello")).toEqual("world");
+
+    expect(
+      SyncMessagesLog.getMessages({
+        Group: group.core,
+        Map: map.core,
+      }),
+    ).toMatchInlineSnapshot(`
+      [
+        "invite-consumer -> server | LOAD Map sessions: empty",
+        "server -> invite-consumer | CONTENT Group header: true new: After: 0 New: 5",
+        "invite-consumer -> server | KNOWN Group sessions: header/5",
+        "server -> invite-consumer | CONTENT Map header: true new: After: 0 New: 1",
+        "invite-consumer -> server | KNOWN Map sessions: header/1",
+      ]
+    `);
+  });
+
+  test("invite a client to a group with parents", async () => {
+    const client = setupTestNode();
+    client.connectToSyncServer({
+      ourName: "invite-provider",
+    });
+    const client2 = setupTestNode();
+    client2.connectToSyncServer({
+      ourName: "invite-consumer",
+    });
+
+    const parentGroup = client.node.createGroup();
+    const group = client.node.createGroup();
+
+    group.extend(parentGroup);
+    const map = group.createMap();
+    map.set("hello", "world");
+
+    await map.core.waitForSync();
+
+    const invite = group.createInvite("reader");
+
+    await group.core.waitForSync();
+    SyncMessagesLog.clear();
+
+    await client2.node.acceptInvite(map.id, invite);
+
+    const mapOnClient2 = await loadCoValueOrFail(client2.node, map.id);
+    expect(mapOnClient2.get("hello")).toEqual("world");
+
+    expect(
+      SyncMessagesLog.getMessages({
+        Group: group.core,
+        ParentGroup: parentGroup.core,
+        Map: map.core,
+      }),
+    ).toMatchInlineSnapshot(`
+      [
+        "invite-consumer -> server | LOAD Map sessions: empty",
+        "server -> invite-consumer | CONTENT ParentGroup header: true new: After: 0 New: 4",
+        "invite-consumer -> server | KNOWN ParentGroup sessions: header/4",
+        "server -> invite-consumer | CONTENT Group header: true new: After: 0 New: 7",
+        "invite-consumer -> server | KNOWN Group sessions: header/7",
+        "server -> invite-consumer | CONTENT Map header: true new: After: 0 New: 1",
+        "invite-consumer -> server | KNOWN Map sessions: header/1",
+      ]
+    `);
+  });
+
+  test("invite a client to a parent group", async () => {
+    const client = setupTestNode();
+    client.connectToSyncServer({
+      ourName: "invite-provider",
+    });
+    const client2 = setupTestNode();
+    client2.connectToSyncServer({
+      ourName: "invite-consumer",
+    });
+
+    const parentGroup = client.node.createGroup();
+    const group = client.node.createGroup();
+
+    group.extend(parentGroup);
+    const map = group.createMap();
+    map.set("hello", "world");
+
+    await map.core.waitForSync();
+
+    const invite = parentGroup.createInvite("reader");
+
+    await parentGroup.core.waitForSync();
+    SyncMessagesLog.clear();
+
+    await client2.node.acceptInvite(parentGroup.id, invite);
+
+    const mapOnClient2 = await loadCoValueOrFail(client2.node, map.id);
+    expect(mapOnClient2.get("hello")).toEqual("world");
+
+    expect(
+      SyncMessagesLog.getMessages({
+        Group: group.core,
+        ParentGroup: parentGroup.core,
+        Map: map.core,
+      }),
+    ).toMatchInlineSnapshot(`
+      [
+        "invite-consumer -> server | LOAD ParentGroup sessions: empty",
+        "server -> invite-consumer | CONTENT ParentGroup header: true new: After: 0 New: 6",
+        "invite-consumer -> server | KNOWN ParentGroup sessions: header/6",
+        "invite-consumer -> server | LOAD Map sessions: empty",
+        "server -> invite-consumer | CONTENT Group header: true new: After: 0 New: 5",
+        "invite-consumer -> server | KNOWN Group sessions: header/5",
+        "server -> invite-consumer | CONTENT Map header: true new: After: 0 New: 1",
+        "invite-consumer -> server | CONTENT ParentGroup header: false new: After: 0 New: 2",
+        "server -> invite-consumer | KNOWN ParentGroup sessions: header/8",
+        "server -> invite-provider | CONTENT ParentGroup header: false new: After: 0 New: 2",
+        "invite-consumer -> server | KNOWN Map sessions: header/1",
+        "invite-provider -> server | KNOWN ParentGroup sessions: header/8",
+      ]
+    `);
+  });
+});

package/dist/utils.d.ts

@@ -1,5 +0,0 @@
-export declare function parseError(e: unknown): {
-    message: string | null;
-    stack: string | null;
-};
-//# sourceMappingURL=utils.d.ts.map

package/dist/utils.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"AAAA,wBAAgB,UAAU,CAAC,CAAC,EAAE,OAAO,GAAG;IACtC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;CACtB,CAKA"}

package/dist/utils.js

@@ -1,7 +0,0 @@
-export function parseError(e) {
-    return {
-        message: e instanceof Error ? e.message : null,
-        stack: e instanceof Error ? (e.stack ?? null) : null,
-    };
-}
-//# sourceMappingURL=utils.js.map

package/dist/utils.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"utils.js","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"AAAA,MAAM,UAAU,UAAU,CAAC,CAAU;IAInC,OAAO;QACL,OAAO,EAAE,CAAC,YAAY,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI;QAC9C,KAAK,EAAE,CAAC,YAAY,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,KAAK,IAAI,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI;KACrD,CAAC;AACJ,CAAC"}

package/src/utils.ts

@@ -1,9 +0,0 @@
-export function parseError(e: unknown): {
-  message: string | null;
-  stack: string | null;
-} {
-  return {
-    message: e instanceof Error ? e.message : null,
-    stack: e instanceof Error ? (e.stack ?? null) : null,
-  };
-}