jazz-tools 0.19.12 → 0.19.13

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

@@ -15,7 +15,7 @@ import {
   createJazzContext,
   createJazzContextForNewAccount,
   createJazzContextFromExistingCredentials,
-  randomSessionProvider,
+  MockSessionProvider,
 } from "../exports";
 import { activeAccountContext } from "../implementation/activeAccountContext";
 import {
@@ -26,6 +26,7 @@ import {
 import { assertLoaded, loadCoValueOrFail } from "./utils";
 const Crypto = await WasmCrypto.create();
 
+let randomSessionProvider = new MockSessionProvider();
 KvStoreContext.getInstance().initialize(new InMemoryKVStore());
 
 describe("createContext methods", () => {
@@ -35,6 +36,9 @@ describe("createContext methods", () => {
     authSecretStorage = new AuthSecretStorage();
     authSecretStorage.clear();
     await setupJazzTestSync();
+    randomSessionProvider = new MockSessionProvider();
+    vi.spyOn(randomSessionProvider, "acquireSession");
+    vi.spyOn(randomSessionProvider, "persistSession");
   });
 
   describe("createJazzContextFromExistingCredentials", () => {
@@ -49,6 +53,13 @@ describe("createContext methods", () => {
         secret: account.$jazz.localNode.getCurrentAgent().agentSecret,
       };
 
+      const sessionID = Crypto.newRandomSessionID(account.$jazz.raw.id);
+
+      vi.spyOn(randomSessionProvider, "acquireSession").mockResolvedValue({
+        sessionID: sessionID,
+        sessionDone: () => {},
+      });
+
       const context = await createJazzContextFromExistingCredentials({
         credentials,
         peers: [getPeerConnectedToTestSyncServer()],
@@ -60,10 +71,47 @@ describe("createContext methods", () => {
       expect(context.node).toBeDefined();
       expect(context.account).toBeDefined();
       expect(context.account.$jazz.id).toBe(credentials.accountID);
+      expect(context.node.currentSessionID).toBe(sessionID);
       expect(typeof context.done).toBe("function");
       expect(typeof context.logOut).toBe("function");
     });
 
+    test("releasese the session when the context is done", async () => {
+      const spy = vi.fn();
+
+      // Create an account first to get valid credentials
+      const account = await createJazzTestAccount({
+        isCurrentActiveAccount: true,
+      });
+
+      const credentials: Credentials = {
+        accountID: account.$jazz.id,
+        secret: account.$jazz.localNode.getCurrentAgent().agentSecret,
+      };
+
+      const sessionID = Crypto.newRandomSessionID(account.$jazz.raw.id);
+
+      vi.spyOn(randomSessionProvider, "acquireSession").mockResolvedValue({
+        sessionID: sessionID,
+        sessionDone: spy,
+      });
+
+      const context = await createJazzContextFromExistingCredentials({
+        credentials,
+        peers: [getPeerConnectedToTestSyncServer()],
+        crypto: Crypto,
+        sessionProvider: randomSessionProvider,
+        asActiveAccount: true,
+      });
+
+      expect(randomSessionProvider.acquireSession).toHaveBeenCalled();
+      expect(spy).not.toHaveBeenCalled();
+
+      context.done();
+
+      expect(spy).toHaveBeenCalled();
+    });
+
     test("handles custom account schema", async () => {
       const CustomAccount = co
         .account({
@@ -187,6 +235,7 @@ describe("createContext methods", () => {
         creationProps: { name: "New User" },
         peers: [],
         crypto: Crypto,
+        sessionProvider: randomSessionProvider,
       });
 
       expect(context.account).toBeDefined();
@@ -202,11 +251,38 @@ describe("createContext methods", () => {
         initialAgentSecret: initialSecret,
         peers: [],
         crypto: Crypto,
+        sessionProvider: randomSessionProvider,
       });
 
+      expect(randomSessionProvider.persistSession).toHaveBeenCalledWith(
+        context.account.$jazz.id,
+        context.node.currentSessionID,
+      );
+      expect(randomSessionProvider.acquireSession).not.toHaveBeenCalled();
       expect(context.node.getCurrentAgent().agentSecret).toBe(initialSecret);
     });
 
+    test("releasese the session when the context is done", async () => {
+      const spy = vi.fn();
+      vi.spyOn(randomSessionProvider, "persistSession").mockResolvedValue({
+        sessionDone: spy,
+      });
+
+      const context = await createJazzContextForNewAccount({
+        creationProps: { name: "New User" },
+        peers: [],
+        crypto: Crypto,
+        sessionProvider: randomSessionProvider,
+      });
+
+      expect(randomSessionProvider.persistSession).toHaveBeenCalled();
+      expect(spy).not.toHaveBeenCalled();
+
+      context.done();
+
+      expect(spy).toHaveBeenCalled();
+    });
+
     test("handles custom account schema", async () => {
       const CustomAccount = co
         .account({
@@ -220,6 +296,7 @@ describe("createContext methods", () => {
         peers: [],
         crypto: Crypto,
         AccountSchema: CustomAccount,
+        sessionProvider: randomSessionProvider,
       });
 
       expect(context.account).toBeInstanceOf(
@@ -232,6 +309,7 @@ describe("createContext methods", () => {
         creationProps: { name: "New User" },
         peers: [],
         crypto: Crypto,
+        sessionProvider: randomSessionProvider,
       });
       expect(activeAccountContext.get()).toBe(context.account);
     });

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

@@ -23,7 +23,7 @@ import {
   MaybeLoaded,
   Settled,
   co,
-  randomSessionProvider,
+  MockSessionProvider,
   CoValueLoadingState,
   CoValueErrorState,
 } from "../internal.js";
@@ -33,7 +33,7 @@ import { setCustomErrorReporter } from "../config.js";
 
 const Crypto = await WasmCrypto.create();
 const { connectedPeers } = cojsonInternals;
-
+const randomSessionProvider = new MockSessionProvider();
 const InnermostMap = co.map({
   value: z.string(),
 });
@@ -1192,6 +1192,29 @@ test("should not throw when calling ensureLoaded a record with a non-existent ke
   expect(loadedPerson.pet1).toBeUndefined();
 });
 
+test("should load a record with a non-existent key if there's a catch block", async () => {
+  const Person = co.record(
+    z.string(),
+    co.map({
+      name: z.string(),
+      breed: z.string(),
+    }),
+  );
+
+  const person = Person.create({});
+
+  const loadedPerson = await Person.load(person.$jazz.id, {
+    resolve: {
+      pet1: {
+        $onError: "catch",
+      },
+    },
+  });
+
+  assertLoaded(loadedPerson);
+  expect(loadedPerson.pet1).toBeUndefined();
+});
+
 // This was a regression that ocurred when we migrated `DeeplyLoaded` to use explicit loading states.
 // Keeping this test to prevent it from happening again.
 test("deep loaded CoList nested inside another CoValue can be iterated over", async () => {

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

@@ -796,4 +796,14 @@ describe("Schema.resolved()", () => {
       expect(loadedPerson.friends[0]?.friends.$isLoaded).toBe(false);
     });
   });
+
+  test("resolved() does not override previous schema configuration", () => {
+    const TestMap = co
+      .map({ name: co.plainText() })
+      .withPermissions({ onInlineCreate: "sameAsContainer" });
+    const TestMapWithName = TestMap.resolved({ name: true });
+    expect(TestMapWithName.permissions).toEqual({
+      onInlineCreate: "sameAsContainer",
+    });
+  });
 });