jazz-tools 0.19.5 → 0.19.7

package/src/tools/implementation/zodSchema/schemaTypes/AccountSchema.ts

@@ -93,15 +93,20 @@ export class AccountSchema<
     );
   }
 
-  /** @internal */
+  // Create an account via worker, useful to generate controlled accounts from the server
   createAs(
-    as: Account,
+    worker: Account,
     options: {
       creationProps: { name: string };
+      onCreate?: (
+        account: AccountInstance<Shape>,
+        worker: Account,
+      ) => Promise<void>;
     },
-  ): Promise<AccountInstance<Shape>> {
+    // @ts-expect-error we can't statically enforce the schema's resolve query is a valid resolve query, but in practice it is
+  ): Promise<Loaded<AccountSchema<Shape>, DefaultResolveQuery>> {
     // @ts-expect-error
-    return this.coValueClass.createAs(as, options);
+    return this.coValueClass.createAs(worker, options);
   }
 
   unstable_merge<

package/src/tools/subscribe/SubscriptionScope.ts

@@ -91,7 +91,11 @@ export class SubscriptionScope<D extends CoValue> {
         // - Run the migration only once
         // - Skip all the updates until the migration is done
         // - Trigger handleUpdate only with the final value
-        if (!this.migrated && value !== CoValueLoadingState.UNAVAILABLE) {
+        if (
+          !this.migrated &&
+          value !== CoValueLoadingState.UNAVAILABLE &&
+          hasAccessToCoValue(value)
+        ) {
           if (this.migrating) {
             return;
           }
@@ -139,14 +143,7 @@ export class SubscriptionScope<D extends CoValue> {
       return;
     }
 
-    const ruleset = update.core.verified.header.ruleset;
-
-    // Groups and accounts are accessible by everyone, for the other coValues we use the role to check access
-    const hasAccess =
-      ruleset.type !== "ownedByGroup" ||
-      myRoleForRawValue(update) !== undefined;
-
-    if (!hasAccess) {
+    if (!hasAccessToCoValue(update)) {
       if (this.value.type !== CoValueLoadingState.UNAUTHORIZED) {
         this.updateValue(
           new JazzError(this.id, CoValueLoadingState.UNAUTHORIZED, [
@@ -759,3 +756,13 @@ export class SubscriptionScope<D extends CoValue> {
     this.childNodes.forEach((child) => child.destroy());
   }
 }
+
+function hasAccessToCoValue(rawCoValue: RawCoValue): boolean {
+  const ruleset = rawCoValue.core.verified.header.ruleset;
+
+  // Groups and accounts are accessible by everyone, for the other coValues we use the role to check access
+  return (
+    ruleset.type !== "ownedByGroup" ||
+    myRoleForRawValue(rawCoValue) !== undefined
+  );
+}

package/src/tools/tests/account.test.ts

@@ -435,3 +435,68 @@ describe("accepting invites", () => {
     expect(group.getRoleOf(newAccount.$jazz.id)).toBe("reader");
   });
 });
+
+describe("createAs", () => {
+  test("migration is executed before onCreate and onCreate can set root from worker", async () => {
+    const executionOrder: string[] = [];
+
+    const CustomRoot = co.map({
+      value: z.string(),
+    });
+
+    const CustomAccount = co
+      .account({
+        profile: co.profile({
+          name: z.string(),
+        }),
+        root: CustomRoot,
+      })
+      .withMigration((me) => {
+        executionOrder.push("migration");
+        if (me.root === undefined) {
+          me.$jazz.set("root", { value: "migration-set" });
+        }
+      });
+
+    const worker = await createJazzTestAccount({
+      isCurrentActiveAccount: true,
+    });
+
+    const workerRoot = CustomRoot.create(
+      { value: "worker-root" },
+      { owner: worker },
+    );
+
+    const createdAccount = await CustomAccount.createAs(worker, {
+      creationProps: { name: "Test Account" },
+      onCreate: async (account, loadedWorker) => {
+        executionOrder.push("onCreate");
+
+        // Verify migration ran before onCreate
+        expect(executionOrder).toEqual(["migration", "onCreate"]);
+
+        // Verify migration set the root
+        assertLoaded(account.root);
+        expect(account.root.value).toBe("migration-set");
+
+        // It should be possible to add the worker as a member of the root
+        account.root.$jazz.owner.addMember(loadedWorker, "writer");
+        expect(account.root.$jazz.owner.getRoleOf(loadedWorker.$jazz.id)).toBe(
+          "writer",
+        );
+
+        // Set root from worker in onCreate
+        account.$jazz.set("root", workerRoot);
+      },
+    });
+
+    assertLoaded(createdAccount);
+    assertLoaded(createdAccount.root);
+
+    // Verify onCreate was called and root was set from worker
+    expect(createdAccount.root.value).toBe("worker-root");
+
+    // Verify execution order
+    expect(executionOrder).toEqual(["migration", "onCreate"]);
+  });
+});

package/src/tools/tests/coDiscriminatedUnion.test.ts

@@ -1,5 +1,13 @@
-import { beforeEach, describe, expect, test, vi } from "vitest";
-import { CoPlainText, Group, Loaded, co, loadCoValue, z } from "../exports.js";
+import { assert, beforeEach, describe, expect, test, vi } from "vitest";
+import {
+  CoPlainText,
+  CoValueLoadingState,
+  Group,
+  Loaded,
+  co,
+  loadCoValue,
+  z,
+} from "../exports.js";
 import { createJazzTestAccount, setupJazzTestSync } from "../testing.js";
 import { assertLoaded, waitFor } from "./utils.js";
 import type { Account } from "jazz-tools";
@@ -713,4 +721,63 @@ describe("co.discriminatedUnion", () => {
       }
     });
   });
+
+  test("cannot create a co.discriminatedUnion member if it has no matching discriminator value", async () => {
+    const Dog = co.map({
+      type: z.literal("dog"),
+      name: z.string(),
+    });
+    const Cat = co.map({
+      type: z.literal("cat"),
+      name: z.string(),
+    });
+    const Parrot = co.map({
+      type2: z.literal("parrot"),
+      name: z.string(),
+    });
+    const Pet = co.discriminatedUnion("type", [Dog, Cat, Parrot]);
+    const Pets = co.list(Pet);
+
+    expect(() => Pets.create([{ type2: "parrot", name: "Polly" }])).toThrow(
+      "co.discriminatedUnion() of collaborative types with no matching discriminator value found",
+    );
+  });
+
+  test("can load a discriminated union CoList even if some elements are not accessible", async () => {
+    const Dog = co.map({
+      type: z.literal("dog"),
+      name: z.string(),
+    });
+    const Cat = co.map({
+      type: z.literal("cat"),
+      name: z.string(),
+    });
+    const Pet = co.discriminatedUnion("type", [Dog, Cat]);
+    const Pets = co.list(Pet);
+
+    const publicGroup = Group.create().makePublic();
+    const privateGroup = Group.create();
+    const pets = Pets.create(
+      [
+        Dog.create({ type: "dog", name: "Rex" }, publicGroup),
+        Cat.create({ type: "cat", name: "Whiskers" }, privateGroup),
+      ],
+      { owner: publicGroup },
+    );
+
+    const anotherAccount = await createJazzTestAccount();
+    const loadedPets = await Pets.load(pets.$jazz.id, {
+      resolve: { $each: { $onError: "catch" } },
+      loadAs: anotherAccount,
+    });
+
+    assertLoaded(loadedPets);
+    expect(loadedPets.length).toEqual(2);
+    assert(loadedPets[0]);
+    assertLoaded(loadedPets[0]);
+    expect(loadedPets[0].type).toEqual("dog");
+    expect(loadedPets[1]?.$jazz.loadingState).toEqual(
+      CoValueLoadingState.UNAUTHORIZED,
+    );
+  });
 });

package/src/tools/tests/exportImport.test.ts

@@ -5,6 +5,7 @@ import { Account, CoPlainText, Group, co, z } from "../exports.js";
 import {
   createJazzTestAccount,
   createJazzTestGuest,
+  disableJazzTestSync,
   setupJazzTestSync,
 } from "../testing.js";
 import { assertLoaded } from "./utils.js";
@@ -262,6 +263,83 @@ describe("exportCoValue", () => {
   });
 });
 
