jazz-tools 0.18.6 → 0.18.8

package/src/react-core/tests/useCoStateWithSelector.test.ts

@@ -0,0 +1,149 @@
+// @vitest-environment happy-dom
+
+import { cojsonInternals } from "cojson";
+import { Account, co, Loaded, z } from "jazz-tools";
+import { beforeEach, describe, expect, expectTypeOf, it } from "vitest";
+import { useCoStateWithSelector } from "../index.js";
+import { createJazzTestAccount, setupJazzTestSync } from "../testing.js";
+import { renderHook, waitFor } from "./testUtils.js";
+import { useRef } from "react";
+
+beforeEach(async () => {
+  await setupJazzTestSync();
+
+  await createJazzTestAccount({
+    isCurrentActiveAccount: true,
+  });
+});
+
+cojsonInternals.setCoValueLoadingRetryDelay(300);
+
+const useRenderCount = <T>(hook: () => T) => {
+  const renderCountRef = useRef(0);
+  const result = hook();
+  renderCountRef.current = renderCountRef.current + 1;
+  return {
+    renderCount: renderCountRef.current,
+    result,
+  };
+};
+
+describe("useCoStateWithSelector", () => {
+  it("should not re-render when a nested coValue is updated and not selected", async () => {
+    const TestMap = co.map({
+      value: z.string(),
+      get nested() {
+        return TestMap.optional();
+      },
+    });
+
+    const map = TestMap.create({
+      value: "1",
+      nested: TestMap.create({
+        value: "1",
+      }),
+    });
+
+    const { result } = renderHook(() =>
+      useRenderCount(() =>
+        useCoStateWithSelector(TestMap, map.$jazz.id, {
+          resolve: {
+            nested: true,
+          },
+          select: (v) => v?.value,
+        }),
+      ),
+    );
+
+    await waitFor(() => {
+      expect(result.current.result).not.toBeUndefined();
+    });
+
+    for (let i = 0; i < 100; i++) {
+      map.nested!.$jazz.set("value", `${i}`);
+      await Account.getMe().$jazz.waitForAllCoValuesSync();
+    }
+
+    expect(result.current.result).toEqual("1");
+    expect(result.current.renderCount).toEqual(1);
+  });
+
+  it("should re-render when a nested coValue is updated and selected", async () => {
+    const TestMap = co.map({
+      value: z.string(),
+      get nested() {
+        return TestMap.optional();
+      },
+    });
+
+    const map = TestMap.create({
+      value: "1",
+      nested: TestMap.create({
+        value: "1",
+      }),
+    });
+
+    const { result } = renderHook(() =>
+      useRenderCount(() =>
+        useCoStateWithSelector(TestMap, map.$jazz.id, {
+          resolve: {
+            nested: true,
+          },
+          select: (v) => v?.nested?.value,
+        }),
+      ),
+    );
+
+    await waitFor(() => {
+      expect(result.current.result).not.toBeUndefined();
+    });
+
+    for (let i = 1; i <= 100; i++) {
+      map.nested!.$jazz.set("value", `${i}`);
+      await Account.getMe().$jazz.waitForAllCoValuesSync();
+    }
+
+    expect(result.current.result).toEqual("100");
+
+    // skips re-render on i = 1, only re-renders on i = [2,100], so initial render + 99 renders = 100
+    expect(result.current.renderCount).toEqual(100);
+
+    expectTypeOf(result.current.result).toEqualTypeOf<string | undefined>();
+  });
+
+  it("should not re-render when equalityFn always returns true", async () => {
+    const TestMap = co.map({
+      value: z.string(),
+      get nested() {
+        return TestMap.optional();
+      },
+    });
+
+    const map = TestMap.create({
+      value: "1",
+      nested: TestMap.create({
+        value: "1",
+      }),
+    });
+
+    const { result } = renderHook(() =>
+      useRenderCount(() =>
+        useCoStateWithSelector(TestMap, map.$jazz.id, {
+          resolve: {
+            nested: true,
+          },
+          select: (v) => v?.nested?.value,
+          equalityFn: () => true,
+        }),
+      ),
+    );
+
+    for (let i = 1; i <= 100; i++) {
+      map.nested!.$jazz.set("value", `${i}`);
+      await Account.getMe().$jazz.waitForAllCoValuesSync();
+    }
+
+    expect(result.current.result).toEqual("1");
+    expect(result.current.renderCount).toEqual(1);
+  });
+});

package/src/react-native-core/hooks.tsx

