jazz-tools 0.14.28 → 0.15.1

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

@@ -0,0 +1,188 @@
+import { CoValueUniqueness } from "cojson";
+import {
+  Account,
+  CoMap,
+  Group,
+  RefsToResolve,
+  RefsToResolveStrict,
+  Resolved,
+  Simplify,
+  SubscribeListenerOptions,
+} from "../../../internal.js";
+import { AnonymousJazzAgent } from "../../anonymousJazzAgent.js";
+import { InstanceOrPrimitiveOfSchema } from "../typeConverters/InstanceOrPrimitiveOfSchema.js";
+import { InstanceOrPrimitiveOfSchemaCoValuesNullable } from "../typeConverters/InstanceOrPrimitiveOfSchemaCoValuesNullable.js";
+import { z } from "../zodReExport.js";
+import { WithHelpers } from "../zodSchema.js";
+
+export type CoMapSchema<
+  Shape extends z.core.$ZodLooseShape,
+  Config extends z.core.$ZodObjectConfig = z.core.$ZodObjectConfig,
+  Owner extends Account | Group = Account | Group,
+> = z.core.$ZodObject<Shape, Config> &
+  z.$ZodTypeDiscriminable & {
+    collaborative: true;
+
+    create: (
+      init: Simplify<CoMapInitZod<Shape>>,
+      options?:
+        | {
+            owner: Owner;
+            unique?: CoValueUniqueness["uniqueness"];
+          }
+        | Owner,
+    ) => (Shape extends Record<string, never>
+      ? {}
+      : {
+          -readonly [key in keyof Shape]: InstanceOrPrimitiveOfSchema<
+            Shape[key]
+          >;
+        }) &
+      (unknown extends Config["out"][string]
+        ? {}
+        : {
+            [key: string]: Config["out"][string];
+          }) &
+      CoMap;
+
+    load<
+      const R extends RefsToResolve<
+        Simplify<CoMapInstanceCoValuesNullable<Shape>> & CoMap
+      > = true,
+    >(
+      id: string,
+      options?: {
+        resolve?: RefsToResolveStrict<
+          Simplify<CoMapInstanceCoValuesNullable<Shape>> & CoMap,
+          R
+        >;
+        loadAs?: Account | AnonymousJazzAgent;
+        skipRetry?: boolean;
+      },
+    ): Promise<Resolved<
+      Simplify<CoMapInstanceCoValuesNullable<Shape>> & CoMap,
+      R
+    > | null>;
+
+    subscribe<
+      const R extends RefsToResolve<
+        Simplify<CoMapInstanceCoValuesNullable<Shape>> & CoMap
+      > = true,
+    >(
+      id: string,
+      options: SubscribeListenerOptions<
+        Simplify<CoMapInstanceCoValuesNullable<Shape>> & CoMap,
+        R
+      >,
+      listener: (
+        value: Resolved<
+          Simplify<CoMapInstanceCoValuesNullable<Shape>> & CoMap,
+          R
+        >,
+        unsubscribe: () => void,
+      ) => void,
+    ): () => void;
+
+    /** @deprecated Use `CoMap.upsertUnique` and `CoMap.loadUnique` instead. */
+    findUnique(
+      unique: CoValueUniqueness["uniqueness"],
+      ownerID: string,
+      as?: Account | Group | AnonymousJazzAgent,
+    ): string;
+
+    upsertUnique: <
+      const R extends RefsToResolve<
+        Simplify<CoMapInstanceCoValuesNullable<Shape>> & CoMap
+      > = true,
+    >(options: {
+      value: Simplify<CoMapInitZod<Shape>>;
+      unique: CoValueUniqueness["uniqueness"];
+      owner: Owner;
+      resolve?: RefsToResolveStrict<
+        Simplify<CoMapInstanceCoValuesNullable<Shape>> & CoMap,
+        R
+      >;
+    }) => Promise<Resolved<
+      Simplify<CoMapInstanceCoValuesNullable<Shape>> & CoMap,
+      R
+    > | null>;
+
+    loadUnique<
+      const R extends RefsToResolve<
+        Simplify<CoMapInstanceCoValuesNullable<Shape>> & CoMap
+      > = true,
+    >(
+      unique: CoValueUniqueness["uniqueness"],
+      ownerID: string,
+      options?: {
+        resolve?: RefsToResolveStrict<
+          Simplify<CoMapInstanceCoValuesNullable<Shape>> & CoMap,
+          R
+        >;
+        loadAs?: Account | AnonymousJazzAgent;
+      },
+    ): Promise<Resolved<
+      Simplify<CoMapInstanceCoValuesNullable<Shape>> & CoMap,
+      R
+    > | null>;
+
+    catchall<T extends z.core.$ZodType>(
+      schema: T,
+    ): CoMapSchema<Shape, z.core.$catchall<T>>;
+
+    /** @deprecated Define your helper methods separately, in standalone functions. */
+    withHelpers<S extends z.core.$ZodType, T extends object>(
+      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> = {
+  [key in keyof Shape]: Shape[key] extends z.core.$ZodOptional<any>
+    ? key
+    : never;
+}[keyof Shape];
+
+export type requiredKeys<Shape extends z.core.$ZodLooseShape> = {
+  [key in keyof Shape]: Shape[key] extends z.core.$ZodOptional<any>
+    ? never
+    : key;
+}[keyof Shape];
+
+export type CoMapInitZod<Shape extends z.core.$ZodLooseShape> = {
+  [key in optionalKeys<Shape>]?: NonNullable<
+    InstanceOrPrimitiveOfSchemaCoValuesNullable<Shape[key]>
+  >;
+} & {
+  [key in requiredKeys<Shape>]: NonNullable<
+    InstanceOrPrimitiveOfSchemaCoValuesNullable<Shape[key]>
+  >;
+} & { [key in keyof Shape]?: unknown };
+
+// less precise verion to avoid circularity issues and allow matching against
+export type AnyCoMapSchema<
+  Shape extends z.core.$ZodLooseShape = z.core.$ZodLooseShape,
+  Config extends z.core.$ZodObjectConfig = z.core.$ZodObjectConfig,
+> = z.core.$ZodObject<Shape, Config> & { collaborative: true };
+
+export type CoMapInstance<Shape extends z.core.$ZodLooseShape> = {
+  -readonly [key in keyof Shape]: InstanceOrPrimitiveOfSchema<Shape[key]>;
+} & CoMap;
+
+export type CoMapInstanceCoValuesNullable<Shape extends z.core.$ZodLooseShape> =
+  {
+    -readonly [key in keyof Shape]: InstanceOrPrimitiveOfSchemaCoValuesNullable<
+      Shape[key]
+    >;
+  };

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

@@ -0,0 +1,370 @@
+import {
+  type Account,
+  AccountCreationProps,
+  AccountSchema,
+  AnyCoMapSchema,
+  CoFeed,
+  CoFeedSchema,
+  CoListSchema,
+  CoMapSchema,
+  CoPlainText,
+  CoProfileSchema,
+  CoRecordSchema,
+  CoRichText,
+  DefaultProfileShape,
+  FileStream,
+  FileStreamSchema,
+  ImageDefinition,
+  PlainTextSchema,
+  Simplify,
+  zodSchemaToCoSchema,
+} from "../../internal.js";
+import { RichTextSchema } from "./schemaTypes/RichTextSchema.js";
+import { z } from "./zodReExport.js";
+
+function enrichCoMapSchema<Shape extends z.core.$ZodLooseShape>(
+  schema: z.ZodObject<
+    { -readonly [P in keyof Shape]: Shape[P] },
+    z.core.$strip
+  >,
+) {
+  const baseCatchall = schema.catchall;
+
+  const enrichedSchema = Object.assign(schema, {
+    collaborative: true,
+    create: (...args: any[]) => {
+      return coSchema.create(...args);
+    },
+    load: (...args: any[]) => {
+      return coSchema.load(...args);
+    },
+    subscribe: (...args: any[]) => {
+      return coSchema.subscribe(...args);
+    },
+    findUnique: (...args: any[]) => {
+      return coSchema.findUnique(...args);
+    },
+    upsertUnique: (...args: any[]) => {
+      return coSchema.upsertUnique(...args);
+    },
+    loadUnique: (...args: any[]) => {
+      return coSchema.loadUnique(...args);
+    },
+    catchall: (index: z.core.$ZodType) => {
+      return enrichCoMapSchema(baseCatchall(index));
+    },
+    withHelpers: (helpers: (Self: z.core.$ZodType) => object) => {
+      return Object.assign(schema, helpers(schema));
+    },
+    withMigration: (migration: (value: any) => undefined) => {
+      coSchema.prototype.migrate = migration;
+
+      return enrichedSchema;
+    },
+    getCoSchema: () => {
+      return coSchema;
+    },
+  }) as unknown as CoMapSchema<Shape>;
+
+  // Needs to be derived from the enriched schema
+  const coSchema = zodSchemaToCoSchema(enrichedSchema) as any;
+
+  return enrichedSchema;
+}
+
+export const coMapDefiner = <Shape extends z.core.$ZodLooseShape>(
+  shape: Shape,
+): CoMapSchema<Shape> => {
+  const objectSchema = z.object(shape).meta({
+    collaborative: true,
+  });
+
+  return enrichCoMapSchema(objectSchema);
+};
+
+function enrichAccountSchema<
+  Shape extends {
+    profile: AnyCoMapSchema<{
+      name: z.core.$ZodString<string>;
+      inbox?: z.core.$ZodOptional<z.core.$ZodString>;
+      inboxInvite?: z.core.$ZodOptional<z.core.$ZodString>;
+    }>;
+    root: AnyCoMapSchema;
+  },
+>(schema: z.ZodObject<Shape, z.core.$strip>) {
+  const enrichedSchema = Object.assign(schema, {
+    collaborative: true,
+    builtin: "Account",
+    create: (...args: any[]) => {
+      return coSchema.create(...args);
+    },
+    createAs: (...args: any[]) => {
+      return coSchema.createAs(...args);
+    },
+    getMe: (...args: any[]) => {
+      return coSchema.getMe(...args);
+    },
+    load: (...args: any[]) => {
+      return coSchema.load(...args);
+    },
+    subscribe: (...args: any[]) => {
+      return coSchema.subscribe(...args);
+    },
+    withHelpers: (helpers: (Self: z.core.$ZodType) => object) => {
+      return Object.assign(schema, helpers(schema));
+    },
+    fromRaw: (...args: any[]) => {
+      return coSchema.fromRaw(...args);
+    },
+    withMigration: (
+      migration: (
+        value: any,
+        creationProps?: AccountCreationProps,
+      ) => void | Promise<void>,
+    ) => {
+      (coSchema.prototype as Account).migrate = async function (
+        this,
+        creationProps,
+      ) {
+        await migration(this, creationProps);
+      };
+
+      return enrichedSchema;
+    },
+    getCoSchema: () => {
+      return coSchema;
+    },
+  }) as unknown as AccountSchema<Shape>;
+
+  // Needs to be derived from the enriched schema
+  const coSchema = zodSchemaToCoSchema(enrichedSchema) as any;
+
+  return enrichedSchema;
+}
+
+export const coAccountDefiner = <
+  Shape extends {
+    profile: AnyCoMapSchema<{
+      name: z.core.$ZodString<string>;
+      inbox?: z.core.$ZodOptional<z.core.$ZodString>;
+      inboxInvite?: z.core.$ZodOptional<z.core.$ZodString>;
+    }>;
+    root: AnyCoMapSchema;
+  },
+>(
+  shape: Shape = {
+    profile: coMapDefiner({
+      name: z.string(),
+      inbox: z.optional(z.string()),
+      inboxInvite: z.optional(z.string()),
+    }),
+    root: coMapDefiner({}),
+  } as unknown as Shape,
+): AccountSchema<Shape> => {
+  const objectSchema = z.object(shape).meta({
+    collaborative: true,
+  });
+
+  return enrichAccountSchema(objectSchema) as unknown as AccountSchema<Shape>;
+};
+
+export const coRecordDefiner = <
+  K extends z.core.$ZodString<string>,
+  V extends z.core.$ZodType,
+>(
+  _keyType: K,
+  valueType: V,
+): CoRecordSchema<K, V> => {
+  return coMapDefiner({}).catchall(valueType) as unknown as CoRecordSchema<
+    K,
+    V
+  >;
+};
+
+function enrichCoListSchema<T extends z.core.$ZodType>(schema: z.ZodArray<T>) {
+  const enrichedSchema = Object.assign(schema, {
+    collaborative: true,
+    create: (...args: any[]) => {
+      return coSchema.create(...args);
+    },
+    load: (...args: any[]) => {
+      return coSchema.load(...args);
+    },
+    subscribe: (...args: any[]) => {
+      return coSchema.subscribe(...args);
+    },
+    withHelpers: (helpers: (Self: z.core.$ZodType) => object) => {
+      return Object.assign(schema, helpers(schema));
+    },
+    getCoSchema: () => {
+      return coSchema;
+    },
+  }) as unknown as CoListSchema<T>;
+
+  // Needs to be derived from the enriched schema
+  const coSchema = zodSchemaToCoSchema(enrichedSchema) as any;
+
+  return enrichedSchema;
+}
+
+export const coListDefiner = <T extends z.core.$ZodType>(
+  element: T,
+): CoListSchema<T> => {
+  const arraySchema = z.array(element).meta({
+    collaborative: true,
+  });
+
+  return enrichCoListSchema(arraySchema);
+};
+
+export const coProfileDefiner = <
+  Shape extends z.core.$ZodLooseShape = Simplify<DefaultProfileShape>,
+>(
+  shape: Shape & {
+    name?: z.core.$ZodString<string>;
+    inbox?: z.core.$ZodOptional<z.core.$ZodString>;
+    inboxInvite?: z.core.$ZodOptional<z.core.$ZodString>;
+  } = {} as any,
+): CoProfileSchema<Shape> => {
+  const ehnancedShape = Object.assign(shape ?? {}, {
+    name: z.string(),
+    inbox: z.optional(z.string()),
+    inboxInvite: z.optional(z.string()),
+  });
+
+  return coMapDefiner(ehnancedShape) as CoProfileSchema<Shape>;
+};
+
+function enrichCoFeedSchema<T extends z.core.$ZodType>(
+  schema: z.ZodCustom<CoFeed<unknown>, unknown>,
+  element: T,
+) {
+  const enrichedSchema = Object.assign(schema, {
+    collaborative: true,
+    builtin: "CoFeed",
+    element,
+    create: (...args: any[]) => {
+      return coSchema.create(...args);
+    },
+    load: (...args: any[]) => {
+      return coSchema.load(...args);
+    },
+    subscribe: (...args: any[]) => {
+      return coSchema.subscribe(...args);
+    },
+    withHelpers: (helpers: (Self: z.core.$ZodType) => object) => {
+      return Object.assign(schema, helpers(schema));
+    },
+    getCoSchema: () => {
+      return coSchema;
+    },
+  }) as unknown as CoFeedSchema<T>;
+
+  // Needs to be derived from the enriched schema
+  const coSchema = zodSchemaToCoSchema(enrichedSchema) as any;
+
+  return enrichedSchema;
+}
+
+export const coFeedDefiner = <T extends z.core.$ZodType>(
+  element: T,
+): CoFeedSchema<T> => {
+  return enrichCoFeedSchema(z.instanceof(CoFeed), element);
+};
+
+function enrichFileStreamSchema(schema: z.ZodCustom<FileStream, unknown>) {
+  const enrichedSchema = Object.assign(schema, {
+    collaborative: true,
+    builtin: "FileStream",
+    create: (...args: any[]) => {
+      return coSchema.create(...args);
+    },
+    createFromBlob: (...args: any[]) => {
+      return coSchema.createFromBlob(...args);
+    },
+    load: (...args: any[]) => {
+      return coSchema.load(...args);
+    },
+    loadAsBlob: (...args: any[]) => {
+      return coSchema.loadAsBlob(...args);
+    },
+    subscribe: (...args: any[]) => {
+      return coSchema.subscribe(...args);
+    },
+    getCoSchema: () => {
+      return coSchema;
+    },
+  }) as unknown as FileStreamSchema;
+
+  // Needs to be derived from the enriched schema
+  const coSchema = zodSchemaToCoSchema(enrichedSchema) as any;
+
+  return enrichedSchema;
+}
+
+export const coFileStreamDefiner = (): FileStreamSchema => {
+  return enrichFileStreamSchema(z.instanceof(FileStream));
+};
+
+function enrichPlainTextSchema(schema: z.ZodCustom<CoPlainText, unknown>) {
+  const enrichedSchema = Object.assign(schema, {
+    collaborative: true,
+    builtin: "CoPlainText",
+    create: (...args: any[]) => {
+      return coSchema.create(...args);
+    },
+    load: (...args: any[]) => {
+      return coSchema.load(...args);
+    },
+    subscribe: (...args: any[]) => {
+      return coSchema.subscribe(...args);
+    },
+    fromRaw: (...args: any[]) => {
+      return coSchema.fromRaw(...args);
+    },
+    getCoSchema: () => {
+      return coSchema;
+    },
+  }) as unknown as PlainTextSchema;
+
+  // Needs to be derived from the enriched schema
+  const coSchema = zodSchemaToCoSchema(enrichedSchema) as any;
+
+  return enrichedSchema;
+}
+
+export const coPlainTextDefiner = (): PlainTextSchema => {
+  return enrichPlainTextSchema(z.instanceof(CoPlainText));
+};
+
+function enrichRichTextSchema(schema: z.ZodCustom<CoRichText, unknown>) {
+  const enrichedSchema = Object.assign(schema, {
+    collaborative: true,
+    builtin: "CoRichText",
+    create: (...args: any[]) => {
+      return coSchema.create(...args);
+    },
+    load: (...args: any[]) => {
+      return coSchema.load(...args);
+    },
+    subscribe: (...args: any[]) => {
+      return coSchema.subscribe(...args);
+    },
+    getCoSchema: () => {
+      return coSchema;
+    },
+  }) as unknown as RichTextSchema;
+
+  // Needs to be derived from the enriched schema
+  const coSchema = zodSchemaToCoSchema(enrichedSchema) as any;
+
+  return enrichedSchema;
+}
+
+export const coRichTextDefiner = (): RichTextSchema => {
+  return enrichRichTextSchema(z.instanceof(CoRichText));
+};
+
+export const coImageDefiner = (): typeof ImageDefinition => {
+  return ImageDefinition;
+};

package/src/tools/index.ts

@@ -0,0 +1,8 @@
+export * from "./exports.js";
+
+export {
+  MAX_RECOMMENDED_TX_SIZE,
+  cojsonInternals,
+  logger,
+  LogLevel,
+} from "cojson";

package/src/tools/subscribe/CoValueCoreSubscription.ts

@@ -0,0 +1,74 @@
+import { CoValueCore, LocalNode, RawCoMap, RawCoValue } from "cojson";
+
+export class CoValueCoreSubscription {
+  _unsubscribe: () => void = () => {};
+  unsubscribed = false;
+
+  value: RawCoMap | undefined;
+
+  constructor(
+    public node: LocalNode,
+    public id: string,
+    public listener: (value: RawCoValue | "unavailable") => void,
+    public skipRetry?: boolean,
+  ) {
+    const entry = this.node.getCoValue(this.id as any);
+
+    if (entry?.isAvailable()) {
+      this.subscribe(entry.getCurrentContent());
+    } else {
+      this.node
+        .loadCoValueCore(this.id as any, undefined, skipRetry)
+        .then((value) => {
+          if (this.unsubscribed) return;
+
+          if (value.isAvailable()) {
+            this.subscribe(value.getCurrentContent());
+          } else {
+            this.subscribeToState();
+            this.listener("unavailable");
+          }
+        });
+    }
+  }
+
+  subscribeToState() {
+    const entry = this.node.getCoValue(this.id as any);
+    const handleStateChange = (
+      core: CoValueCore,
+      unsubFromStateChange: () => void,
+    ) => {
+      if (this.unsubscribed) {
+        unsubFromStateChange();
+        return;
+      }
+
+      if (core.isAvailable()) {
+        this.subscribe(core.getCurrentContent());
+        unsubFromStateChange();
+      }
+    };
+
+    const unsubFromStateChange = entry.subscribe(handleStateChange);
+
+    this._unsubscribe = () => {
+      unsubFromStateChange();
+    };
+  }
+
+  subscribe(value: RawCoValue) {
+    if (this.unsubscribed) return;
+
+    this._unsubscribe = value.subscribe((value) => {
+      this.listener(value);
+    });
+
+    this.listener(value);
+  }
+
+  unsubscribe() {
+    if (this.unsubscribed) return;
+    this.unsubscribed = true;
+    this._unsubscribe();
+  }
+}