+describe("value.$jazz.export", () => {
+  test("exports a CoValue returned by create", async () => {
+    disableJazzTestSync();
+
+    const Person = co.map({
+      name: z.string(),
+      age: z.number(),
+    });
+
+    const group = Group.create();
+    group.addMember("everyone", "reader");
+
+    const person = Person.create({ name: "Jane", age: 28 }, group);
+
+    const exported = person.$jazz.export();
+
+    expect(exported.id).toBe(person.$jazz.id);
+
+    const bob = await createJazzTestAccount();
+    importContentPieces(exported.contentPieces, bob);
+
+    const loadedPerson = await Person.load(person.$jazz.id, { loadAs: bob });
+    assertLoaded(loadedPerson);
+
+    expect(loadedPerson.name).toBe("Jane");
+    expect(loadedPerson.age).toBe(28);
+  });
+
+  test("exports a nested CoValue loaded with load", async () => {
+    disableJazzTestSync();
+
+    const Address = co.map({
+      street: z.string(),
+      city: z.string(),
+    });
+
+    const Person = co.map({
+      name: z.string(),
+      address: Address,
+    });
+
+    const alice = await createJazzTestAccount();
+
+    const group = Group.create(alice);
+    group.addMember("everyone", "reader");
+
+    const address = Address.create(
+      { street: "123 Main St", city: "New York" },
+      group,
+    );
+    const person = Person.create({ name: "John", address }, group);
+
+    const loadedPerson = await Person.load(person.$jazz.id, {
+      resolve: { address: true },
+      loadAs: alice,
+    });
+
+    assertLoaded(loadedPerson);
+    assertLoaded(loadedPerson.address);
+
+    const exported = loadedPerson.$jazz.export();
+
+    const bob = await createJazzTestAccount();
+
+    importContentPieces(exported.contentPieces, bob);
+
+    const importedPerson = await Person.load(person.$jazz.id, {
+      resolve: { address: true },
+      loadAs: bob,
+    });
+
+    assertLoaded(importedPerson);
+    expect(importedPerson.address.street).toBe("123 Main St");
+    expect(importedPerson.address.city).toBe("New York");
+  });
+});
+
 describe("importContentPieces", () => {
   test("imports content pieces successfully", async () => {
     const Person = co.map({

package/src/tools/tests/groupsAndAccounts.test.ts

@@ -12,6 +12,7 @@ import {
 import { createJazzTestAccount, setupJazzTestSync } from "../testing.js";
 import {
   assertLoaded,
+  createAccountAs,
   loadCoValueOrFail,
   setupTwoNodes,
   waitFor,
@@ -100,7 +101,7 @@ describe("Group inheritance", () => {
 
     group.addMember(parentGroup);
 
-    const reader = await co.account().createAs(me, {
+    const reader = await createAccountAs(co.account(), me, {
       creationProps: { name: "Reader" },
     });
 
@@ -141,7 +142,7 @@ describe("Group inheritance", () => {
     group.addMember(parentGroup);
     parentGroup.addMember(grandParentGroup);
 
-    const reader = await co.account().createAs(me, {
+    const reader = await createAccountAs(co.account(), me, {
       creationProps: { name: "Reader" },
     });
 
@@ -359,7 +360,7 @@ describe("Group inheritance", () => {
 
     test("nested CoValues inherit permissions from the referencing CoValue", async () => {
       const me = co.account().getMe();
-      const reader = await co.account().createAs(me, {
+      const reader = await createAccountAs(co.account(), me, {
         creationProps: { name: "Reader" },
       });
 
@@ -504,16 +505,16 @@ describe("Account permissions", () => {
     const group = Group.create({ owner: admin });
     const testObject = CoMap.create({}, { owner: group });
 
-    const manager = await co.account().createAs(admin, {
+    const manager = await createAccountAs(co.account(), admin, {
       creationProps: { name: "Manager" },
     });
-    const writer = await co.account().createAs(admin, {
+    const writer = await createAccountAs(co.account(), admin, {
       creationProps: { name: "Writer" },
     });
-    const reader = await co.account().createAs(admin, {
+    const reader = await createAccountAs(co.account(), admin, {
       creationProps: { name: "Reader" },
     });
-    const writeOnly = await co.account().createAs(admin, {
+    const writeOnly = await createAccountAs(co.account(), admin, {
       creationProps: { name: "WriteOnly" },
     });
 
@@ -541,16 +542,16 @@ describe("Account permissions", () => {
     const group = Group.create({ owner: admin });
     const testObject = CoMap.create({}, { owner: group });
 
-    const manager = await co.account().createAs(admin, {
+    const manager = await createAccountAs(co.account(), admin, {
       creationProps: { name: "Manager" },
     });
-    const writer = await co.account().createAs(admin, {
+    const writer = await createAccountAs(co.account(), admin, {
       creationProps: { name: "Writer" },
     });
-    const reader = await co.account().createAs(admin, {
+    const reader = await createAccountAs(co.account(), admin, {
       creationProps: { name: "Reader" },
     });
-    const writeOnly = await co.account().createAs(admin, {
+    const writeOnly = await createAccountAs(co.account(), admin, {
       creationProps: { name: "WriteOnly" },
     });
 
@@ -578,17 +579,17 @@ describe("Account permissions", () => {
     const group = Group.create({ owner: admin });
     const testObject = CoMap.create({}, { owner: group });
 
-    const manager = await co.account().createAs(admin, {
+    const manager = await createAccountAs(co.account(), admin, {
       creationProps: { name: "Admin" },
     });
 
-    const writer = await co.account().createAs(admin, {
+    const writer = await createAccountAs(co.account(), admin, {
       creationProps: { name: "Writer" },
     });
-    const reader = await co.account().createAs(admin, {
+    const reader = await createAccountAs(co.account(), admin, {
       creationProps: { name: "Reader" },
     });
-    const writeOnly = await co.account().createAs(admin, {
+    const writeOnly = await createAccountAs(co.account(), admin, {
       creationProps: { name: "WriteOnly" },
     });
 
@@ -616,17 +617,17 @@ describe("Account permissions", () => {
     const group = Group.create({ owner: admin });
     const testObject = CoMap.create({}, { owner: group });
 
-    const manager = await co.account().createAs(admin, {
+    const manager = await createAccountAs(co.account(), admin, {
       creationProps: { name: "Admin" },
     });
 
-    const writer = await co.account().createAs(admin, {
+    const writer = await createAccountAs(co.account(), admin, {
       creationProps: { name: "Writer" },
     });
-    const reader = await co.account().createAs(admin, {
+    const reader = await createAccountAs(co.account(), admin, {
       creationProps: { name: "Reader" },
     });
-    const writeOnly = await co.account().createAs(admin, {
+    const writeOnly = await createAccountAs(co.account(), admin, {
       creationProps: { name: "WriteOnly" },
     });
 
@@ -653,7 +654,7 @@ describe("Account permissions", () => {
     const group = Group.create({ owner: admin });
     const testObject = CoMap.create({}, { owner: group });
 
-    const nonMember = await co.account().createAs(admin, {
+    const nonMember = await createAccountAs(co.account(), admin, {
       creationProps: { name: "NonMember" },
     });
 

package/src/tools/tests/schema.resolved.test.ts

@@ -248,11 +248,13 @@ describe("Schema.resolved()", () => {
 
         const account = await AccountWithProfile.createAs(serverAccount, {
           creationProps: { name: "Hermes Puggington" },
+          onCreate: async (account) => {
+            account.$jazz.set(
+              "profile",
+              co.profile().create({ name: "Hermes Puggington" }, publicGroup),
+            );
+          },
         });
-        account.$jazz.set(
-          "profile",
-          co.profile().create({ name: "Hermes Puggington" }, publicGroup),
-        );
 
         const loadedAccount = await AccountWithProfile.load(account.$jazz.id, {
           loadAs: clientAccount,
@@ -405,11 +407,13 @@ describe("Schema.resolved()", () => {
 
         const account = await AccountWithProfile.createAs(serverAccount, {
           creationProps: { name: "Hermes Puggington" },
+          onCreate: async (account) => {
+            account.$jazz.set(
+              "profile",
+              co.profile().create({ name: "Hermes Puggington" }, publicGroup),
+            );
+          },
         });
-        account.$jazz.set(
-          "profile",
-          co.profile().create({ name: "Hermes Puggington" }, publicGroup),
-        );
 
         const updates: co.loaded<typeof AccountWithProfile>[] = [];
         AccountWithProfile.subscribe(
@@ -559,18 +563,21 @@ describe("Schema.resolved()", () => {
 
         const account = await TestAccount.createAs(serverAccount, {
           creationProps: { name: "Hermes Puggington" },
+          onCreate: async (account) => {
+            account.$jazz.set(
+              "profile",
+              TestAccount.shape.profile.create(
+                { name: "Hermes Puggington" },
+                publicGroup,
+              ),
+            );
+            account.$jazz.set(
+              "root",
+              TestAccount.shape.root.create({ text: "Test" }, publicGroup),
+            );
+          },
         });
-        account.$jazz.set(
-          "profile",
-          TestAccount.shape.profile.create(
-            { name: "Hermes Puggington" },
-            publicGroup,
-          ),
-        );
-        account.$jazz.set(
-          "root",
-          TestAccount.shape.root.create({ text: "Test" }, publicGroup),
-        );
+
         const accountList = AccountList.create([account], publicGroup);
 
         const branchAccountList = await AccountList.load(accountList.$jazz.id, {

package/src/tools/tests/utils.ts

@@ -15,6 +15,7 @@ import {
   CoValueLoadingState,
   MaybeLoaded,
   LoadedAndRequired,
+  AccountSchema,
 } from "../internal";
 
 const Crypto = await WasmCrypto.create();
@@ -151,3 +152,29 @@ export function assertLoaded<T extends MaybeLoaded<CoValue>>(
 ): asserts coValue is LoadedAndRequired<T> {
   assert(coValue.$isLoaded, "CoValue is not loaded");
 }
+
+export async function createAccountAs<S extends AccountSchema<any, any>>(
+  schema: S,
+  as: Account,
+  options: {
+    creationProps: { name: string };
+  },
+) {
+  const connectedPeers = cojsonInternals.connectedPeers(
+    "creatingAccount",
+    "createdAccount",
+    { peer1role: "server", peer2role: "client" },
+  );
+
+  as.$jazz.localNode.syncManager.addPeer(connectedPeers[1]);
+
+  const account = await schema.create({
+    creationProps: options.creationProps,
+    crypto: as.$jazz.localNode.crypto,
+    peers: [connectedPeers[0]],
+  });
+
+  await account.$jazz.waitForAllCoValuesSync();
+
+  return account;
+}