jazz-tools 0.13.30 → 0.14.0

package/src/testing.ts

@@ -4,17 +4,14 @@ import { PureJSCrypto } from "cojson/dist/crypto/PureJSCrypto";
 import {
   Account,
   AccountClass,
+  type AnonymousJazzAgent,
   AuthCredentials,
-  JazzContextManagerAuthProps,
-} from "./exports.js";
-import {
+  type CoValueClass,
+  CoValueFromRaw,
   JazzContextManager,
+  JazzContextManagerAuthProps,
   JazzContextManagerBaseProps,
-} from "./implementation/ContextManager.js";
-import { activeAccountContext } from "./implementation/activeAccountContext.js";
-import {
-  type AnonymousJazzAgent,
-  type CoValueClass,
+  activeAccountContext,
   createAnonymousJazzContext,
   createJazzContext,
   randomSessionProvider,
@@ -76,13 +73,13 @@ export function getPeerConnectedToTestSyncServer() {
 const SecretSeedMap = new Map<string, Uint8Array>();
 let isMigrationActive = false;
 
-export async function createJazzTestAccount<Acc extends Account>(options?: {
+export async function createJazzTestAccount<A extends Account>(options?: {
   isCurrentActiveAccount?: boolean;
-  AccountSchema?: CoValueClass<Acc>;
+  AccountSchema?: CoValueClass<A>;
   creationProps?: Record<string, unknown>;
-}): Promise<Acc> {
+}): Promise<A> {
   const AccountSchema = (options?.AccountSchema ??
-    Account) as unknown as TestAccountSchema<Acc>;
+    Account) as unknown as TestAccountSchema<Account>;
   const peers = [];
   if (syncServer.current) {
     peers.push(getPeerConnectedToTestSyncServer());
@@ -134,7 +131,7 @@ export async function createJazzTestAccount<Acc extends Account>(options?: {
     activeAccountContext.set(account);
   }
 
-  return account;
+  return account as A;
 }
 
 export function setActiveAccount(account: Account) {
@@ -155,7 +152,7 @@ export async function createJazzTestGuest() {
 export type TestJazzContextManagerProps<Acc extends Account> =
   JazzContextManagerBaseProps<Acc> & {
     defaultProfileName?: string;
-    AccountSchema?: AccountClass<Acc>;
+    AccountSchema?: AccountClass<Acc> & CoValueFromRaw<Acc>;
     isAuthenticated?: boolean;
   };
 
@@ -194,7 +191,8 @@ export class TestJazzContextManager<
 
     context.updateContext(
       {
-        AccountSchema: account.constructor as AccountClass<Acc>,
+        AccountSchema: account.constructor as AccountClass<Acc> &
+          CoValueFromRaw<Acc>,
         ...props,
       },
       {
@@ -247,7 +245,7 @@ export class TestJazzContextManager<
       );
     }
 
-    const context = await createJazzContext<Acc>({
+    const context = await createJazzContext({
       credentials: authProps?.credentials,
       defaultProfileName: props.defaultProfileName,
       newAccountProps: authProps?.newAccountProps,

package/src/tests/ContextManager.test.ts

@@ -10,6 +10,8 @@ import {
   JazzAuthContext,
   KvStoreContext,
   co,
+  coField,
+  z,
 } from "../exports";
 import {
   JazzContextManager,
@@ -20,6 +22,12 @@ import {
   createJazzContext,
   randomSessionProvider,
 } from "../implementation/createContext";
+import {
+  CoValueFromRaw,
+  InstanceOfSchema,
+  Loaded,
+  zodSchemaToCoSchema,
+} from "../internal";
 import {
   createJazzTestAccount,
   getPeerConnectedToTestSyncServer,
@@ -38,11 +46,11 @@ class TestJazzContextManager<Acc extends Account> extends JazzContextManager<
   async getNewContext(
     props: JazzContextManagerBaseProps<Acc> & {
       defaultProfileName?: string;
-      AccountSchema?: AccountClass<Acc>;
+      AccountSchema?: AccountClass<Acc> & CoValueFromRaw<Acc>;
     },
     authProps?: JazzContextManagerAuthProps,
   ) {
-    const context = await createJazzContext<Acc>({
+    const context = await createJazzContext({
       credentials: authProps?.credentials,
       defaultProfileName: props.defaultProfileName,
       newAccountProps: authProps?.newAccountProps,
@@ -226,31 +234,37 @@ describe("ContextManager", () => {
   });
 
   test("the migration should be applied correctly on existing accounts", async () => {
-    class AccountRoot extends CoMap {
-      value = co.string;
-    }
+    const AccountRoot = co.map({
+      value: z.string(),
+    });
 
     let lastRootId: string | undefined;
 
-    class CustomAccount extends Account {
-      root = co.ref(AccountRoot);
-
-      migrate() {
-        this.root = AccountRoot.create({
+    const CustomAccount = co
+      .account({
+        root: AccountRoot,
+        profile: co.profile(),
+      })
+      .withMigration(async (account) => {
+        account.root = AccountRoot.create({
           value: "Hello",
         });
-        lastRootId = this.root.id;
-      }
-    }
-    const customManager = new TestJazzContextManager<CustomAccount>();
+        lastRootId = account.root.id;
+      });
+
+    const customManager = new TestJazzContextManager<
+      InstanceOfSchema<typeof CustomAccount>
+    >();
 
     // Create initial anonymous context
     await customManager.createContext({
-      AccountSchema: CustomAccount,
+      AccountSchema: zodSchemaToCoSchema(CustomAccount),
     });
 
     const account = (
-      customManager.getCurrentValue() as JazzAuthContext<CustomAccount>
+      customManager.getCurrentValue() as JazzAuthContext<
+        InstanceOfSchema<typeof CustomAccount>
+      >
     ).me;
 
     console.log("before", account._refs.root?.id);
@@ -271,34 +285,41 @@ describe("ContextManager", () => {
   });
 
   test("the migration should be applied correctly on existing accounts (2)", async () => {
-    class AccountRoot extends CoMap {
-      value = co.number;
-    }
-
-    class CustomAccount extends Account {
-      root = co.ref(AccountRoot);
+    const AccountRoot = co.map({
+      value: z.number(),
+    });
 
-      async migrate(this: CustomAccount) {
-        if (this.root === undefined) {
-          this.root = AccountRoot.create({
+    const CustomAccount = co
+      .account({
+        root: AccountRoot,
+        profile: co.profile(),
+      })
+      .withMigration(async (account) => {
+        if (account.root === undefined) {
+          account.root = AccountRoot.create({
             value: 1,
           });
         } else {
-          const { root } = await this.ensureLoaded({ resolve: { root: true } });
+          const { root } = await account.ensureLoaded({
+            resolve: { root: true },
+          });
 
           root.value = 2;
         }
-      }
-    }
-    const customManager = new TestJazzContextManager<CustomAccount>();
+      });
+    const customManager = new TestJazzContextManager<
+      InstanceOfSchema<typeof CustomAccount>
+    >();
 
     // Create initial anonymous context
     await customManager.createContext({
-      AccountSchema: CustomAccount,
+      AccountSchema: zodSchemaToCoSchema(CustomAccount),
     });
 
     const account = (
-      customManager.getCurrentValue() as JazzAuthContext<CustomAccount>
+      customManager.getCurrentValue() as JazzAuthContext<
+        InstanceOfSchema<typeof CustomAccount>
+      >
     ).me;
 
     await customManager.authenticate({
@@ -315,25 +336,28 @@ describe("ContextManager", () => {
   });
 
   test("onAnonymousAccountDiscarded should work on transfering data between accounts", async () => {
-    class AccountRoot extends CoMap {
-      value = co.string;
-      transferredRoot = co.optional.ref(AccountRoot);
-    }
-
-    class CustomAccount extends Account {
-      root = co.ref(AccountRoot);
+    const AccountRoot = co.map({
+      value: z.string(),
+      get transferredRoot(): z.ZodOptional<typeof AccountRoot> {
+        return z.optional(AccountRoot);
+      },
+    });
 
-      migrate() {
-        if (this.root === undefined) {
-          this.root = AccountRoot.create({
+    const CustomAccount = co
+      .account({
+        root: AccountRoot,
+        profile: co.profile(),
+      })
+      .withMigration(async (account) => {
+        if (account.root === undefined) {
+          account.root = AccountRoot.create({
             value: "Hello",
           });
         }
-      }
-    }
+      });
 
     const onAnonymousAccountDiscarded = async (
-      anonymousAccount: CustomAccount,
+      anonymousAccount: Loaded<typeof CustomAccount, { root: true }>,
     ) => {
       const anonymousAccountWithRoot = await anonymousAccount.ensureLoaded({
         resolve: {
@@ -354,17 +378,19 @@ describe("ContextManager", () => {
       meWithRoot.root.transferredRoot = rootToTransfer;
     };
 
-    const customManager = new TestJazzContextManager<CustomAccount>();
+    const customManager = new TestJazzContextManager<
+      InstanceOfSchema<typeof CustomAccount>
+    >();
 
     // Create initial anonymous context
     await customManager.createContext({
       onAnonymousAccountDiscarded,
-      AccountSchema: CustomAccount,
+      AccountSchema: zodSchemaToCoSchema(CustomAccount),
     });
 
     const account = await createJazzTestAccount({
       isCurrentActiveAccount: true,
-      AccountSchema: CustomAccount,
+      AccountSchema: zodSchemaToCoSchema(CustomAccount),
     });
 
     await customManager.authenticate({

package/src/tests/DemoAuth.test.ts

@@ -4,7 +4,7 @@ import { AuthSecretStorage } from "../auth/AuthSecretStorage";
 import { DemoAuth } from "../auth/DemoAuth";
 import { InMemoryKVStore } from "../auth/InMemoryKVStore";
 import { KvStoreContext } from "../auth/KvStoreContext";
-import { Account } from "../coValues/account";
+import { Account } from "../exports";
 import { ID } from "../internal";
 import { createJazzTestAccount } from "../testing";
 

package/src/tests/account.test.ts

@@ -1,6 +1,5 @@
-import { LocalNode } from "cojson";
 import { assert, beforeEach, expect, test } from "vitest";
-import { Account, CoMap, Group, co } from "../exports.js";
+import { Account, Group, co, z } from "../exports.js";
 import {
   createJazzTestAccount,
   linkAccounts,
@@ -14,9 +13,9 @@ beforeEach(async () => {
 });
 
 test("waitForAllCoValuesSync should resolve when all the values are synced", async () => {
-  class TestMap extends CoMap {
-    name = co.string;
-  }
+  const TestMap = co.map({
+    name: z.string(),
+  });
 
   const { clientNode, serverNode, clientAccount } = await setupTwoNodes();
 
@@ -99,10 +98,8 @@ test("accounts should sync correctly", async () => {
 
   group.addMember(otherAccount, "writer");
 
-  const { members } = group;
-
-  expect(members[0]?.account.profile!.name).toBe("test 1");
-  expect(members[1]?.account.profile!.name).toBe("test 2");
+  expect(group.members[0]?.account.profile!.name).toBe("test 1");
+  expect(group.members[1]?.account.profile!.name).toBe("test 2");
 });
 
 test("loading accounts should work", async () => {

package/src/tests/coFeed.test.ts

@@ -1,5 +1,5 @@
 import { WasmCrypto } from "cojson/crypto/WasmCrypto";
-import { describe, expect, test } from "vitest";
+import { describe, expect, expectTypeOf, test } from "vitest";
 import {
   Account,
   CoFeed,
@@ -7,10 +7,14 @@ import {
   Group,
   ID,
   co,
+  coField,
   cojsonInternals,
   isControlledAccount,
+  z,
 } from "../index.js";
 import {
+  AnyCoFeedSchema,
+  Loaded,
   createJazzContextFromExistingCredentials,
   randomSessionProvider,
 } from "../internal.js";
@@ -29,19 +33,19 @@ describe("Simple CoFeed operations", async () => {
   if (!isControlledAccount(me)) {
     throw "me is not a controlled account";
   }
-  class TestStream extends CoFeed.Of(co.string) {}
+  const TestStream = co.feed(z.string());
 
   const stream = TestStream.create(["milk"], { owner: me });
 
   test("Construction", () => {
-    expect(stream[me.id]?.value).toEqual("milk");
+    expect(stream.perAccount[me.id]?.value).toEqual("milk");
     expect(stream.perSession[me.sessionID]?.value).toEqual("milk");
   });
 
   test("Construction with an Account", () => {
     const stream = TestStream.create(["milk"], me);
 
-    expect(stream[me.id]?.value).toEqual("milk");
+    expect(stream.perAccount[me.id]?.value).toEqual("milk");
     expect(stream.perSession[me.sessionID]?.value).toEqual("milk");
   });
 
@@ -49,33 +53,27 @@ describe("Simple CoFeed operations", async () => {
     const group = Group.create(me);
     const stream = TestStream.create(["milk"], group);
 
-    expect(stream[me.id]?.value).toEqual("milk");
+    expect(stream.perAccount[me.id]?.value).toEqual("milk");
     expect(stream.perSession[me.sessionID]?.value).toEqual("milk");
   });
 
   describe("Mutation", () => {
     test("pushing", () => {
       stream.push("bread");
-      expect(stream[me.id]?.value).toEqual("bread");
+      expect(stream.perAccount[me.id]?.value).toEqual("bread");
       expect(stream.perSession[me.sessionID]?.value).toEqual("bread");
 
       stream.push("butter");
-      expect(stream[me.id]?.value).toEqual("butter");
+      expect(stream.perAccount[me.id]?.value).toEqual("butter");
       expect(stream.perSession[me.sessionID]?.value).toEqual("butter");
     });
   });
 });
 
 describe("CoFeed resolution", async () => {
-  class TwiceNestedStream extends CoFeed.Of(co.string) {
-    fancyValueOf(account: ID<Account>) {
-      return "Sir " + this[account]?.value;
-    }
-  }
-
-  class NestedStream extends CoFeed.Of(co.ref(TwiceNestedStream)) {}
-
-  class TestStream extends CoFeed.Of(co.ref(NestedStream)) {}
+  const TwiceNestedStream = co.feed(z.string());
+  const NestedStream = co.feed(TwiceNestedStream);
+  const TestStream = co.feed(NestedStream);
 
   const initNodeAndStream = async () => {
     const me = await Account.create({
@@ -98,9 +96,15 @@ describe("CoFeed resolution", async () => {
 
   test("Construction", async () => {
     const { me, stream } = await initNodeAndStream();
-    expect(stream[me.id]?.value?.[me.id]?.value?.[me.id]?.value).toEqual(
-      "milk",
-    );
+
+    // TODO: fix this
+    // expectTypeOf(stream[me.id]).not.toBeAny();
+
+    expect(
+      stream.perAccount[me.id]?.value?.perAccount[me.id]?.value?.perAccount[
+        me.id
+      ]?.value,
+    ).toEqual("milk");
   });
 
   test("Loading and availability", async () => {
@@ -128,46 +132,52 @@ describe("CoFeed resolution", async () => {
       loadAs: meOnSecondPeer,
     });
 
-    expect(loadedStream?.[me.id]?.value).toEqual(null);
-    expect(loadedStream?.[me.id]?.ref?.id).toEqual(stream[me.id]?.value?.id);
+    // TODO: fix this
+    // expectTypeOf(loadedStream?.[me.id]).not.toBeAny();
+
+    expect(loadedStream?.perAccount[me.id]?.value).toEqual(null);
+    expect(loadedStream?.perAccount[me.id]?.ref?.id).toEqual(
+      stream.perAccount[me.id]?.value?.id,
+    );
 
     const loadedNestedStream = await NestedStream.load(
-      stream[me.id]!.value!.id,
+      stream.perAccount[me.id]!.value!.id,
       { loadAs: meOnSecondPeer },
     );
 
     // expect(loadedStream?.[me.id]?.value).toEqual(loadedNestedStream);
-    expect(loadedStream?.[me.id]?.value?.id).toEqual(loadedNestedStream?.id);
-    expect(loadedStream?.[me.id]?.value?.[me.id]?.value).toEqual(null);
-    // expect(loadedStream?.[me.id]?.ref?.value).toEqual(loadedNestedStream);
-    expect(loadedStream?.[me.id]?.ref?.value?.id).toEqual(
+    expect(loadedStream?.perAccount[me.id]?.value?.id).toEqual(
       loadedNestedStream?.id,
     );
-    expect(loadedStream?.[me.id]?.value?.[me.id]?.ref?.id).toEqual(
-      stream[me.id]?.value?.[me.id]?.value?.id,
+    expect(
+      loadedStream?.perAccount[me.id]?.value?.perAccount[me.id]?.value,
+    ).toEqual(null);
+    // expect(loadedStream?.[me.id]?.ref?.value).toEqual(loadedNestedStream);
+    expect(loadedStream?.perAccount[me.id]?.ref?.value?.id).toEqual(
+      loadedNestedStream?.id,
     );
+    expect(
+      loadedStream?.perAccount[me.id]?.value?.perAccount[me.id]?.ref?.id,
+    ).toEqual(stream.perAccount[me.id]?.value?.perAccount[me.id]?.value?.id);
 
     const loadedTwiceNestedStream = await TwiceNestedStream.load(
-      stream[me.id]!.value![me.id]!.value!.id,
+      stream.perAccount[me.id]!.value!.perAccount[me.id]!.value!.id,
       { loadAs: meOnSecondPeer },
     );
 
     // expect(loadedStream?.[me.id]?.value?.[me.id]?.value).toEqual(
     //     loadedTwiceNestedStream
     // );
-    expect(loadedStream?.[me.id]?.value?.[me.id]?.value?.id).toEqual(
-      loadedTwiceNestedStream?.id,
-    );
     expect(
-      loadedStream?.[me.id]?.value?.[me.id]?.value?.fancyValueOf(me.id),
-    ).toEqual("Sir milk");
+      loadedStream?.perAccount[me.id]?.value?.perAccount[me.id]?.value?.id,
+    ).toEqual(loadedTwiceNestedStream?.id);
     // expect(loadedStream?.[me.id]?.ref?.value).toEqual(loadedNestedStream);
-    expect(loadedStream?.[me.id]?.ref?.value?.id).toEqual(
+    expect(loadedStream?.perAccount[me.id]?.ref?.value?.id).toEqual(
       loadedNestedStream?.id,
     );
-    expect(loadedStream?.[me.id]?.value?.[me.id]?.ref?.value?.id).toEqual(
-      loadedTwiceNestedStream?.id,
-    );
+    expect(
+      loadedStream?.perAccount[me.id]?.value?.perAccount[me.id]?.ref?.value?.id,
+    ).toEqual(loadedTwiceNestedStream?.id);
 
     const otherNestedStream = NestedStream.create(
       [TwiceNestedStream.create(["butter"], { owner: meOnSecondPeer })],
@@ -175,16 +185,15 @@ describe("CoFeed resolution", async () => {
     );
     loadedStream?.push(otherNestedStream);
     // expect(loadedStream?.[me.id]?.value).toEqual(otherNestedStream);
-    expect(loadedStream?.[me.id]?.value?.id).toEqual(otherNestedStream?.id);
-    expect(loadedStream?.[me.id]?.ref?.value?.id).toEqual(
+    expect(loadedStream?.perAccount[me.id]?.value?.id).toEqual(
       otherNestedStream?.id,
     );
-    expect(loadedStream?.[me.id]?.value?.[me.id]?.value?.id).toEqual(
-      otherNestedStream[me.id]?.value?.id,
+    expect(loadedStream?.perAccount[me.id]?.ref?.value?.id).toEqual(
+      otherNestedStream?.id,
     );
     expect(
-      loadedStream?.[me.id]?.value?.[me.id]?.value?.fancyValueOf(me.id),
-    ).toEqual("Sir butter");
+      loadedStream?.perAccount[me.id]?.value?.perAccount[me.id]?.value?.id,
+    ).toEqual(otherNestedStream.perAccount[me.id]?.value?.id);
   });
 
   test("Subscription & auto-resolution", async () => {
@@ -221,20 +230,32 @@ describe("CoFeed resolution", async () => {
     );
 
     const update1 = (await queue.next()).value;
-    expect(update1[me.id]?.value).toEqual(null);
+    expect(update1.perAccount[me.id]?.value).toEqual(null);
 
     const update2 = (await queue.next()).value;
-    expect(update2[me.id]?.value).toBeDefined();
-    expect(update2[me.id]?.value?.[me.id]?.value).toBe(null);
+    expect(update2.perAccount[me.id]?.value).toBeDefined();
+    expect(update2.perAccount[me.id]?.value?.perAccount[me.id]?.value).toBe(
+      null,
+    );
 
     const update3 = (await queue.next()).value;
-    expect(update3[me.id]?.value?.[me.id]?.value).toBeDefined();
-    expect(update3[me.id]?.value?.[me.id]?.value?.[me.id]?.value).toBe("milk");
+    expect(
+      update3.perAccount[me.id]?.value?.perAccount[me.id]?.value,
+    ).toBeDefined();
+    expect(
+      update3.perAccount[me.id]?.value?.perAccount[me.id]?.value?.perAccount[
+        me.id
+      ]?.value,
+    ).toBe("milk");
 
-    update3[me.id]!.value![me.id]!.value!.push("bread");
+    update3.perAccount[me.id]!.value!.perAccount[me.id]!.value!.push("bread");
 
     const update4 = (await queue.next()).value;
-    expect(update4[me.id]?.value?.[me.id]?.value?.[me.id]?.value).toBe("bread");
+    expect(
+      update4.perAccount[me.id]?.value?.perAccount[me.id]?.value?.perAccount[
+        me.id
+      ]?.value,
+    ).toBe("bread");
 
     // When assigning a new nested stream, we get an update
     const newTwiceNested = TwiceNestedStream.create(["butter"], {
@@ -248,14 +269,20 @@ describe("CoFeed resolution", async () => {
     update4.push(newNested);
 
     const update5 = (await queue.next()).value;
-    expect(update5[me.id]?.value?.[me.id]?.value?.[me.id]?.value).toBe(
-      "butter",
-    );
+    expect(
+      update5.perAccount[me.id]?.value?.perAccount[me.id]?.value?.perAccount[
+        me.id
+      ]?.value,
+    ).toBe("butter");
 
     // we get updates when the new nested stream changes
     newTwiceNested.push("jam");
     const update6 = (await queue.next()).value;
-    expect(update6[me.id]?.value?.[me.id]?.value?.[me.id]?.value).toBe("jam");
+    expect(
+      update6.perAccount[me.id]?.value?.perAccount[me.id]?.value?.perAccount[
+        me.id
+      ]?.value,
+    ).toBe("jam");
   });
 
   test("Subscription without options", async () => {
@@ -280,26 +307,38 @@ describe("CoFeed resolution", async () => {
       crypto: Crypto,
     });
 
-    const queue = new cojsonInternals.Channel();
+    const queue = new cojsonInternals.Channel<Loaded<typeof TestStream>>();
 
     TestStream.subscribe(stream.id, (subscribedStream) => {
       void queue.push(subscribedStream);
     });
 
     const update1 = (await queue.next()).value;
-    expect(update1[me.id]?.value).toEqual(null);
+    expect(update1.perAccount[me.id]?.value).toEqual(null);
 
     const update2 = (await queue.next()).value;
-    expect(update2[me.id]?.value?.[me.id]?.value).toEqual(null);
+    expect(update2.perAccount[me.id]?.value?.perAccount[me.id]?.value).toEqual(
+      null,
+    );
 
     const update3 = (await queue.next()).value;
-    expect(update3[me.id]?.value?.[me.id]?.value).toBeDefined();
-    expect(update3[me.id]?.value?.[me.id]?.value?.[me.id]?.value).toBe("milk");
+    expect(
+      update3.perAccount[me.id]?.value?.perAccount[me.id]?.value,
+    ).toBeDefined();
+    expect(
+      update3.perAccount[me.id]?.value?.perAccount[me.id]?.value?.perAccount[
+        me.id
+      ]?.value,
+    ).toBe("milk");
 
-    update3[me.id]!.value![me.id]!.value!.push("bread");
+    update3.perAccount[me.id]!.value!.perAccount[me.id]!.value!.push("bread");
 
     const update4 = (await queue.next()).value;
-    expect(update4[me.id]?.value?.[me.id]?.value?.[me.id]?.value).toBe("bread");
+    expect(
+      update4.perAccount[me.id]?.value?.perAccount[me.id]?.value?.perAccount[
+        me.id
+      ]?.value,
+    ).toBe("bread");
   });
 });
 
@@ -611,7 +650,7 @@ describe("FileStream progress tracking", async () => {
 
 describe("waitForSync", async () => {
   test("CoFeed: should resolve when the value is uploaded", async () => {
-    class TestStream extends CoFeed.Of(co.string) {}
+    const TestStream = co.feed(z.string());
 
     const { clientNode, serverNode, clientAccount } = await setupTwoNodes();