jazz-tools 0.18.6 → 0.18.7

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