jazz-tools 0.19.12 → 0.19.14

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

@@ -3,6 +3,7 @@ import {
   BranchDefinition,
   CoList,
   Group,
+  hydrateCoreCoValueSchema,
   ID,
   Settled,
   RefsToResolve,
@@ -11,6 +12,7 @@ import {
   SubscribeListenerOptions,
   coOptionalDefiner,
   unstable_mergeBranchWithResolve,
+  withSchemaPermissions,
 } from "../../../internal.js";
 import { CoValueUniqueness } from "cojson";
 import { AnonymousJazzAgent } from "../../anonymousJazzAgent.js";
@@ -21,6 +23,10 @@ import { AnyZodOrCoValueSchema } from "../zodSchema.js";
 import { CoOptionalSchema } from "./CoOptionalSchema.js";
 import { CoreCoValueSchema, CoreResolveQuery } from "./CoValueSchema.js";
 import { withSchemaResolveQuery } from "../../schemaUtils.js";
+import {
+  DEFAULT_SCHEMA_PERMISSIONS,
+  SchemaPermissions,
+} from "../schemaPermissions.js";
 
 export class CoListSchema<
   T extends AnyZodOrCoValueSchema,
@@ -37,6 +43,12 @@ export class CoListSchema<
    */
   resolveQuery: DefaultResolveQuery = true as DefaultResolveQuery;
 
+  /**
+   * Permissions to be used when creating or composing CoValues
+   * @internal
+   */
+  permissions: SchemaPermissions = DEFAULT_SCHEMA_PERMISSIONS;
+
   constructor(
     public element: T,
     private coValueClass: typeof CoList,
@@ -63,7 +75,14 @@ export class CoListSchema<
       | Account
       | Group,
   ): CoListInstance<T> {
-    return this.coValueClass.create(items as any, options) as CoListInstance<T>;
+    const optionsWithPermissions = withSchemaPermissions(
+      options,
+      this.permissions,
+    );
+    return this.coValueClass.create(
+      items as any,
+      optionsWithPermissions,
+    ) as CoListInstance<T>;
   }
 
   load<
@@ -189,8 +208,32 @@ export class CoListSchema<
   >(
     resolveQuery: RefsToResolveStrict<CoListInstanceCoValuesMaybeLoaded<T>, R>,
   ): CoListSchema<T, R> {
-    const copy = new CoListSchema<T, R>(this.element, this.coValueClass);
-    copy.resolveQuery = resolveQuery as R;
+    return this.copy({ resolveQuery: resolveQuery as R });
+  }
+
+  /**
+   * Configure permissions to be used when creating or composing CoValues
+   */
+  withPermissions(
+    permissions: SchemaPermissions,
+  ): CoListSchema<T, DefaultResolveQuery> {
+    return this.copy({ permissions });
+  }
+
+  private copy<ResolveQuery extends CoreResolveQuery = DefaultResolveQuery>({
+    permissions,
+    resolveQuery,
+  }: {
+    permissions?: SchemaPermissions;
+    resolveQuery?: ResolveQuery;
+  }): CoListSchema<T, ResolveQuery> {
+    const coreSchema = createCoreCoListSchema(this.element);
+    // @ts-expect-error
+    const copy: CoListSchema<T, ResolveQuery> =
+      hydrateCoreCoValueSchema(coreSchema);
+    // @ts-expect-error TS cannot infer that the resolveQuery type is valid
+    copy.resolveQuery = resolveQuery ?? this.resolveQuery;
+    copy.permissions = permissions ?? this.permissions;
     return copy;
   }
 }

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

@@ -17,6 +17,7 @@ import {
   hydrateCoreCoValueSchema,
   isAnyCoValueSchema,
   unstable_mergeBranchWithResolve,
+  withSchemaPermissions,
 } from "../../../internal.js";
 import { AnonymousJazzAgent } from "../../anonymousJazzAgent.js";
 import { removeGetters, withSchemaResolveQuery } from "../../schemaUtils.js";
@@ -27,6 +28,10 @@ import { z } from "../zodReExport.js";
 import { AnyZodOrCoValueSchema, AnyZodSchema } from "../zodSchema.js";
 import { CoOptionalSchema } from "./CoOptionalSchema.js";
 import { CoreCoValueSchema, CoreResolveQuery } from "./CoValueSchema.js";
+import {
+  DEFAULT_SCHEMA_PERMISSIONS,
+  SchemaPermissions,
+} from "../schemaPermissions.js";
 
 export class CoMapSchema<
   Shape extends z.core.$ZodLooseShape,
@@ -48,6 +53,12 @@ export class CoMapSchema<
    */
   resolveQuery: DefaultResolveQuery = true as DefaultResolveQuery;
 
