jazz-tools 0.19.11 → 0.19.13

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

@@ -0,0 +1,188 @@
+import { Account, Group, TypeSym, type GroupRole } from "../../internal.js";
+
+/**
+ * Defines how a nested CoValue’s owner is obtained when creating CoValues from JSON.
+ *
+ * This configuration is not used when using an explicit .create() for nested CoValues.
+ * In that case, {@link SchemaPermissions.default} is used.
+ */
+export type OnInlineCreateOptions =
+  /**
+   * Always create a new group for CoValues created inline
+   */
+  | "newGroup"
+  /**
+   * Use the same owner as the container CoValue
+   */
+  | "sameAsContainer"
+  /**
+   * Create a new group that includes the container CoValue's owner as a member (effectively inheriting
+   * all permissions from the container)
+   */
+  | "extendsContainer"
+  /**
+   * Similar to "extendsContainer", but allows overriding the role of the container CoValue's owner
+   */
+  | { extendsContainer: GroupRole }
+  /**
+   * Create a new group and configure it as needed
+   */
+  | InlineGroupConfigurationCallback;
+
+export type InlineGroupConfigurationCallback = (
+  newGroup: Group,
+  context: { containerOwner: Group },
+) => void;
+
+export type OnCreateCallback = (newGroup: Group) => void;
+
+/**
+ * Internal callback type used by RefPermissions that includes init for discriminated union support.
+ * @internal
+ */
+export type RefOnCreateCallback = (newGroup: Group, init?: unknown) => void;
+
+/**
+ * Permissions to be used when creating or composing CoValues
+ * @param default - default owner to be used when creating a CoValue without providing an explicit owner.
+ * @param onInlineCreate - defines how a nested CoValue's owner is obtained when creating CoValues from JSON.
+ * @param onCreate - callback that runs every time a CoValue is created. Can be used to configure the CoValue's owner.
+ * Runs both when creating CoValues with `.create()` and when creating CoValues from JSON.
+ * @default { default: () => Group.create(), onInlineCreate: "extendsContainer" }
+ */
+export type SchemaPermissions = {
+  /**
+   * default owner to be used when creating a CoValue without providing an explicit owner.
+   */
+  default?: () => Group;
+  /**
+   * Defines how a nested CoValue's owner is obtained when creating CoValues from JSON.
+   */
+  onInlineCreate?: OnInlineCreateOptions;
+  /**
+   * callback that runs every time a CoValue is created. Can be used to configure the CoValue's owner.
+   * Runs both when creating CoValues with `.create()` and when creating CoValues from JSON.
+   */
+  onCreate?: OnCreateCallback;
+};
+
+export let DEFAULT_SCHEMA_PERMISSIONS: SchemaPermissions = {
+  default: () => Group.create(),
+  onInlineCreate: "extendsContainer",
+};
+
+/**
+ * Update the default schema permissions for all new CoValue schemas.
+ * Schemas created before calling this function will not be affected.
+ */
+export function setDefaultSchemaPermissions(permissions: SchemaPermissions) {
+  DEFAULT_SCHEMA_PERMISSIONS = {
+    ...DEFAULT_SCHEMA_PERMISSIONS,
+    ...permissions,
+  };
+}
+
+/**
+ * Parsed {@link SchemaPermissions}, used by CoValue classes to set up permissions for referenced CoValues.
+ */
+export type RefPermissions = {
+  newInlineOwnerStrategy: NewInlineOwnerStrategy;
+  onCreate?: RefOnCreateCallback;
+};
+
+/**
+ * A function that creates a new owner for a new CoValue created inline.
+ * @param createNewGroup - A function that creates a new group.
+ * @param containerOwner - The owner of the container CoValue.
+ * @param init - The value used to create the new CoValue. Necessary to determine the concrete
+ * strategy to use in discriminated unions.
+ * @returns The new owner.
+ */
+export type NewInlineOwnerStrategy = (
+  createNewGroup: () => Group,
+  containerOwner: Group,
+  init?: unknown,
+) => Group;
+
+export const extendContainerOwnerFactory =
+  (roleOverride?: GroupRole): NewInlineOwnerStrategy =>
+  (createNewGroup: () => Group, containerOwner: Group): Group => {
+    const node = containerOwner.$jazz.localNode;
+    const rawGroup = node.createGroup();
+    const owner = new Group({ fromRaw: rawGroup });
+    owner.addMember(containerOwner, roleOverride);
+    return owner;
+  };
+
+/**
+ * A function that creates a new owner for a new CoValue by extending the container CoValue's owner
+ * (without overriding its role)
+ */
+export const extendContainerOwner = extendContainerOwnerFactory();
+
+export function schemaToRefPermissions(
+  permissions: SchemaPermissions,
+): RefPermissions {
+  const newInlineOwnerStrategy = parseOnInlineCreate(
+    permissions.onInlineCreate,
+  );
+  const onCreate: RefOnCreateCallback | undefined = permissions.onCreate
+    ? (newGroup, _init) => permissions.onCreate?.(newGroup)
+    : undefined;
+  return {
+    newInlineOwnerStrategy,
+    onCreate,
+  };
+}
+
+function parseOnInlineCreate(
+  onInlineCreate?: OnInlineCreateOptions,
+): NewInlineOwnerStrategy {
+  if (!onInlineCreate || onInlineCreate === "extendsContainer") {
+    return extendContainerOwner;
+  }
+  if (
+    typeof onInlineCreate === "object" &&
+    "extendsContainer" in onInlineCreate
+  ) {
+    return extendContainerOwnerFactory(onInlineCreate.extendsContainer);
+  }
+  if (onInlineCreate === "newGroup") {
+    return (createNewGroup) => createNewGroup();
+  }
+  if (onInlineCreate === "sameAsContainer") {
+    return (_createNewGroup, containerOwner) => containerOwner;
+  }
+  return (createNewGroup, containerOwner) => {
+    const newGroup = createNewGroup();
+    onInlineCreate(newGroup, { containerOwner });
+    return newGroup;
+  };
+}
+
+export function getDefaultRefPermissions(): RefPermissions {
+  return schemaToRefPermissions(DEFAULT_SCHEMA_PERMISSIONS);
+}
+
+export function withSchemaPermissions<T extends { owner?: Account | Group }>(
+  options?: T | Account | Group,
+  schemaPermissions?: SchemaPermissions,
+): T & { onCreate?: OnCreateCallback } {
+  const onCreate = schemaPermissions?.onCreate;
+  if (!options) {
+    const owner = schemaPermissions?.default?.() ?? Group.create();
+    return { owner, onCreate } as T & { onCreate?: OnCreateCallback };
+  }
+  if (TypeSym in options) {
+    return { owner: options, onCreate } as T & {
+      onCreate?: OnCreateCallback;
+    };
+  }
+  const owner =
+    options.owner ?? schemaPermissions?.default?.() ?? Group.create();
+  return {
+    ...options,
+    owner,
+    onCreate,
+  } as T & { onCreate?: OnCreateCallback };
+}

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

