jazz-tools 0.17.14 → 0.18.1

package/src/tools/implementation/zodSchema/typeConverters/{CoFieldInit.ts → CoFieldSchemaInit.ts}

@@ -22,7 +22,7 @@ import { TypeOfZodSchema } from "./TypeOfZodSchema.js";
  * For CoValue fields, this can be either a shallowly-loaded CoValue instance
  * or a JSON object that will be used to create the CoValue.
  */
-export type CoFieldInit<S extends CoValueClass | AnyZodOrCoValueSchema> =
+export type CoFieldSchemaInit<S extends CoValueClass | AnyZodOrCoValueSchema> =
   S extends CoreCoValueSchema
     ?
         | Loaded<S>
@@ -31,15 +31,15 @@ export type CoFieldInit<S extends CoValueClass | AnyZodOrCoValueSchema> =
             : S extends CoreCoMapSchema<infer Shape>
               ? CoMapSchemaInit<Shape>
               : S extends CoreCoListSchema<infer T>
-                ? CoListInit<T>
+                ? CoListSchemaInit<T>
                 : S extends CoreCoFeedSchema<infer T>
-                  ? CoFeedInit<T>
+                  ? CoFeedSchemaInit<T>
                   : S extends CorePlainTextSchema | CoreRichTextSchema
                     ? string
                     : S extends CoreCoOptionalSchema<infer T>
-                      ? CoFieldInit<T> | undefined
+                      ? CoFieldSchemaInit<T> | undefined
                       : S extends CoDiscriminatedUnionSchema<infer Members>
-                        ? CoFieldInit<Members[number]>
+                        ? CoFieldSchemaInit<Members[number]>
                         : never)
     : S extends z.core.$ZodType
       ? TypeOfZodSchema<S>
@@ -59,20 +59,20 @@ export type CoMapSchemaInit<Shape extends z.core.$ZodLooseShape> = Simplify<
       | CoreCoOptionalSchema
       | z.core.$ZodOptional
       ? never
-      : Key]: CoFieldInit<Shape[Key]>;
+      : Key]: CoFieldSchemaInit<Shape[Key]>;
   } & {
     [Key in keyof Shape as Shape[Key] extends
       | CoreCoOptionalSchema
       | z.core.$ZodOptional
       ? Key
-      : never]?: CoFieldInit<Shape[Key]>;
+      : never]?: CoFieldSchemaInit<Shape[Key]>;
   }
 >;
 
-export type CoListInit<T extends AnyZodOrCoValueSchema> = Simplify<
-  ReadonlyArray<CoFieldInit<T>>
+export type CoListSchemaInit<T extends AnyZodOrCoValueSchema> = Simplify<
+  ReadonlyArray<CoFieldSchemaInit<T>>
 >;
 
-export type CoFeedInit<T extends AnyZodOrCoValueSchema> = Simplify<
-  ReadonlyArray<CoFieldInit<T>>
+export type CoFeedSchemaInit<T extends AnyZodOrCoValueSchema> = Simplify<
+  ReadonlyArray<CoFieldSchemaInit<T>>
 >;

package/src/tools/implementation/zodSchema/typeConverters/InstanceOfSchema.ts

