jazz-tools 0.19.11 → 0.19.13

package/src/tools/coValues/coList.ts

@@ -26,8 +26,6 @@ import {
   getIdFromHeader,
   internalLoadUnique,
   CoValueLoadingState,
-} from "../internal.js";
-import {
   AnonymousJazzAgent,
   ItemsSym,
   Ref,
@@ -172,8 +170,8 @@ export class CoList<out Item = any>
       | Account
       | Group,
   ) {
-    const { owner, uniqueness } = parseCoValueCreateOptions(options);
     const instance = new this();
+    const { owner, uniqueness } = parseCoValueCreateOptions(options);
 
     Object.defineProperties(instance, {
       $jazz: {
@@ -918,10 +916,15 @@ function toRawItems<Item>(
       }
       let refId = (value as unknown as CoValue).$jazz?.id;
       if (!refId) {
+        const newOwnerStrategy =
+          itemDescriptor.permissions?.newInlineOwnerStrategy;
+        const onCreate = itemDescriptor.permissions?.onCreate;
         const coValue = instantiateRefEncodedWithInit(
           itemDescriptor,
           value,
           owner,
+          newOwnerStrategy,
+          onCreate,
         );
         refId = coValue.$jazz.id;
       }

package/src/tools/coValues/coMap.ts

@@ -298,10 +298,15 @@ export class CoMap extends CoValueBase implements CoValue {
           if (initValue != null) {
             let refId = (initValue as unknown as CoValue).$jazz?.id;
             if (!refId) {
+              const newOwnerStrategy =
+                descriptor.permissions?.newInlineOwnerStrategy;
+              const onCreate = descriptor.permissions?.onCreate;
               const coValue = instantiateRefEncodedWithInit(
                 descriptor,
                 initValue,
                 owner,
+                newOwnerStrategy,
+                onCreate,
               );
               refId = coValue.$jazz.id;
             }
@@ -610,10 +615,15 @@ class CoMapJazzApi<M extends CoMap> extends CoValueJazzApi<M> {
         this.raw.set(key, null);
       } else {
         if (!refId) {
+          const newOwnerStrategy =
+            descriptor.permissions?.newInlineOwnerStrategy;
+          const onCreate = descriptor.permissions?.onCreate;
           const coValue = instantiateRefEncodedWithInit(
             descriptor,
             value,
             this.owner,
+            newOwnerStrategy,
+            onCreate,
           );
           refId = coValue.$jazz.id;
         }

package/src/tools/coValues/coVector.ts

@@ -129,7 +129,8 @@ export class CoVector
       );
     }
 
-    const coVector = new this(parseCoValueCreateOptions(options));
+    const { owner } = parseCoValueCreateOptions(options);
+    const coVector = new this({ owner });
     coVector.setVectorData(vectorAsFloat32Array);
 
     const byteArray = CoVector.toByteArray(vectorAsFloat32Array);

package/src/tools/coValues/group.ts

@@ -48,6 +48,11 @@ type GroupMember = {
   account: Account;
 };
 
+/**
+ * Roles that can be granted to a group member.
+ */
+export type GroupRole = "reader" | "writer" | "admin" | "manager";
+
 /** @category Identity & Permissions */
 export class Group extends CoValueBase implements CoValue {
   declare [TypeSym]: "Group";
@@ -107,10 +112,7 @@ export class Group extends CoValueBase implements CoValue {
    * @param member The group that will gain access to this group.
    * @param role The role all members of the parent group should have in this group.
    */
-  addMember(
-    member: Group,
-    role?: "reader" | "writer" | "admin" | "manager" | "inherit",
-  ): void;
+  addMember(member: Group, role?: GroupRole | "inherit"): void;
   addMember(
     member: Group | Account,
     role: "reader" | "writer" | "admin" | "manager",

package/src/tools/coValues/interfaces.ts

@@ -11,10 +11,11 @@ import {
   CoValueClassOrSchema,
   CoValueLoadingState,
   NotLoadedCoValueState,
-  type Group,
+  Group,
   Loaded,
   Inaccessible,
   MaybeLoaded,
+  OnCreateCallback,
   Settled,
   RefsToResolve,
   RefsToResolveStrict,
@@ -424,6 +425,7 @@ export function parseCoValueCreateOptions(
     | {
         owner?: Account | Group;
         unique?: CoValueUniqueness["uniqueness"];
+        onCreate?: OnCreateCallback;
       }
     | Account
     | Group
@@ -432,16 +434,22 @@ export function parseCoValueCreateOptions(
   owner: Group;
   uniqueness?: CoValueUniqueness;
 } {
+  const onCreate =
+    options && "onCreate" in options ? options.onCreate : undefined;
   const Group = RegisteredSchemas["Group"];
-
   if (!options) {
-    return { owner: Group.create(), uniqueness: undefined };
+    const owner = Group.create();
+    onCreate?.(owner);
+    return { owner, uniqueness: undefined };
   }
 
   if (TypeSym in options) {
     if (options[TypeSym] === "Account") {
-      return { owner: accountOrGroupToGroup(options), uniqueness: undefined };
+      const owner = accountOrGroupToGroup(options);
+      onCreate?.(owner);
+      return { owner, uniqueness: undefined };
     } else if (options[TypeSym] === "Group") {
+      onCreate?.(options);
       return { owner: options, uniqueness: undefined };
     }
   }
@@ -450,10 +458,14 @@ export function parseCoValueCreateOptions(
     ? { uniqueness: options.unique }
     : undefined;
 
+  const owner = options.owner
+    ? accountOrGroupToGroup(options.owner)
+    : Group.create();
+
+  onCreate?.(owner);
+
   const opts = {
-    owner: options.owner
-      ? accountOrGroupToGroup(options.owner)
-      : Group.create(),
+    owner,
     uniqueness,
   };
   return opts;

package/src/tools/exports.ts

@@ -66,6 +66,7 @@ export {
   createUnloadedCoValue,
   unstable_loadUnique,
   getUnloadedCoValueWithoutId,
+  setDefaultSchemaPermissions,
 } from "./internal.js";
 
 export {
@@ -100,7 +101,8 @@ export {
   createJazzContextFromExistingCredentials,
   createJazzContextForNewAccount,
   createJazzContext,
-  randomSessionProvider,
+  SessionProvider,
+  MockSessionProvider,
   type AuthResult,
   type Credentials,
   type JazzContextWithAccount,

package/src/tools/implementation/ContextManager.ts

@@ -351,6 +351,16 @@ export class JazzContextManager<
       // The storage is reachable through currentContext using the connectedPeers
       prevContext.node.removeStorage();
 
+      // Ensure that the new context is the only peer connected to the previous context
+      // This way all the changes made in the previous context are synced only to the new context
+      for (const peer of Object.values(prevContext.node.syncManager.peers)) {
+        if (!peer.closed) {
+          peer.gracefulShutdown();
+        }
+      }
+
+      prevContext.node.syncManager.peers = {};
+
       currentContext.node.syncManager.addPeer(prevAccountAsPeer);
       prevContext.node.syncManager.addPeer(currentAccountAsPeer);
 

package/src/tools/implementation/createContext.ts

@@ -28,10 +28,39 @@ export type Credentials = {
   secret: AgentSecret;
 };
 
-type SessionProvider = (
-  accountID: ID<Account>,
-  crypto: CryptoProvider,
-) => Promise<{ sessionID: SessionID; sessionDone: () => void }>;
+export interface SessionProvider {
+  acquireSession: (
+    accountID: ID<Account>,
+    crypto: CryptoProvider,
+  ) => Promise<{ sessionID: SessionID; sessionDone: () => void }>;
+  persistSession: (
+    accountID: ID<Account>,
+    sessionID: SessionID,
+  ) => Promise<{ sessionDone: () => void }>;
+}
+
+export class MockSessionProvider implements SessionProvider {
+  async acquireSession(
+    accountID: ID<Account>,
+    crypto: CryptoProvider,
+  ): Promise<{ sessionID: SessionID; sessionDone: () => void }> {
+    return {
+      sessionID: crypto.newRandomSessionID(
+        accountID as unknown as RawAccountID,
+      ),
+      sessionDone: () => {},
+    };
+  }
+
+  async persistSession(
+    _accountID: ID<Account>,
+    _sessionID: SessionID,
+  ): Promise<{ sessionDone: () => void }> {
+    return {
+      sessionDone: () => {},
+    };
+  }
+}
 
 export type AuthResult =
   | {
@@ -57,16 +86,6 @@ export type AuthResult =
       logOut: () => Promise<void>;
     };
 
-export async function randomSessionProvider(
-  accountID: ID<Account>,
-  crypto: CryptoProvider,
-) {
-  return {
-    sessionID: crypto.newRandomSessionID(accountID as unknown as RawAccountID),
-    sessionDone: () => {},
-  };
-}
-
 export type JazzContextWithAccount<Acc extends Account> = {
   node: LocalNode;
   account: Acc;
@@ -107,7 +126,7 @@ export async function createJazzContextFromExistingCredentials<
   storage?: StorageAPI;
   asActiveAccount: boolean;
 }): Promise<JazzContextWithAccount<InstanceOfSchema<S>>> {
-  const { sessionID, sessionDone } = await sessionProvider(
+  const { sessionID, sessionDone } = await sessionProvider.acquireSession(
     credentials.accountID,
     crypto,
   );
@@ -167,6 +186,7 @@ export async function createJazzContextForNewAccount<
   AccountSchema: PropsAccountSchema,
   onLogOut,
   storage,
+  sessionProvider,
 }: {
   creationProps: { name: string };
   initialAgentSecret?: AgentSecret;
@@ -175,6 +195,7 @@ export async function createJazzContextForNewAccount<
   AccountSchema?: S;
   onLogOut?: () => Promise<void>;
   storage?: StorageAPI;
+  sessionProvider: SessionProvider;
 }): Promise<JazzContextWithAccount<InstanceOfSchema<S>>> {
   const CurrentAccountSchema =
     PropsAccountSchema ?? (RegisteredSchemas["Account"] as unknown as S);
@@ -199,11 +220,17 @@ export async function createJazzContextForNewAccount<
   const account = AccountClass.fromNode(node);
   activeAccountContext.set(account);
 
+  const { sessionDone } = await sessionProvider.persistSession(
+    account.$jazz.id,
+    node.currentSessionID,
+  );
+
   return {
     node,
     account: account as InstanceOfSchema<S>,
     done: () => {
       node.gracefulShutdown();
+      sessionDone();
     },
     logOut: async () => {
       node.gracefulShutdown();
@@ -270,6 +297,7 @@ export async function createJazzContext<
       peers: options.peers,
       crypto,
       AccountSchema: options.AccountSchema,
+      sessionProvider: options.sessionProvider,
       onLogOut: async () => {
         await authSecretStorage.clearWithoutNotify();
       },

package/src/tools/implementation/schema.ts

@@ -5,9 +5,14 @@ import {
   type CoValue,
   type CoValueClass,
   CoValueFromRaw,
+  extendContainerOwner,
   Group,
+  type GroupRole,
   ItemsSym,
   LoadedAndRequired,
+  type NewInlineOwnerStrategy,
+  type RefOnCreateCallback,
+  type RefPermissions,
   SchemaInit,
   isCoValueClass,
 } from "../internal.js";
@@ -94,31 +99,33 @@ export const coField = {
 
 function optionalRef<C extends CoValueClass>(
   arg: C | ((raw: InstanceType<C>["$jazz"]["raw"]) => C),
+  options: { permissions: RefPermissions },
 ): InstanceType<C> | null | undefined {
-  return ref(arg, { optional: true });
+  return ref(arg, { optional: true, permissions: options.permissions });
 }
 
 function ref<C extends CoValueClass>(
   arg: C | ((raw: InstanceType<C>["$jazz"]["raw"]) => C),
-  options?: never,
+  options: { permissions?: RefPermissions },
 ): InstanceType<C> | null;
 function ref<C extends CoValueClass>(
   arg: C | ((raw: InstanceType<C>["$jazz"]["raw"]) => C),
-  options: { optional: true },
+  options: { optional: true; permissions?: RefPermissions },
 ): InstanceType<C> | null | undefined;
 function ref<
   C extends CoValueClass,
-  Options extends { optional?: boolean } | undefined,
+  Options extends { optional?: boolean; permissions?: RefPermissions },
 >(
   arg: C | ((raw: InstanceType<C>["$jazz"]["raw"]) => C),
-  options?: Options,
+  options: Options,
 ): Options extends { optional: true }
   ? InstanceType<C> | null | undefined
   : InstanceType<C> | null {
   return {
     [SchemaInit]: {
       ref: arg,
-      optional: options?.optional || false,
+      optional: options.optional || false,
+      permissions: options.permissions,
     } satisfies Schema,
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
   } as any;
@@ -129,6 +136,7 @@ export type EncodedAs<V> = { encoded: Encoder<V> | OptionalEncoder<V> };
 export type RefEncoded<V extends CoValue> = {
   ref: CoValueClass<V> | ((raw: RawCoValue) => CoValueClass<V>);
   optional: boolean;
+  permissions?: RefPermissions;
 };
 
 export function isRefEncoded<V extends CoValue>(
@@ -158,24 +166,26 @@ export function instantiateRefEncodedFromRaw<V extends CoValue>(
  *
  * @param schema - The schema of the CoValue to create.
  * @param init - The init values to use to create the CoValue.
- * @param parentOwner - The owner of the referencing CoValue. Will be used
- * as the parent group of the created CoValue's group
+ * @param containerOwner - The owner of the referencing CoValue. Will be used
+ * to determine the owner of the new CoValue
+ * @param newOwnerStrategy - The strategy to use to determine the owner of the new CoValue
+ * @param onCreate - The callback to call when the new CoValue is created
  * @returns The created CoValue.
  */
 export function instantiateRefEncodedWithInit<V extends CoValue>(
   schema: RefEncoded<V>,
   init: any,
-  parentOwner: Group,
+  containerOwner: Group,
+  newOwnerStrategy: NewInlineOwnerStrategy = extendContainerOwner,
+  onCreate?: RefOnCreateCallback,
 ): V {
   if (!isCoValueClass<V>(schema.ref)) {
     throw Error(
       `Cannot automatically create CoValue from value: ${JSON.stringify(init)}. Use the CoValue schema's create() method instead.`,
     );
   }
-  const node = parentOwner.$jazz.localNode;
-  const rawGroup = node.createGroup();
-  const owner = new Group({ fromRaw: rawGroup });
-  owner.addMember(parentOwner);
+  const owner = newOwnerStrategy(() => Group.create(), containerOwner, init);
+  onCreate?.(owner, init);
   // @ts-expect-error - create is a static method in all CoValue classes
   return schema.ref.create(init, owner);
 }

package/src/tools/implementation/schemaUtils.ts

@@ -1,4 +1,4 @@
-import { CoreResolveQuery } from "./zodSchema/schemaTypes/CoValueSchema";
+import { CoreResolveQuery } from "./zodSchema/schemaTypes/CoValueSchema.js";
 
 /**
  * Remove getters from an object

package/src/tools/implementation/zodSchema/runtimeConverters/schemaFieldToCoFieldDef.ts

@@ -1,8 +1,24 @@
 import type { JsonValue } from "cojson";
-import { CoValueClass, isCoValueClass } from "../../../internal.js";
+import {
+  CoValueClass,
+  isCoValueClass,
+  schemaToRefPermissions,
+  getDefaultRefPermissions,
+  SchemaPermissions,
+  RefPermissions,
+  type NewInlineOwnerStrategy,
+  type CoreCoDiscriminatedUnionSchema,
+  type DiscriminableCoValueSchemas,
+  type RefOnCreateCallback,
+} from "../../../internal.js";
 import { coField } from "../../schema.js";
 import { CoreCoValueSchema } from "../schemaTypes/CoValueSchema.js";
-import { isUnionOfPrimitivesDeeply } from "../unionUtils.js";
+import {
+  isUnionOfPrimitivesDeeply,
+  getFlattenedUnionOptions,
+  getDiscriminatorValuesForOption,
+  resolveDiscriminantValue,
+} from "../unionUtils.js";
 import {
   ZodCatch,
   ZodDefault,
@@ -76,17 +92,28 @@ export function schemaFieldToCoFieldDef(schema: SchemaField): CoFieldDef {
   }
 
   if (isCoValueClass(schema)) {
-    return cacheSchemaField(schema, coField.ref(schema));
+    return cacheSchemaField(
+      schema,
+      coField.ref(schema, {
+        permissions: getDefaultRefPermissions(),
+      }),
+    );
   } else if (isCoValueSchema(schema)) {
     if (schema.builtin === "CoOptional") {
       return cacheSchemaField(
         schema,
         coField.ref(schema.getCoValueClass(), {
           optional: true,
+          permissions: schemaFieldPermissions(schema),
         }),
       );
     }
-    return cacheSchemaField(schema, coField.ref(schema.getCoValueClass()));
+    return cacheSchemaField(
+      schema,
+      coField.ref(schema.getCoValueClass(), {
+        permissions: schemaFieldPermissions(schema),
+      }),
+    );
   } else {
     if ("_zod" in schema) {
       const zodSchemaDef = schema._zod.def;
@@ -228,3 +255,77 @@ export function schemaFieldToCoFieldDef(schema: SchemaField): CoFieldDef {
     }
   }
 }
+
+function schemaFieldPermissions(schema: CoreCoValueSchema): RefPermissions {
+  if (schema.builtin === "CoOptional") {
+    return schemaFieldPermissions((schema as any).innerType);
+  }
+  if (schema.builtin === "CoDiscriminatedUnion") {
+    return discriminatedUnionFieldPermissions(
+      schema as CoreCoDiscriminatedUnionSchema<DiscriminableCoValueSchemas>,
+    );
+  }
+  return "permissions" in schema
+    ? schemaToRefPermissions(schema.permissions as SchemaPermissions)
+    : getDefaultRefPermissions();
+}
+
+function discriminatedUnionFieldPermissions(
+  schema: CoreCoDiscriminatedUnionSchema<DiscriminableCoValueSchemas>,
+): RefPermissions {
+  const discriminatorKey = schema.getDefinition().discriminator;
+  const allOptions = getFlattenedUnionOptions(schema);
+
+  const valueToStrategy = new Map<unknown, RefPermissions>();
+  for (const option of allOptions) {
+    const optionPermissions = schemaFieldPermissions(option);
+    const discriminatorValues = getDiscriminatorValuesForOption(
+      option,
+      discriminatorKey,
+    );
+
+    if (!discriminatorValues) {
+      continue;
+    }
+
+    for (const value of discriminatorValues) {
+      if (!valueToStrategy.has(value)) {
+        valueToStrategy.set(value, optionPermissions);
+      }
+    }
+  }
+
+  const fallbackStrategy = getDefaultRefPermissions();
+
+  const newInlineOwnerStrategy: NewInlineOwnerStrategy = (
+    createNewGroup,
+    containerOwner,
+    init,
+  ) => {
+    const discriminantValue = resolveDiscriminantValue(init, discriminatorKey);
+    const strategy =
+      discriminantValue !== undefined
+        ? valueToStrategy.get(discriminantValue)
+        : undefined;
+
+    const effectiveStrategy = strategy ?? fallbackStrategy;
+    return effectiveStrategy.newInlineOwnerStrategy(
+      createNewGroup,
+      containerOwner,
+      init,
+    );
+  };
+
+  const onCreate: RefOnCreateCallback = (newGroup, init) => {
+    const discriminantValue = resolveDiscriminantValue(init, discriminatorKey);
+    const strategy =
+      discriminantValue !== undefined
+        ? valueToStrategy.get(discriminantValue)
+        : undefined;
+
+    const effectiveStrategy = strategy ?? fallbackStrategy;
+    effectiveStrategy.onCreate?.(newGroup, init);
+  };
+
+  return { newInlineOwnerStrategy, onCreate };
+}