@@ -4,6 +4,7 @@ import {
   BranchDefinition,
   CoFeed,
   Group,
+  hydrateCoreCoValueSchema,
   Settled,
   RefsToResolve,
   RefsToResolveStrict,
@@ -12,6 +13,7 @@ import {
   coOptionalDefiner,
   parseSubscribeRestArgs,
   unstable_mergeBranchWithResolve,
+  withSchemaPermissions,
 } from "../../../internal.js";
 import { AnonymousJazzAgent } from "../../anonymousJazzAgent.js";
 import { CoFeedSchemaInit } from "../typeConverters/CoFieldSchemaInit.js";
@@ -20,6 +22,10 @@ import { InstanceOrPrimitiveOfSchemaCoValuesMaybeLoaded } from "../typeConverter
 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 CoFeedSchema<
   T extends AnyZodOrCoValueSchema,
@@ -36,6 +42,12 @@ export class CoFeedSchema<
    */
   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 CoFeed,
@@ -54,7 +66,14 @@ export class CoFeedSchema<
     init: CoFeedSchemaInit<T>,
     options?: { owner: Account | Group } | Account | Group,
   ): CoFeedInstance<T> {
-    return this.coValueClass.create(init as any, options) as CoFeedInstance<T>;
+    const optionsWithPermissions = withSchemaPermissions(
+      options,
+      this.permissions,
+    );
+    return this.coValueClass.create(
+      init as any,
+      optionsWithPermissions,
+    ) as CoFeedInstance<T>;
   }
 
   load<
@@ -146,8 +165,32 @@ export class CoFeedSchema<
   >(
     resolveQuery: RefsToResolveStrict<CoFeedInstanceCoValuesMaybeLoaded<T>, R>,
   ): CoFeedSchema<T, R> {
-    const copy = new CoFeedSchema<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,
+  ): CoFeedSchema<T, DefaultResolveQuery> {
+    return this.copy({ permissions });
+  }
+
+  private copy<ResolveQuery extends CoreResolveQuery = DefaultResolveQuery>({
+    permissions,
+    resolveQuery,
+  }: {
+    permissions?: SchemaPermissions;
+    resolveQuery?: ResolveQuery;
+  }): CoFeedSchema<T, ResolveQuery> {
+    const coreSchema = createCoreCoFeedSchema(this.element);
+    // @ts-expect-error
+    const copy: CoFeedSchema<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/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;
+  }
 }