jazz-tools 0.14.19 → 0.14.21

package/src/coValues/CoValueBase.ts

@@ -1,4 +1,5 @@
 import { ControlledAccount, RawAccount, type RawCoValue } from "cojson";
+import { z } from "../implementation/zodSchema/zodReExport.js";
 import {
   AnonymousJazzAgent,
   CoValue,
@@ -11,7 +12,12 @@ import {
   coValuesCache,
   inspect,
 } from "../internal.js";
-import type { Account, Group } from "../internal.js";
+import type {
+  Account,
+  CoValueClassFromZodSchema,
+  Group,
+  InstanceOfSchemaCoValuesNullable,
+} from "../internal.js";
 
 /** @internal */
 
@@ -61,7 +67,6 @@ export class CoValueBase implements CoValue {
   static fromRaw<V extends CoValue>(this: CoValueClass<V>, raw: RawCoValue): V {
     return new this({ fromRaw: raw });
   }
-
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   toJSON(): object | any[] | string {
     return {
@@ -76,13 +81,32 @@ export class CoValueBase implements CoValue {
   }
 
   /** @category Type Helpers */
-  castAs<Cl extends CoValueClass & CoValueFromRaw<CoValue>>(
-    cl: Cl,
-  ): InstanceType<Cl> {
+  castAs<
+    S extends
+      | CoValueClass
+      | z.core.$ZodType
+      | (z.core.$ZodObject<any, any> & {
+          builtin: "Account";
+          migration?: (account: any, creationProps?: { name: string }) => void;
+        })
+      | (z.core.$ZodCustom<any, any> & { builtin: "FileStream" })
+      | (z.core.$ZodCustom<any, any> & {
+          builtin: "CoFeed";
+          element: z.core.$ZodType;
+        }),
+  >(
+    schema: S,
+  ): S extends CoValueClass
+    ? InstanceType<S>
+    : S extends z.core.$ZodType
+      ? NonNullable<InstanceOfSchemaCoValuesNullable<S>>
+      : never {
+    const cl = "getCoSchema" in schema ? (schema as any).getCoSchema() : schema;
+
     if (this.constructor === cl) {
-      return this as InstanceType<Cl>;
+      return this as any;
     }
 
-    return cl.fromRaw(this._raw) as InstanceType<Cl>;
+    return (cl as unknown as CoValueFromRaw<CoValue>).fromRaw(this._raw) as any;
   }
 }

package/src/coValues/coMap.ts

@@ -35,7 +35,6 @@ import {
   accessChildById,
   accessChildByKey,
   activeAccountContext,
-  anySchemaToCoSchema,
   ensureCoValueLoaded,
   inspect,
   isRefEncoded,
@@ -119,6 +118,20 @@ export class CoMap extends CoValueBase implements CoValue {
     } & { [ItemsSym]?: Schema };
   }
 
+  /**
+   * The timestamp of the creation time of the CoMap
+   */
+  get _createdAt() {
+    return this._raw.earliestTxMadeAt ?? Number.MAX_SAFE_INTEGER;
+  }
+
+  /**
+   * The timestamp of the last updated time of the CoMap
+   */
+  get _lastUpdatedAt() {
+    return this._raw.latestTxMadeAt;
+  }
+
   /**
    * If property `prop` is a `coField.ref(...)`, you can use `coMaps._refs.prop` to access
    * the `Ref` instead of the potentially loaded/null value.

package/src/coValues/group.ts

@@ -215,6 +215,18 @@ export class Group extends CoValueBase implements CoValue {
     );
   }
 
+  /**
+   * Make the group public, so that everyone can read it.
+   * Alias for `addMember("everyone", role)`.
+   *
+   * @param role - Optional: the role to grant to everyone. Defaults to "reader".
+   * @returns The group itself.
+   */
+  makePublic(role: "reader" | "writer" = "reader") {
+    this.addMember("everyone", role);
+    return this;
+  }
+
   getParentGroups(): Array<Group> {
     return this._raw.getParentGroups().map((group) => Group.fromRaw(group));
   }

package/src/coValues/interfaces.ts

@@ -294,6 +294,11 @@ export function subscribeToCoValue<
   return unsubscribe;
 }
 
+/**
+ * @deprecated Used for the React integration in the past, but we moved to use SubscriptionScope directly.
+ *
+ * Going to be removed in the next minor version.
+ */
 export function createCoValueObservable<
   S extends CoValueOrZodSchema,
   const R extends ResolveQuery<S>,

package/src/implementation/zodSchema/runtimeConverters/zodSchemaToCoSchema.ts

@@ -61,19 +61,6 @@ export function tryZodSchemaToCoSchema<S extends z.core.$ZodType>(
         }
       };
 
-      if ("migration" in schema) {
-        const migration = schema.migration;
-        if (typeof migration !== "function") {
-          throw new Error("migration must be a function");
-        }
-        (coSchema.prototype as Account).migrate = async function (
-          this,
-          creationProps,
-        ) {
-          await migration(this, creationProps);
-        };
-      }
-
       coSchemasForZodSchemas.set(schema, coSchema as unknown as CoValueClass);
       return coSchema as unknown as CoValueClassFromZodSchema<S>;
     } else if (isZodArray(schema)) {
@@ -175,9 +162,19 @@ export function anySchemaToCoSchema<
     : never {
   if (isCoValueClass(schema)) {
     return schema as any;
-  } else {
-    return zodSchemaToCoSchema(schema as any) as any;
+  } else if ("getCoSchema" in schema) {
+    return (schema as any).getCoSchema() as any;
+  } else if ("def" in schema) {
+    const coSchema = tryZodSchemaToCoSchema(schema as z.core.$ZodType);
+    if (!coSchema) {
+      throw new Error(
+        `Unsupported zod type: ${(schema.def as any)?.type || JSON.stringify(schema)}`,
+      );
+    }
+    return coSchema as any;
   }
+
+  throw new Error(`Unsupported schema: ${JSON.stringify(schema)}`);
 }
 
 export function zodSchemaToCoSchemaOrKeepPrimitive<S extends z.core.$ZodType>(

package/src/implementation/zodSchema/schemaTypes/AccountSchema.ts

@@ -33,7 +33,7 @@ export type AccountSchema<
     }>;
     root: CoMapSchema<{}>;
   },
-> = Omit<CoMapSchema<Shape>, "create" | "load"> & {
+> = Omit<CoMapSchema<Shape>, "create" | "load" | "withMigration"> & {
   builtin: "Account";
 
   create: (options: {
@@ -64,6 +64,8 @@ export type AccountSchema<
       creationProps?: { name: string },
     ) => void,
   ): AccountSchema<Shape>;
+
+  getCoSchema: () => typeof Account;
 };
 
 export type DefaultProfileShape = {

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

@@ -57,6 +57,8 @@ export type CoFeedSchema<T extends z.core.$ZodType> = z.core.$ZodCustom<
       unsubscribe: () => void,
     ) => void,
   ): () => void;
+
+  getCoSchema: () => typeof CoFeed;
 };
 
 // less precise verion to avoid circularity issues and allow matching against

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

