jazz-tools 0.19.11 → 0.19.13

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

@@ -7,10 +7,15 @@ import {
   Settled,
   coOptionalDefiner,
   unstable_mergeBranchWithResolve,
+  withSchemaPermissions,
 } from "../../../internal.js";
 import { AnonymousJazzAgent } from "../../anonymousJazzAgent.js";
 import { CoOptionalSchema } from "./CoOptionalSchema.js";
 import { CoreCoValueSchema } from "./CoValueSchema.js";
+import {
+  DEFAULT_SCHEMA_PERMISSIONS,
+  SchemaPermissions,
+} from "../schemaPermissions.js";
 
 export interface CorePlainTextSchema extends CoreCoValueSchema {
   builtin: "CoPlainText";
@@ -29,6 +34,12 @@ export class PlainTextSchema implements CorePlainTextSchema {
   readonly builtin = "CoPlainText" as const;
   readonly resolveQuery = true as const;
 
+  /**
+   * Permissions to be used when creating or composing CoValues
+   * @internal
+   */
+  permissions: SchemaPermissions = DEFAULT_SCHEMA_PERMISSIONS;
+
   constructor(private coValueClass: typeof CoPlainText) {}
 
   create(text: string, options?: { owner: Group } | Group): CoPlainText;
@@ -41,7 +52,11 @@ export class PlainTextSchema implements CorePlainTextSchema {
     text: string,
     options?: { owner: Account | Group } | Account | Group,
   ): CoPlainText {
-    return this.coValueClass.create(text, options);
+    const optionsWithPermissions = withSchemaPermissions(
+      options,
+      this.permissions,
+    );
+    return this.coValueClass.create(text, optionsWithPermissions);
   }
 
   load(
@@ -90,4 +105,13 @@ export class PlainTextSchema implements CorePlainTextSchema {
   optional(): CoOptionalSchema<this> {
     return coOptionalDefiner(this);
   }
+
+  /**
+   * Configure permissions to be used when creating or composing CoValues
+   */
+  withPermissions(permissions: SchemaPermissions): PlainTextSchema {
+    const copy = new PlainTextSchema(this.coValueClass);
+    copy.permissions = permissions;
+    return copy;
+  }
 }

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

@@ -6,10 +6,15 @@ import {
   Settled,
   coOptionalDefiner,
   unstable_mergeBranchWithResolve,
+  withSchemaPermissions,
 } from "../../../internal.js";
 import { AnonymousJazzAgent } from "../../anonymousJazzAgent.js";
 import { CoOptionalSchema } from "./CoOptionalSchema.js";
 import { CoreCoValueSchema } from "./CoValueSchema.js";
+import {
+  DEFAULT_SCHEMA_PERMISSIONS,
+  SchemaPermissions,
+} from "../schemaPermissions.js";
 
 export interface CoreRichTextSchema extends CoreCoValueSchema {
   builtin: "CoRichText";
@@ -28,6 +33,8 @@ export class RichTextSchema implements CoreRichTextSchema {
   readonly builtin = "CoRichText" as const;
   readonly resolveQuery = true as const;
 
+  permissions: SchemaPermissions = DEFAULT_SCHEMA_PERMISSIONS;
+
   constructor(private coValueClass: typeof CoRichText) {}
 
   create(text: string, options?: { owner: Group } | Group): CoRichText;
@@ -40,7 +47,11 @@ export class RichTextSchema implements CoreRichTextSchema {
     text: string,
     options?: { owner: Account | Group } | Account | Group,
   ): CoRichText {
-    return this.coValueClass.create(text, options);
+    const optionsWithPermissions = withSchemaPermissions(
+      options,
+      this.permissions,
+    );
+    return this.coValueClass.create(text, optionsWithPermissions);
   }
 
   load(
@@ -85,4 +96,13 @@ export class RichTextSchema implements CoreRichTextSchema {
   optional(): CoOptionalSchema<this> {
     return coOptionalDefiner(this);
   }
+
+  /**
+   * Configure permissions to be used when creating or composing CoValues
+   */
+  withPermissions(permissions: SchemaPermissions): RichTextSchema {
+    const copy = new RichTextSchema(this.coValueClass);
+    copy.permissions = permissions;
+    return copy;
+  }
 }

package/src/tools/implementation/zodSchema/unionUtils.ts

@@ -1,3 +1,4 @@
+import { JsonValue, RawCoMap } from "cojson";
 import {
   AnyZodOrCoValueSchema,
   CoDiscriminatedUnionSchema,
@@ -37,25 +38,7 @@ export function schemaUnionDiscriminatorFor(
       }
     }
 
-    const availableOptions: DiscriminableCoreCoValueSchema[] = [];
-
-    for (const option of options) {
-      if (option.builtin === "CoMap") {
-        availableOptions.push(option);
-      } else if (option.builtin === "CoDiscriminatedUnion") {
-        for (const subOption of (
-          option as CoDiscriminatedUnionSchema<any>
-        ).getDefinition().options) {
-          if (!options.includes(subOption)) {
-            options.push(subOption);
-          }
-        }
-      } else {
-        throw new Error(
-          "Unsupported zod type in co.discriminatedUnion() of collaborative types",
-        );
-      }
-    }
+    const availableOptions = getFlattenedUnionOptions(schema);
 
     const determineSchema: SchemaUnionDiscriminator<CoMap> = (
       discriminable,
@@ -77,7 +60,10 @@ export function schemaUnionDiscriminatorFor(
 
         for (const key of Object.keys(discriminatorMap)) {
           const discriminatorDef = optionDef.shape[key];
-          const discriminatorValue = discriminable.get(key);
+          const discriminatorValue = resolveDiscriminantValue(
+            discriminable,
+            key,
+          );
 
           if (discriminatorValue && typeof discriminatorValue === "object") {
             throw new Error("Discriminator must be a primitive value");
@@ -175,3 +161,69 @@ function isCoDiscriminatedUnion(
 ): def is CoreCoDiscriminatedUnionSchema<any> {
   return def.builtin === "CoDiscriminatedUnion";
 }
+
+/**
+ * Flattens all options from a discriminated union schema, including nested unions.
+ * Returns all options in a flat array.
+ */
+export function getFlattenedUnionOptions(
+  schema: CoreCoDiscriminatedUnionSchema<DiscriminableCoValueSchemas>,
+): DiscriminableCoreCoValueSchema[] {
+  const definition = schema.getDefinition();
+  const options = definition.options;
+  const availableOptions: DiscriminableCoreCoValueSchema[] = [];
+
+  for (const option of options) {
+    if (option.builtin === "CoMap") {
+      availableOptions.push(option);
+    } else if (option.builtin === "CoDiscriminatedUnion") {
+      const nestedOptions = getFlattenedUnionOptions(
+        option as CoreCoDiscriminatedUnionSchema<DiscriminableCoValueSchemas>,
+      );
+      for (const subOption of nestedOptions) {
+        if (!availableOptions.includes(subOption)) {
+          availableOptions.push(subOption);
+        }
+      }
+    } else {
+      throw new Error(
+        "Unsupported zod type in co.discriminatedUnion() of collaborative types",
+      );
+    }
+  }
+
+  return availableOptions;
+}
+
+/**
+ * Gets the discriminator values for a given option and discriminator key
+ */
+export function getDiscriminatorValuesForOption(
+  option: DiscriminableCoreCoValueSchema,
+  discriminatorKey: string,
+): Set<unknown> | undefined {
+  const optionDefinition = option.getDefinition();
+  return optionDefinition.discriminatorMap?.[discriminatorKey];
+}
+
+export function resolveDiscriminantValue(
+  init: unknown,
+  discriminatorKey: string,
+): JsonValue | undefined {
+  if (init == null) {
+    return undefined;
+  }
+
+  if (init instanceof Map || init instanceof RawCoMap) {
+    return init.get(discriminatorKey);
+  }
+
+  if (typeof init === "object") {
+    const record = init as Record<string, JsonValue>;
+    if (discriminatorKey in record) {
+      return record[discriminatorKey];
+    }
+  }
+
+  return undefined;
+}

package/src/tools/internal.ts

@@ -53,6 +53,7 @@ export * from "./implementation/zodSchema/typeConverters/InstanceOfSchemaCoValue
 export * from "./implementation/zodSchema/typeConverters/CoFieldSchemaInit.js";
 export * from "./implementation/zodSchema/runtimeConverters/coValueSchemaTransformation.js";
 export * from "./implementation/zodSchema/runtimeConverters/schemaFieldToCoFieldDef.js";
+export * from "./implementation/zodSchema/schemaPermissions.js";
 export * from "./coValues/extensions/imageDef.js";
 
 export * from "./implementation/ContextManager.js";

package/src/tools/subscribe/SubscriptionScope.ts

@@ -309,64 +309,86 @@ export class SubscriptionScope<D extends CoValue> {
 
   unloadedValue: NotLoaded<D> | undefined;
 
-  lastPromise:
-    | {
-        value: MaybeLoaded<D> | undefined;
-        promise: PromiseWithStatus<MaybeLoaded<D>>;
-      }
-    | undefined;
-
-  cachePromise(value: MaybeLoaded<D>, callback: () => PromiseWithStatus<D>) {
-    if (this.lastPromise?.value === value) {
-      return this.lastPromise.promise;
-    }
-
-    const promise = callback();
-    this.lastPromise = { value, promise };
-
-    return promise;
-  }
+  lastPromise: PromiseWithStatus<D> | undefined;
 
   getPromise() {
     const currentValue = this.getCurrentValue();
 
     if (currentValue.$isLoaded) {
-      return resolvedPromise(currentValue);
+      return resolvedPromise<D>(currentValue);
     }
 
     if (currentValue.$jazz.loadingState !== CoValueLoadingState.LOADING) {
       const error = this.getError();
-      return rejectedPromise(
+      return rejectedPromise<D>(
         new Error(error?.toString() ?? "Unknown error", {
           cause: this.callerStack,
         }),
       );
     }
 
-    // We need to cache rejected promises to make React Suspense happy
-    return this.cachePromise(currentValue, () => {
-      return new Promise<D>((resolve, reject) => {
-        const unsubscribe = this.subscribe(() => {
-          const currentValue = this.getCurrentValue();
+    const promise = new Promise<D>((resolve, reject) => {
+      const unsubscribe = this.subscribe(() => {
+        const currentValue = this.getCurrentValue();
 
-          if (currentValue.$jazz.loadingState === CoValueLoadingState.LOADING) {
-            return;
-          }
+        if (currentValue.$jazz.loadingState === CoValueLoadingState.LOADING) {
+          return;
+        }
 
-          if (currentValue.$isLoaded) {
-            resolve(currentValue);
-          } else {
-            reject(
-              new Error(this.getError()?.toString() ?? "Unknown error", {
-                cause: this.callerStack,
-              }),
-            );
-          }
+        if (currentValue.$isLoaded) {
+          promise.status = "fulfilled";
+          promise.value = currentValue;
+          resolve(currentValue);
+        } else {
+          promise.status = "rejected";
+          promise.reason = new Error(
+            this.getError()?.toString() ?? "Unknown error",
+            {
+              cause: this.callerStack,
+            },
+          );
+          reject(
+            new Error(this.getError()?.toString() ?? "Unknown error", {
+              cause: this.callerStack,
+            }),
+          );
+        }
 
-          unsubscribe();
-        });
+        unsubscribe();
       });
-    });
+    }) as PromiseWithStatus<D>;
+
+    promise.status = "pending";
+
+    return promise;
+  }
+
+  getCachedPromise() {
+    if (this.lastPromise) {
+      const value = this.getCurrentValue();
+
+      // if the value is loaded, we update the promise state
+      // to ensure that the value provided is always up to date
+      if (value.$isLoaded) {
+        this.lastPromise.status = "fulfilled";
+        this.lastPromise.value = value;
+      } else if (value.$jazz.loadingState !== CoValueLoadingState.LOADING) {
+        this.lastPromise.status = "rejected";
+        this.lastPromise.reason = new Error(
+          this.getError()?.toString() ?? "Unknown error",
+          {
+            cause: this.callerStack,
+          },
+        );
+      } else if (this.lastPromise.status !== "pending") {
+        // Value got into loading state, we need to suspend again
+        this.lastPromise = this.getPromise();
+      }
+    } else {
+      this.lastPromise = this.getPromise();
+    }
+
+    return this.lastPromise;
   }
 
   private getUnloadedValue(reason: NotLoadedCoValueState): NotLoaded<D> {

package/src/tools/testing.ts

@@ -16,9 +16,11 @@ import {
   coValueClassFromCoValueClassOrSchema,
   createAnonymousJazzContext,
   createJazzContext,
-  randomSessionProvider,
+  MockSessionProvider,
 } from "./internal.js";
 
+const randomSessionProvider = new MockSessionProvider();
+
 export { assertLoaded } from "./lib/utils.js";
 
 const syncServer: { current: LocalNode | null; asyncPeers: boolean } = {

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

@@ -19,7 +19,7 @@ import {
 } from "../implementation/ContextManager";
 import {
   createJazzContext,
-  randomSessionProvider,
+  MockSessionProvider,
 } from "../implementation/createContext";
 import {
   CoValueFromRaw,
@@ -37,6 +37,7 @@ import { SubscriptionCache } from "../subscribe/SubscriptionCache";
 import { createAsyncStorage, getDbPath } from "./testStorage";
 
 const Crypto = await WasmCrypto.create();
+const randomSessionProvider = new MockSessionProvider();
 
 class TestJazzContextManager<Acc extends Account> extends JazzContextManager<
   Acc,

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

@@ -7,10 +7,10 @@ import {
   createJazzContextFromExistingCredentials,
   isControlledAccount,
 } from "../index.js";
-import { co, randomSessionProvider } from "../internal.js";
+import { co, MockSessionProvider } from "../internal.js";
 
 const Crypto = await WasmCrypto.create();
-
+const randomSessionProvider = new MockSessionProvider();
 const connectedPeers = cojsonInternals.connectedPeers;
 
 describe("CoPlainText", () => {

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",
+    });
+  });
 });