jazz-tools 0.19.4 → 0.19.6

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

@@ -10,6 +10,7 @@ import {
   type RefEncoded,
   type RefsToResolve,
   TypeSym,
+  createUnloadedCoValue,
   instantiateRefEncodedFromRaw,
   isRefEncoded,
 } from "../internal.js";
@@ -291,15 +292,7 @@ export class SubscriptionScope<D extends CoValue> {
       return this.unloadedValue;
     }
 
-    const unloadedValue: NotLoaded<D> = {
-      $jazz: {
-        id: this.id,
-        loadingState: reason,
-        // @ts-expect-error - This is a private property
-        _subscriptionScope: this,
-      },
-      $isLoaded: false,
-    };
+    const unloadedValue: NotLoaded<D> = createUnloadedCoValue(this.id, reason);
 
     this.unloadedValue = unloadedValue;
 

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/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;
+}