@@ -51,6 +51,8 @@ export type CoListSchema<T extends z.core.$ZodType> = z.core.$ZodArray<T> & {
     this: S,
     helpers: (Self: S) => T,
   ): WithHelpers<S, T>;
+
+  getCoSchema: () => typeof CoList;
 };
 
 // less precise verion to avoid circularity issues and allow matching against

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

@@ -97,6 +97,17 @@ export type CoMapSchema<
       this: S,
       helpers: (Self: S) => T,
     ): WithHelpers<S, T>;
+
+    withMigration(
+      migration: (
+        value: Resolved<
+          Simplify<CoMapInstanceCoValuesNullable<Shape>> & CoMap,
+          true
+        >,
+      ) => undefined,
+    ): CoMapSchema<Shape, Config, Owner>;
+
+    getCoSchema: () => typeof CoMap;
   };
 
 export type optionalKeys<Shape extends z.core.$ZodLooseShape> = {

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

@@ -1,7 +1,7 @@
 import { CoValueUniqueness } from "cojson";
 import {
   Account,
-  CoMap,
+  type CoMap,
   Group,
   ID,
   RefsToResolve,
@@ -83,6 +83,7 @@ export type CoRecordSchema<
     this: S,
     helpers: (Self: S) => T,
   ): WithHelpers<S, T>;
+  getCoSchema: () => typeof CoMap;
 };
 
 // less precise verion to avoid circularity issues and allow matching against

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

@@ -40,4 +40,5 @@ export type FileStreamSchema = z.core.$ZodCustom<FileStream, unknown> & {
     id: string,
     listener: (value: FileStream, unsubscribe: () => void) => void,
   ): () => void;
+  getCoSchema: () => typeof FileStream;
 };

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

@@ -24,4 +24,5 @@ export type PlainTextSchema = z.core.$ZodCustom<CoPlainText, unknown> & {
     listener: (value: CoPlainText, unsubscribe: () => void) => void,
   ): () => void;
   fromRaw(raw: RawCoPlainText): CoPlainText;
+  getCoSchema: () => typeof CoPlainText;
 };

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

@@ -22,4 +22,5 @@ export type RichTextSchema = z.core.$ZodCustom<CoRichText, unknown> & {
     id: string,
     listener: (value: CoRichText, unsubscribe: () => void) => void,
   ): () => void;
+  getCoSchema: () => typeof CoRichText;
 };