+  /**
+   * Permissions to be used when creating or composing CoValues
+   * @internal
+   */
+  permissions: SchemaPermissions = DEFAULT_SCHEMA_PERMISSIONS;
+
   constructor(
     coreSchema: CoreCoMapSchema<Shape, CatchAll>,
     private coValueClass: typeof CoMap,
@@ -76,8 +87,12 @@ export class CoMapSchema<
         }
       | Owner,
   ): CoMapInstanceShape<Shape, CatchAll> & CoMap;
-  create(...args: [any, ...any[]]) {
-    return this.coValueClass.create(...args);
+  create(init: any, options?: any) {
+    const optionsWithPermissions = withSchemaPermissions(
+      options,
+      this.permissions,
+    );
+    return this.coValueClass.create(init, optionsWithPermissions);
   }
 
   load<
@@ -254,8 +269,8 @@ export class CoMapSchema<
         true
       >,
     ) => undefined,
-  ): CoMapSchema<Shape, CatchAll, Owner, DefaultResolveQuery> {
-    // @ts-expect-error
+  ): this {
+    // @ts-expect-error avoid exposing 'migrate' at the type level
     this.coValueClass.prototype.migrate = migration;
     return this;
   }
@@ -340,15 +355,37 @@ export class CoMapSchema<
       R
     >,
   ): CoMapSchema<Shape, CatchAll, Owner, R> {
-    const coreSchema: CoreCoMapSchema<Shape, CatchAll> = createCoreCoMapSchema(
-      this.shape,
-      this.catchAll,
-    );
-    const copy = new CoMapSchema<Shape, CatchAll, Owner, R>(
-      coreSchema,
-      this.coValueClass,
-    );
-    copy.resolveQuery = resolveQuery as R;
+    return this.copy({ resolveQuery: resolveQuery as R });
+  }
+
+  /**
+   * Configure permissions to be used when creating or composing CoValues
+   */
+  withPermissions(
+    permissions: SchemaPermissions,
+  ): CoMapSchema<Shape, CatchAll, Owner, DefaultResolveQuery> {
+    return this.copy({ permissions });
+  }
+
+  /**
+   * Creates a copy of this schema, preserving all previous configuration
+   */
+  private copy<ResolveQuery extends CoreResolveQuery = DefaultResolveQuery>({
+    permissions,
+    resolveQuery,
+  }: {
+    permissions?: SchemaPermissions;
+    resolveQuery?: ResolveQuery;
+  }): CoMapSchema<Shape, CatchAll, Owner, ResolveQuery> {
+    const coreSchema = createCoreCoMapSchema(this.shape, this.catchAll);
+    // @ts-expect-error
+    const copy: CoMapSchema<Shape, CatchAll, Owner, ResolveQuery> =
+      hydrateCoreCoValueSchema(coreSchema);
+    // @ts-expect-error avoid exposing 'migrate' at the type level
+    copy.coValueClass.prototype.migrate = this.coValueClass.prototype.migrate;
+    // @ts-expect-error TS cannot infer that the resolveQuery type is valid
+    copy.resolveQuery = resolveQuery ?? this.resolveQuery;
+    copy.permissions = permissions ?? this.permissions;
     return copy;
   }
 }

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

@@ -21,6 +21,7 @@ import { z } from "../zodReExport.js";
 import { AnyZodOrCoValueSchema } from "../zodSchema.js";
 import { CoOptionalSchema } from "./CoOptionalSchema.js";
 import { CoreCoValueSchema, CoreResolveQuery } from "./CoValueSchema.js";
+import { SchemaPermissions } from "../schemaPermissions.js";
 
 type CoRecordInit<
   K extends z.core.$ZodString<string>,
@@ -161,6 +162,19 @@ export interface CoRecordSchema<
       R
     >,
   ): CoRecordSchema<K, V, R>;
+
+  /**
+   * Permissions to be used when creating or composing CoValues
+   * @internal
+   */
+  permissions: SchemaPermissions;
+
+  /**
+   * Configure permissions to be used when creating or composing CoValues
+   */
+  withPermissions(
+    permissions: SchemaPermissions,
+  ): CoRecordSchema<K, V, DefaultResolveQuery>;
 }
 
 type CoRecordSchemaDefinition<

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

@@ -6,9 +6,14 @@ import {
   InstanceOrPrimitiveOfSchema,
   InstanceOrPrimitiveOfSchemaCoValuesMaybeLoaded,
   coOptionalDefiner,
+  withSchemaPermissions,
 } from "../../../internal.js";
 import { CoOptionalSchema } from "./CoOptionalSchema.js";
 import { CoreCoValueSchema } from "./CoValueSchema.js";