@@ -13,6 +13,7 @@ export {
   useAuthSecretStorage,
   useIsAuthenticated,
   useAccount,
+  useCoStateWithSelector,
 } from "jazz-tools/react-core";
 
 export function useAcceptInviteNative<S extends CoValueClassOrSchema>({

package/src/tools/coValues/CoFieldInit.ts

@@ -1,8 +1,8 @@
-import { CoFeed } from "./coFeed";
-import { CoList } from "./coList";
-import { CoMap, CoMapInit } from "./coMap";
-import { CoPlainText } from "./coPlainText";
-import { CoRichText } from "./coRichText";
+import { CoFeed } from "./coFeed.js";
+import { CoList } from "./coList.js";
+import { CoMap, CoMapInit } from "./coMap.js";
+import { CoPlainText } from "./coPlainText.js";
+import { CoRichText } from "./coRichText.js";
 
 /**
  * Returns the type of values that can be used to initialize a field of the provided type.

package/src/tools/coValues/CoValueBase.ts

@@ -77,4 +77,36 @@ export abstract class CoValueJazzApi<V extends CoValue> {
 
     return new AnonymousJazzAgent(this.localNode);
   }
+
+  /**
+   * The timestamp of the creation time of the CoValue
+   *
+   * @category Content
+   */
+  get createdAt(): number {
+    const createdAt = this.raw.core.verified.header.meta?.createdAt;
+
+    if (typeof createdAt === "string") {
+      return new Date(createdAt).getTime();
+    }
+
+    return this.raw.core.earliestTxMadeAt;
+  }
+
+  /**
+   * The timestamp of the last updated time of the CoValue
+   *
+   * Returns the creation time if there are no updates.
+   *
+   * @category Content
+   */
+  get lastUpdatedAt(): number {
+    const value = this.raw.core.latestTxMadeAt;
+
+    if (value === 0) {
+      return this.createdAt;
+    }
+
+    return value;
+  }
 }

package/src/tools/coValues/coList.ts

@@ -971,4 +971,39 @@ const CoListProxyHandler: ProxyHandler<CoList> = {
       return Reflect.has(target, key);
     }
   },
+  ownKeys(target) {
+    const keys = Reflect.ownKeys(target);
+    // Add numeric indices for all entries in the list
+    const indexKeys = target.$jazz.raw.entries().map((_entry, i) => String(i));
+    keys.push(...indexKeys);
+    return keys;
+  },
+  getOwnPropertyDescriptor(target, key) {
+    if (key === TypeSym) {
+      // Make TypeSym non-enumerable so it doesn't show up in Object.keys()
+      return {
+        enumerable: false,
+        configurable: true,
+        writable: false,
+        value: target[TypeSym],
+      };
+    } else if (key in target) {
+      return Reflect.getOwnPropertyDescriptor(target, key);
+    } else if (typeof key === "string" && !isNaN(+key)) {
+      const index = Number(key);
+      if (index >= 0 && index < target.$jazz.raw.entries().length) {
+        return {
+          enumerable: true,
+          configurable: true,
+          writable: true,
+        };
+      }
+    } else if (key === "length") {
+      return {
+        enumerable: false,
+        configurable: false,
+        writable: false,
+      };
+    }
+  },
 };

package/src/tools/coValues/coMap.ts

@@ -836,24 +836,6 @@ class CoMapJazzApi<M extends CoMap> extends CoValueJazzApi<M> {
     return this.getRaw();
   }
 
-  /**
-   * The timestamp of the creation time of the CoMap
-   *
-   * @category Content
-   */
-  get createdAt(): number {
-    return this.raw.earliestTxMadeAt ?? Number.MAX_SAFE_INTEGER;
-  }
-
-  /**
-   * The timestamp of the last updated time of the CoMap
-   *
-   * @category Content
-   */
-  get lastUpdatedAt(): number {
-    return this.raw.latestTxMadeAt;
-  }
-
   /** @internal */
   get schema(): CoMapFieldSchema {
     return (this.coMap.constructor as typeof CoMap)._schema;

package/src/tools/implementation/createContext.ts

@@ -96,6 +96,7 @@ export async function createJazzContextFromExistingCredentials<
   AccountSchema: PropsAccountSchema,
   sessionProvider,
   onLogOut,
+  asActiveAccount,
 }: {
   credentials: Credentials;
   peersToLoadFrom: Peer[];
@@ -104,6 +105,7 @@ export async function createJazzContextFromExistingCredentials<
   sessionProvider: SessionProvider;
   onLogOut?: () => void;
   storage?: StorageAPI;
+  asActiveAccount: boolean;
 }): Promise<JazzContextWithAccount<InstanceOfSchema<S>>> {
   const { sessionID, sessionDone } = await sessionProvider(
     credentials.accountID,
@@ -125,14 +127,18 @@ export async function createJazzContextFromExistingCredentials<
     storage,
     migration: async (rawAccount, _node, creationProps) => {
       const account = AccountClass.fromRaw(rawAccount) as InstanceOfSchema<S>;
-      activeAccountContext.set(account);
+      if (asActiveAccount) {
+        activeAccountContext.set(account);
+      }
 
       await account.applyMigration(creationProps);
     },
   });
 
   const account = AccountClass.fromNode(node);