@@ -27,23 +27,23 @@ export type InstanceOfSchema<S extends CoValueClass | AnyZodOrCoValueSchema> =
   S extends CoreCoValueSchema
     ? S extends CoreAccountSchema<infer Shape>
       ? {
-          -readonly [key in keyof Shape]: InstanceOrPrimitiveOfSchema<
+          readonly [key in keyof Shape]: InstanceOrPrimitiveOfSchema<
             Shape[key]
           >;
         } & Account
       : S extends CoreCoRecordSchema<infer K, infer V>
         ? {
-            -readonly [key in z.output<K> &
+            readonly [key in z.output<K> &
               string]: InstanceOrPrimitiveOfSchema<V>;
           } & CoMap
         : S extends CoreCoMapSchema<infer Shape, infer CatchAll>
           ? {
-              -readonly [key in keyof Shape]: InstanceOrPrimitiveOfSchema<
+              readonly [key in keyof Shape]: InstanceOrPrimitiveOfSchema<
                 Shape[key]
               >;
             } & (CatchAll extends AnyZodOrCoValueSchema
               ? {
-                  [key: string]: InstanceOrPrimitiveOfSchema<CatchAll>;
+                  readonly [key: string]: InstanceOrPrimitiveOfSchema<CatchAll>;
                 }
               : {}) &
               CoMap

package/src/tools/implementation/zodSchema/typeConverters/InstanceOfSchemaCoValuesNullable.ts

@@ -29,7 +29,7 @@ export type InstanceOfSchemaCoValuesNullable<
   ? S extends CoreAccountSchema<infer Shape>
     ?
         | ({
-            -readonly [key in keyof Shape]: InstanceOrPrimitiveOfSchemaCoValuesNullable<
+            readonly [key in keyof Shape]: InstanceOrPrimitiveOfSchemaCoValuesNullable<
               Shape[key]
             >;
           } & Account)
@@ -37,19 +37,19 @@ export type InstanceOfSchemaCoValuesNullable<
     : S extends CoreCoRecordSchema<infer K, infer V>
       ?
           | ({
-              -readonly [key in z.output<K> &
+              readonly [key in z.output<K> &
                 string]: InstanceOrPrimitiveOfSchemaCoValuesNullable<V>;
             } & CoMap)
           | null
       : S extends CoreCoMapSchema<infer Shape, infer CatchAll>
         ?
             | ({
-                -readonly [key in keyof Shape]: InstanceOrPrimitiveOfSchemaCoValuesNullable<
+                readonly [key in keyof Shape]: InstanceOrPrimitiveOfSchemaCoValuesNullable<
                   Shape[key]
                 >;
               } & (CatchAll extends AnyZodOrCoValueSchema
                 ? {
-                    [
+                    readonly [
                       key: string
                     ]: InstanceOrPrimitiveOfSchemaCoValuesNullable<CatchAll>;
                   }

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

@@ -101,12 +101,12 @@ export const coMapDefiner = <Shape extends z.core.$ZodLooseShape>(
  *   }),
  * }).withMigration(async (account) => {
  *   // Migration logic for existing accounts
- *   if (account.profile === undefined) {
+ *   if (!account.$jazz.has("profile")) {
  *     const group = Group.create();
- *     account.profile = co.profile().create(
+ *     account.$jazz.set("profile", co.profile().create(
  *       { name: getRandomUsername() },
  *       group
- *     );
+ *     ));
  *     group.addMember("everyone", "reader");
  *   }
  * });

package/src/tools/internal.ts

@@ -1,5 +1,6 @@
 export * from "./coValues/interfaces.js";
 export * from "./coValues/CoValueBase.js";
+export * from "./coValues/CoFieldInit.js";
 export * from "./implementation/inspect.js";
 export * from "./implementation/symbols.js";
 
@@ -45,7 +46,7 @@ export * from "./implementation/zodSchema/typeConverters/InstanceOrPrimitiveOfSc
 export * from "./implementation/zodSchema/typeConverters/InstanceOrPrimitiveOfSchemaCoValuesNullable.js";
 export * from "./implementation/zodSchema/typeConverters/InstanceOfSchema.js";
 export * from "./implementation/zodSchema/typeConverters/InstanceOfSchemaCoValuesNullable.js";
-export * from "./implementation/zodSchema/typeConverters/CoFieldInit.js";
+export * from "./implementation/zodSchema/typeConverters/CoFieldSchemaInit.js";
 export * from "./implementation/zodSchema/runtimeConverters/coValueSchemaTransformation.js";
 export * from "./implementation/zodSchema/runtimeConverters/schemaFieldToCoFieldDef.js";
 export * from "./coValues/extensions/imageDef.js";

package/src/tools/lib/migration.ts

@@ -1,7 +1,7 @@
-import type { CoValue } from "../internal.js";
+import { TypeSym, type CoValue } from "../internal.js";
 
 export function applyCoValueMigrations(instance: CoValue) {
-  const node = instance._raw.core.node;
+  const node = instance.$jazz.raw.core.node;
 
   // @ts-expect-error _migratedCoValues is a custom expando property
   const migratedCoValues = (node._migratedCoValues ??= new Set<string>());
@@ -9,11 +9,11 @@ export function applyCoValueMigrations(instance: CoValue) {
   if (
     "migrate" in instance &&
     typeof instance.migrate === "function" &&
-    instance._type !== "Account" &&
-    !migratedCoValues.has(instance.id)
+    instance[TypeSym] !== "Account" &&
+    !migratedCoValues.has(instance.$jazz.id)
   ) {
     // We flag this before the migration to avoid that internal loads trigger the migration again
-    migratedCoValues.add(instance.id);
+    migratedCoValues.add(instance.$jazz.id);
 
     const result = instance.migrate?.(instance);
     if (result && "then" in result) {

package/src/tools/subscribe/SubscriptionScope.ts

@@ -7,6 +7,7 @@ import {
   type ID,
   type RefEncoded,
   type RefsToResolve,
+  TypeSym,
   instantiateRefEncodedFromRaw,
   isRefEncoded,
 } from "../internal.js";
@@ -14,7 +15,7 @@ import { applyCoValueMigrations } from "../lib/migration.js";
 import { CoValueCoreSubscription } from "./CoValueCoreSubscription.js";
 import { JazzError, type JazzErrorIssue } from "./JazzError.js";
 import type { SubscriptionValue, Unloaded } from "./types.js";
-import { createCoValue, getOwnerFromRawValue } from "./utils.js";
+import { createCoValue, myRoleForRawValue } from "./utils.js";
 
 export class SubscriptionScope<D extends CoValue> {
   childNodes = new Map<string, SubscriptionScope<CoValue>>();
@@ -121,7 +122,7 @@ export class SubscriptionScope<D extends CoValue> {
     // Groups and accounts are accessible by everyone, for the other coValues we use the role to check access
     const hasAccess =
       ruleset.type !== "ownedByGroup" ||
-      getOwnerFromRawValue(update).myRole() !== undefined;
+      myRoleForRawValue(update) !== undefined;
 
     if (!hasAccess) {
       if (this.value.type !== "unauthorized") {
@@ -152,9 +153,9 @@ export class SubscriptionScope<D extends CoValue> {
     } else {
       const hasChanged =
         update.totalValidTransactions !== this.totalValidTransactions ||
-        // Checking the identity of the _raw value makes us cover the cases where the group
+        // Checking the identity of the raw value makes us cover the cases where the group
         // has been updated and the coValues that don't update the totalValidTransactions value (e.g. FileStream)
-        this.value.value._raw !== update;
+        this.value.value.$jazz.raw !== update;
 
       if (this.loadChildren()) {
         this.updateValue(createCoValue(this.schema, update, this));
@@ -241,7 +242,7 @@ export class SubscriptionScope<D extends CoValue> {
         // On child updates, we re-create the value instance to make the updates
         // seamless-immutable and so be compatible with React and the React compiler
         this.updateValue(
-          createCoValue(this.schema, this.value.value._raw, this),
+          createCoValue(this.schema, this.value.value.$jazz.raw, this),
         );
       }
     }
@@ -300,7 +301,7 @@ export class SubscriptionScope<D extends CoValue> {
       return false;
     }
 
-    return this.value.value._raw.core.verified.isStreaming();
+    return this.value.value.$jazz.raw.core.verified.isStreaming();
   }
 
   isFileStream() {
@@ -308,7 +309,9 @@ export class SubscriptionScope<D extends CoValue> {
       return false;
     }
 
-    return this.value.value._raw.core.verified.header.meta?.type === "binary";
+    return (
+      this.value.value.$jazz.raw.core.verified.header.meta?.type === "binary"
+    );
   }
 
   triggerUpdate() {
@@ -369,11 +372,11 @@ export class SubscriptionScope<D extends CoValue> {
     // This helps alot with correctness when triggering the autoloading while rendering components (on React and Svelte)
     this.silenceUpdates = true;
 
-    if (value._type === "CoMap" || value._type === "Account") {
+    if (value[TypeSym] === "CoMap" || value[TypeSym] === "Account") {
       const map = value as CoMap;
 
       this.loadCoMapKey(map, key, true);
-    } else if (value._type === "CoList") {
+    } else if (value[TypeSym] === "CoList") {
       const list = value as CoList;
 
       this.loadCoListKey(list, key, true);
@@ -427,12 +430,17 @@ export class SubscriptionScope<D extends CoValue> {
 
     const idsToLoad = new Set<string>(this.idsSubscribed);
 
-    const coValueType = value._type;
+    const coValueType = value[TypeSym];
 
     if (Object.keys(depth).length > 0) {
-      if (coValueType === "CoMap" || coValueType === "Account") {
+      if (
+        coValueType === "CoMap" ||
+        coValueType === "Account" ||
+        coValueType === "Group"
+      ) {
         const map = value as CoMap;
-        const keys = "$each" in depth ? map._raw.keys() : Object.keys(depth);
+        const keys =
+          "$each" in depth ? map.$jazz.raw.keys() : Object.keys(depth);
 
         for (const key of keys) {
           const id = this.loadCoMapKey(map, key, depth[key] ?? depth.$each);
@@ -441,14 +449,14 @@ export class SubscriptionScope<D extends CoValue> {
             idsToLoad.add(id);
           }
         }
-      } else if (value._type === "CoList") {
+      } else if (value[TypeSym] === "CoList") {
         const list = value as CoList;
 
-        const descriptor = list.getItemsDescriptor();
+        const descriptor = list.$jazz.getItemsDescriptor();
 
         if (descriptor && isRefEncoded(descriptor)) {
-          list._raw.processNewTransactions();
-          const entries = list._raw.entries();
+          list.$jazz.raw.processNewTransactions();
+          const entries = list.$jazz.raw.entries();
           const keys =
             "$each" in depth ? Object.keys(entries) : Object.keys(depth);
 
@@ -460,13 +468,13 @@ export class SubscriptionScope<D extends CoValue> {
             }
           }
         }
-      } else if (value._type === "CoStream") {
+      } else if (value[TypeSym] === "CoStream") {
         const stream = value as CoFeed;
-        const descriptor = stream.getItemsDescriptor();
+        const descriptor = stream.$jazz.getItemsDescriptor();
 
         if (descriptor && isRefEncoded(descriptor)) {
-          for (const session of stream._raw.sessions()) {
-            const values = stream._raw.items[session] ?? [];
+          for (const session of stream.$jazz.raw.sessions()) {
+            const values = stream.$jazz.raw.items[session] ?? [];
 
             for (const [i, item] of values.entries()) {
               const key = `${session}/${i}`;
@@ -525,8 +533,8 @@ export class SubscriptionScope<D extends CoValue> {
       return undefined;
     }
 
-    const id = map._raw.get(key) as string | undefined;
-    const descriptor = map.getDescriptor(key);
+    const id = map.$jazz.raw.get(key) as string | undefined;
+    const descriptor = map.$jazz.getDescriptor(key);
 
     if (!descriptor) {
       this.childErrors.set(
@@ -568,13 +576,13 @@ export class SubscriptionScope<D extends CoValue> {
   }
 
   loadCoListKey(list: CoList, key: string, depth: Record<string, any> | true) {
-    const descriptor = list.getItemsDescriptor();
+    const descriptor = list.$jazz.getItemsDescriptor();
 
     if (!descriptor || !isRefEncoded(descriptor)) {
       return undefined;
     }
 
-    const entries = list._raw.entries();
+    const entries = list.$jazz.raw.entries();
     const entry = entries[Number(key)];
 
     if (!entry) {

package/src/tools/subscribe/index.ts

@@ -2,22 +2,22 @@ import type { CoValue, CoValueClass, RefEncoded } from "../internal.js";
 import { SubscriptionScope } from "./SubscriptionScope.js";
 
 export function getSubscriptionScope<D extends CoValue>(value: D) {
-  const subscriptionScope = value._subscriptionScope;
+  const subscriptionScope = value.$jazz._subscriptionScope;
 
   if (subscriptionScope) {
     return subscriptionScope;
   }
 
-  const node = value._raw.core.node;
+  const node = value.$jazz.raw.core.node;
   const resolve = true;
-  const id = value.id;
+  const id = value.$jazz.id;
 
   const newSubscriptionScope = new SubscriptionScope(node, resolve, id, {
     ref: value.constructor as CoValueClass<D>,
     optional: false,
   });
 
-  Object.defineProperty(value, "_subscriptionScope", {
+  Object.defineProperty(value.$jazz, "_subscriptionScope", {
     value: subscriptionScope,
     writable: false,
     enumerable: false,

package/src/tools/subscribe/utils.ts

@@ -1,24 +1,24 @@
-import { RawAccount, RawCoValue } from "cojson";
+import { RawAccount, RawCoValue, Role } from "cojson";
 import { RegisteredSchemas } from "../coValues/registeredSchemas.js";
 import {
   CoValue,
   RefEncoded,
-  coValueClassFromCoValueClassOrSchema,
+  accountOrGroupToGroup,
   instantiateRefEncodedFromRaw,
 } from "../internal.js";
 import { coValuesCache } from "../lib/cache.js";
 import { SubscriptionScope } from "./SubscriptionScope.js";
 
-export function getOwnerFromRawValue(raw: RawCoValue) {
-  const owner = raw.group;
+export function myRoleForRawValue(raw: RawCoValue): Role | undefined {
+  const rawOwner = raw.group;
 
-  return coValuesCache.get(owner, () =>
-    owner instanceof RawAccount
-      ? coValueClassFromCoValueClassOrSchema(
-          RegisteredSchemas["Account"],
-        ).fromRaw(owner)
-      : RegisteredSchemas["Group"].fromRaw(owner as any),
+  const owner = coValuesCache.get(rawOwner, () =>
+    rawOwner instanceof RawAccount
+      ? RegisteredSchemas["Account"].fromRaw(rawOwner)
+      : RegisteredSchemas["Group"].fromRaw(rawOwner),
   );
+
+  return accountOrGroupToGroup(owner).myRole();
 }
 
 export function createCoValue<D extends CoValue>(
@@ -28,7 +28,7 @@ export function createCoValue<D extends CoValue>(
 ) {
   const freshValueInstance = instantiateRefEncodedFromRaw(ref, raw);
 
-  Object.defineProperty(freshValueInstance, "_subscriptionScope", {
+  Object.defineProperty(freshValueInstance.$jazz, "_subscriptionScope", {
     value: subscriptionScope,
     writable: false,
     enumerable: false,

package/src/tools/testing.ts

@@ -141,7 +141,7 @@ export async function createJazzTestAccount<
   });
 
   const account = AccountClass.fromNode(node);
-  SecretSeedMap.set(account.id, secretSeed);
+  SecretSeedMap.set(account.$jazz.id, secretSeed);
 
   if (options?.isCurrentActiveAccount) {
     activeAccountContext.set(account);
@@ -222,12 +222,12 @@ export class TestJazzContextManager<
 
     const provider = props?.isAuthenticated ? "testProvider" : "anonymous";
     const storage = context.getAuthSecretStorage();
-    const node = account._raw.core.node;
+    const node = account.$jazz.localNode;
 
     const credentials = {
-      accountID: account.id,
+      accountID: account.$jazz.id,
       accountSecret: node.getCurrentAgent().agentSecret,
-      secretSeed: SecretSeedMap.get(account.id),
+      secretSeed: SecretSeedMap.get(account.$jazz.id),
       provider,
     } satisfies AuthCredentials;
 
@@ -319,16 +319,20 @@ export async function linkAccounts(
   aRole: "server" | "client" = "server",
   bRole: "server" | "client" = "server",
 ) {
-  const [aPeer, bPeer] = cojsonInternals.connectedPeers(b.id, a.id, {
-    peer1role: aRole,
-    peer2role: bRole,
-  });
+  const [aPeer, bPeer] = cojsonInternals.connectedPeers(
+    b.$jazz.id,
+    a.$jazz.id,
+    {
+      peer1role: aRole,
+      peer2role: bRole,
+    },
+  );
 
-  a._raw.core.node.syncManager.addPeer(aPeer);
-  b._raw.core.node.syncManager.addPeer(bPeer);
+  a.$jazz.localNode.syncManager.addPeer(aPeer);
+  b.$jazz.localNode.syncManager.addPeer(bPeer);
 
-  await a.waitForAllCoValuesSync();
-  await b.waitForAllCoValuesSync();
+  await a.$jazz.waitForAllCoValuesSync();
+  await b.$jazz.waitForAllCoValuesSync();
 }
 
 export async function setupJazzTestSync({
@@ -347,7 +351,7 @@ export async function setupJazzTestSync({
     crypto: await TestJSCrypto.create(),
   });
 
-  syncServer.current = account._raw.core.node;
+  syncServer.current = account.$jazz.localNode;
   syncServer.asyncPeers = asyncPeers;
 
   return account;