+import {
+  DEFAULT_SCHEMA_PERMISSIONS,
+  SchemaPermissions,
+} from "../schemaPermissions.js";
 
 export interface CoreCoVectorSchema extends CoreCoValueSchema {
   builtin: "CoVector";
@@ -31,6 +36,11 @@ export class CoVectorSchema implements CoreCoVectorSchema {
   readonly builtin = "CoVector" as const;
   readonly resolveQuery = true as const;
 
+  /**
+   * Permissions to be used when creating or composing CoValues
+   */
+  permissions: SchemaPermissions = DEFAULT_SCHEMA_PERMISSIONS;
+
   constructor(
     public dimensions: number,
     private coValueClass: typeof CoVector,
@@ -56,7 +66,11 @@ export class CoVectorSchema implements CoreCoVectorSchema {
     vector: number[] | Float32Array,
     options?: { owner: Account | Group } | Account | Group,
   ): CoVectorInstance {
-    return this.coValueClass.create(vector, options);
+    const optionsWithPermissions = withSchemaPermissions(
+      options,
+      this.permissions,
+    );
+    return this.coValueClass.create(vector, optionsWithPermissions);
   }
 
   /**
@@ -99,6 +113,15 @@ export class CoVectorSchema implements CoreCoVectorSchema {
   optional(): CoOptionalSchema<this> {
     return coOptionalDefiner(this);
   }
+
+  /**
+   * Configure permissions to be used when creating or composing CoValues
+   */
+  withPermissions(permissions: SchemaPermissions): CoVectorSchema {
+    const copy = new CoVectorSchema(this.dimensions, this.coValueClass);
+    copy.permissions = permissions;
+    return copy;
+  }
 }
 
 export type CoVectorInstance = InstanceOrPrimitiveOfSchema<CoVectorSchema>;

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

@@ -6,9 +6,14 @@ import {
   Settled,
   coOptionalDefiner,
   unstable_mergeBranchWithResolve,
+  withSchemaPermissions,
 } from "../../../internal.js";
 import { CoOptionalSchema } from "./CoOptionalSchema.js";
 import { CoreCoValueSchema } from "./CoValueSchema.js";
+import {
+  DEFAULT_SCHEMA_PERMISSIONS,
+  SchemaPermissions,
+} from "../schemaPermissions.js";
 
 export interface CoreFileStreamSchema extends CoreCoValueSchema {
   builtin: "FileStream";
@@ -27,13 +32,22 @@ export class FileStreamSchema implements CoreFileStreamSchema {
   readonly builtin = "FileStream" as const;
   readonly resolveQuery = true as const;
 
+  /**
+   * Permissions to be used when creating or composing CoValues
+   */
+  permissions: SchemaPermissions = DEFAULT_SCHEMA_PERMISSIONS;
+
   constructor(private coValueClass: typeof FileStream) {}
 
   create(options?: { owner: Group } | Group): FileStream;
   /** @deprecated Creating CoValues with an Account as owner is deprecated. Use a Group instead. */
   create(options?: { owner: Account | Group } | Account | Group): FileStream;
   create(options?: { owner: Account | Group } | Account | Group): FileStream {
-    return this.coValueClass.create(options);
+    const optionsWithPermissions = withSchemaPermissions(
+      options,
+      this.permissions,
+    );
+    return this.coValueClass.create(optionsWithPermissions);
   }
 
   createFromBlob(
@@ -60,13 +74,35 @@ export class FileStreamSchema implements CoreFileStreamSchema {
       | Account
       | Group,
   ): Promise<FileStream> {
-    return this.coValueClass.createFromBlob(blob, options);
+    const optionsWithPermissions = withSchemaPermissions(
+      options,
+      this.permissions,
+    );
+    return this.coValueClass.createFromBlob(blob, optionsWithPermissions);
   }
 
   createFromArrayBuffer(
-    ...args: Parameters<typeof FileStream.createFromArrayBuffer>
+    arrayBuffer: ArrayBuffer,
+    mimeType: string,
+    fileName: string | undefined,
+    options?:
+      | {
+          owner?: Account | Group;
+          onProgress?: (progress: number) => void;
+        }
+      | Account
+      | Group,
   ) {
-    return this.coValueClass.createFromArrayBuffer(...args);
+    const optionsWithPermissions = withSchemaPermissions(
+      options,
+      this.permissions,
+    );
+    return this.coValueClass.createFromArrayBuffer(
+      arrayBuffer,
+      mimeType,
+      fileName,
+      optionsWithPermissions,
+    );
   }
 
   loadAsBlob(
@@ -115,4 +151,15 @@ export class FileStreamSchema implements CoreFileStreamSchema {
   optional(): CoOptionalSchema<this> {
     return coOptionalDefiner(this);
   }
+
+  /**
+   * Configure permissions to be used when creating or composing CoValues
+   */
+  withPermissions(
+    permissions: Omit<SchemaPermissions, "onInlineCreate">,
+  ): FileStreamSchema {
+    const copy = new FileStreamSchema(this.coValueClass);
+    copy.permissions = permissions;
+    return copy;
+  }
 }

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/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", () => {