-  activeAccountContext.set(account);
+  if (asActiveAccount) {
+    activeAccountContext.set(account);
+  }
 
   return {
     node,
@@ -245,6 +251,7 @@ export async function createJazzContext<
         authSecretStorage.clearWithoutNotify();
       },
       storage: options.storage,
+      asActiveAccount: true,
     });
   } else {
     const secretSeed = options.crypto.newRandomSecretSeed();

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

@@ -180,7 +180,9 @@ export interface CoMapSchema<
    *
    * @returns A new CoMap schema with all fields optional.
    */
-  partial(): CoMapSchema<PartialShape<Shape>, CatchAll, Owner>;
+  partial<Keys extends keyof Shape = keyof Shape>(
+    keys?: { [key in Keys]: true },
+  ): CoMapSchema<PartialShape<Shape, Keys>, CatchAll, Owner>;
 }
 
 export function createCoreCoMapSchema<
@@ -281,10 +283,17 @@ export function enrichCoMapSchema<
 
       return coMapDefiner(pickedShape);
     },
-    partial: () => {
+    partial: <Keys extends keyof Shape = keyof Shape>(
+      keys?: { [key in Keys]: true },
+    ) => {
       const partialShape: Record<string, AnyZodOrCoValueSchema> = {};
 
       for (const [key, value] of Object.entries(coValueSchema.shape)) {
+        if (keys && !keys[key as Keys]) {
+          partialShape[key] = value;
+          continue;
+        }
+
         if (isAnyCoValueSchema(value)) {
           partialShape[key] = coOptionalDefiner(value);
         } else {
@@ -341,10 +350,15 @@ export type CoMapInstanceCoValuesNullable<Shape extends z.core.$ZodLooseShape> =
     >;
   };
 
-export type PartialShape<Shape extends z.core.$ZodLooseShape> = Simplify<{
-  -readonly [key in keyof Shape]: Shape[key] extends AnyZodSchema
-    ? z.ZodOptional<Shape[key]>
-    : Shape[key] extends CoreCoValueSchema
-      ? CoOptionalSchema<Shape[key]>
-      : never;
+export type PartialShape<
+  Shape extends z.core.$ZodLooseShape,
+  PartialKeys extends keyof Shape = keyof Shape,
+> = Simplify<{
+  -readonly [key in keyof Shape]: key extends PartialKeys
+    ? Shape[key] extends AnyZodSchema
+      ? z.ZodOptional<Shape[key]>
+      : Shape[key] extends CoreCoValueSchema
+        ? CoOptionalSchema<Shape[key]>
+        : never
+    : Shape[key];
 }>;

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

@@ -122,6 +122,25 @@ describe("Simple CoList operations", async () => {
     expect(list[0]).toEqual("milk");
   });
 
+  test("CoList keys can be iterated over just like an array's", () => {
+    const TestList = co.list(z.string());
+    const list = ["a", "b", "c", "d", "e"];
+    const coList = TestList.create(list);
+    const keys = [];
+    for (const key in coList) {
+      keys.push(key);
+    }
+    expect(keys).toEqual(Object.keys(list));
+    expect(Object.keys(coList)).toEqual(Object.keys(list));
+  });
+
+  test("a CoList is structurally equal to an array", () => {
+    const TestList = co.list(z.string());
+    const list = ["a", "b", "c", "d", "e"];
+    const coList = TestList.create(list);
+    expect(coList).toEqual(list);
+  });
+
   describe("Mutation", () => {
     test("assignment", () => {
       const list = TestList.create(["bread", "butter", "onion"], {
@@ -1314,3 +1333,25 @@ describe("co.list schema", () => {
     expect(keywords[1]?.toString()).toEqual("world");
   });
 });
+
+describe("lastUpdatedAt", () => {
+  test("empty list last updated time", () => {
+    const emptyList = co.list(z.number()).create([]);
+
+    expect(emptyList.$jazz.lastUpdatedAt).not.toEqual(0);
+    expect(emptyList.$jazz.lastUpdatedAt).toEqual(emptyList.$jazz.createdAt);
+  });
+
+  test("last update should change on push", async () => {
+    const list = co.list(z.string()).create(["John"]);
+
+    expect(list.$jazz.lastUpdatedAt).not.toEqual(0);
+
+    const updatedAt = list.$jazz.lastUpdatedAt;
+
+    await new Promise((r) => setTimeout(r, 10));
+    list.$jazz.push("Jane");
+
+    expect(list.$jazz.lastUpdatedAt).not.toEqual(updatedAt);
+  });
+});

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

@@ -2646,6 +2646,43 @@ describe("co.map schema", () => {
       expect(draftPerson.pet).toEqual(rex);
     });
 
+    test("creates a new CoMap schema by making some properties optional", () => {
+      const Dog = co.map({
+        name: z.string(),
+        breed: z.string(),
+      });
+      const Person = co.map({
+        name: z.string(),
+        age: z.number(),
+        pet: Dog,
+      });
+
+      const DraftPerson = Person.partial({
+        pet: true,
+      });
+
+      const draftPerson = DraftPerson.create({
+        name: "John",
+        age: 20,
+      });
+
+      expect(draftPerson.$jazz.has("pet")).toBe(false);
+
+      const rex = Dog.create({ name: "Rex", breed: "Labrador" });
+      draftPerson.$jazz.set("pet", rex);
+
+      expect(draftPerson.pet).toEqual(rex);
+
+      expect(draftPerson.$jazz.has("pet")).toBe(true);
+
+      draftPerson.$jazz.delete("pet");
+
+      expect(draftPerson.$jazz.has("pet")).toBe(false);
+
+      // @ts-expect-error - should not allow deleting required properties
+      draftPerson.$jazz.delete("age");
+    });
+
     test("the new schema includes catchall properties", () => {
       const Person = co
         .map({

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

@@ -183,6 +183,7 @@ describe("CoPlainText", () => {
           sessionProvider: randomSessionProvider,
           peersToLoadFrom: [initialAsPeer],
           crypto: Crypto,
+          asActiveAccount: true,
         });
 
       // Load the text on the second peer
@@ -214,6 +215,7 @@ describe("CoPlainText", () => {
         sessionProvider: randomSessionProvider,
         peersToLoadFrom: [initialAsPeer],
         crypto: Crypto,
+        asActiveAccount: true,
       });
 
     const queue = new Channel();
@@ -242,3 +244,25 @@ describe("CoPlainText", () => {
     expect(update3.toString()).toBe("hello world");
   });
 });
+
+describe("lastUpdatedAt", () => {
+  test("empty text last updated time", () => {
+    const text = co.plainText().create("");
+
+    expect(text.$jazz.lastUpdatedAt).toEqual(text.$jazz.createdAt);
+    expect(text.$jazz.lastUpdatedAt).not.toEqual(0);
+  });
+
+  test("last update should change on push", async () => {
+    const text = co.plainText().create("John");
+
+    expect(text.$jazz.lastUpdatedAt).not.toEqual(0);
+
+    const updatedAt = text.$jazz.lastUpdatedAt;
+
+    await new Promise((r) => setTimeout(r, 10));
+    text.$jazz.applyDiff("Jane");
+
+    expect(text.$jazz.lastUpdatedAt).not.toEqual(updatedAt);
+  });
+});

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

@@ -54,6 +54,7 @@ describe("createContext methods", () => {
         peersToLoadFrom: [getPeerConnectedToTestSyncServer()],
         crypto: Crypto,
         sessionProvider: randomSessionProvider,
+        asActiveAccount: true,
       });
 
       expect(context.node).toBeDefined();
@@ -86,6 +87,7 @@ describe("createContext methods", () => {
         crypto: Crypto,
         AccountSchema: CustomAccount,
         sessionProvider: randomSessionProvider,
+        asActiveAccount: true,
       });
 
       expect(context.account).toBeInstanceOf(
@@ -109,6 +111,7 @@ describe("createContext methods", () => {
         crypto: Crypto,
         sessionProvider: randomSessionProvider,
         onLogOut,
+        asActiveAccount: true,
       });
 
       context.logOut();
@@ -131,6 +134,7 @@ describe("createContext methods", () => {
         peersToLoadFrom: [getPeerConnectedToTestSyncServer()],
         crypto: Crypto,
         sessionProvider: randomSessionProvider,
+        asActiveAccount: true,
       });
 
       const loadedMap = await loadCoValueOrFail(context.node, coMap.id);
@@ -151,10 +155,30 @@ describe("createContext methods", () => {
         peersToLoadFrom: [getPeerConnectedToTestSyncServer()],
         crypto: Crypto,
         sessionProvider: randomSessionProvider,
+        asActiveAccount: true,
       });
 
       expect(activeAccountContext.get()).toBe(context.account);
     });
+
+    test("does not set the active account when asActiveAccount is false", async () => {
+      const account = await createJazzTestAccount({
+        isCurrentActiveAccount: false,
+      });
+
+      const context = await createJazzContextFromExistingCredentials({
+        credentials: {
+          accountID: account.$jazz.id,
+          secret: account.$jazz.localNode.getCurrentAgent().agentSecret,
+        },
+        peersToLoadFrom: [getPeerConnectedToTestSyncServer()],
+        crypto: Crypto,
+        sessionProvider: randomSessionProvider,
+        asActiveAccount: false,
+      });
+
+      expect(activeAccountContext.get()).not.toBe(context.account);
+    });
   });
 
   describe("createJazzContextForNewAccount", () => {

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

@@ -57,6 +57,7 @@ describe("Deep loading with depth arg", async () => {
       sessionProvider: randomSessionProvider,
       peersToLoadFrom: [initialAsPeer],
       crypto: Crypto,
+      asActiveAccount: true,
     });
 
   const ownership = { owner: me };
@@ -287,6 +288,7 @@ test("Deep loading a record-like coMap", async () => {
       sessionProvider: randomSessionProvider,
       peersToLoadFrom: [initialAsPeer],
       crypto: Crypto,
+      asActiveAccount: true,
     });
 
   const record = RecordLike.create(

package/src/tools/tests/patterns/requestToJoin.test.ts

@@ -1,6 +1,10 @@
 import { assert, describe, expect, test } from "vitest";
 import { Account, Group, co, z } from "../../exports";
-import { createJazzTestAccount, linkAccounts } from "../../testing";
+import {
+  createJazzTestAccount,
+  linkAccounts,
+  setupJazzTestSync,
+} from "../../testing";
 
 const RequestToJoin = co.map({
   account: Account,
@@ -24,16 +28,20 @@ const Organization = co.map({
 });
 
 async function setup() {
+  await setupJazzTestSync();
+
   const admin1 = await createJazzTestAccount();
   const admin2 = await createJazzTestAccount();
   const user1 = await createJazzTestAccount();
   const user2 = await createJazzTestAccount();
 
-  await linkAccounts(admin1, admin2);
-  await linkAccounts(admin1, user1);
-  await linkAccounts(admin1, user2);
-  await linkAccounts(admin2, user1);
-  await linkAccounts(admin2, user2);
+  // TODO: with this setting the waitForAllCoValuesSync gets stuck
+  // https://github.com/garden-co/jazz/issues/2874
+  // await linkAccounts(admin1, admin2);
+  // await linkAccounts(admin1, user1);
+  // await linkAccounts(admin1, user2);
+  // await linkAccounts(admin2, user1);
+  // await linkAccounts(admin2, user2);
 
   // The organization info are public
   const adminsGroup = Group.create(admin1);

package/src/tools/tests/utils.ts

@@ -40,6 +40,7 @@ export async function setupAccount() {
       sessionProvider: randomSessionProvider,
       peersToLoadFrom: [initialAsPeer],
       crypto: Crypto,
+      asActiveAccount: true,
     });
 
   return { me, meOnSecondPeer };

package/src/worker/index.ts

@@ -31,6 +31,10 @@ type WorkerOptions<
    * If true, the inbox will not be loaded.
    */
   skipInboxLoad?: boolean;
+  /**
+   * If false, the worker will not set in the global account context
+   */
+  asActiveAccount?: boolean;
 };
 
 /** @category Context Creation */
@@ -45,6 +49,7 @@ export async function startWorker<
     syncServer = "wss://cloud.jazz.tools",
     AccountSchema = Account as unknown as S,
     skipInboxLoad = false,
+    asActiveAccount = true,
   } = options;
 
   let node: LocalNode | undefined = undefined;
@@ -90,6 +95,7 @@ export async function startWorker<
     sessionProvider: randomSessionProvider,
     peersToLoadFrom,
     crypto: options.crypto ?? (await WasmCrypto.create()),
+    asActiveAccount,
   });
 
   const account = context.account as InstanceOfSchema<S>;