@rocicorp/zero 0.25.0 → 0.26.0-canary.0

package/out/zql/src/mutate/mutator-registry.js

@@ -0,0 +1,88 @@
+import { deepMerge, isPlainObject } from "../../../shared/src/deep-merge.js";
+import { getValueAtPath, iterateLeaves } from "../../../shared/src/object-traversal.js";
+import { validateInput } from "../query/validate-input.js";
+import { isMutatorDefinition, isMutator } from "./mutator.js";
+function defineMutators(definitionsOrBase, maybeOverrides) {
+  function processDefinitions(definitions, path) {
+    const result = {
+      ["~"]: "MutatorRegistry"
+    };
+    for (const [key, value] of Object.entries(definitions)) {
+      path.push(key);
+      const name = path.join(".");
+      if (isMutatorDefinition(value)) {
+        result[key] = createMutator(name, value);
+      } else {
+        result[key] = processDefinitions(value, path);
+      }
+      path.pop();
+    }
+    return result;
+  }
+  if (maybeOverrides !== void 0) {
+    let base;
+    if (!isMutatorRegistry(definitionsOrBase)) {
+      base = processDefinitions(definitionsOrBase, []);
+    } else {
+      base = definitionsOrBase;
+    }
+    const processed = processDefinitions(maybeOverrides, []);
+    const merged = deepMerge(base, processed, isMutatorLeaf);
+    merged["~"] = "MutatorRegistry";
+    return merged;
+  }
+  return processDefinitions(
+    definitionsOrBase,
+    []
+  );
+}
+const isMutatorLeaf = (value) => !isPlainObject(value) || isMutator(value);
+function defineMutatorsWithType() {
+  return defineMutators;
+}
+function isMutatorRegistry(value) {
+  return typeof value === "object" && value !== null && value["~"] === "MutatorRegistry";
+}
+function createMutator(name, definition) {
+  const { validator } = definition;
+  const fn = async (options) => {
+    const validatedArgs = validator ? validateInput(name, options.args, validator, "mutator") : options.args;
+    await definition.fn({
+      args: validatedArgs,
+      ctx: options.ctx,
+      tx: options.tx
+    });
+  };
+  const mutator = (args) => ({
+    args,
+    "~": "MutateRequest",
+    "mutator": mutator
+  });
+  mutator.mutatorName = name;
+  mutator.fn = fn;
+  mutator["~"] = "Mutator";
+  return mutator;
+}
+function* iterateMutators(registry) {
+  yield* iterateLeaves(registry, isMutator);
+}
+function getMutator(registry, name) {
+  const m = getValueAtPath(registry, name, ".");
+  return m;
+}
+function mustGetMutator(registry, name) {
+  const mutator = getMutator(registry, name);
+  if (mutator === void 0) {
+    throw new Error(`Mutator not found: ${name}`);
+  }
+  return mutator;
+}
+export {
+  defineMutators,
+  defineMutatorsWithType,
+  getMutator,
+  isMutatorRegistry,
+  iterateMutators,
+  mustGetMutator
+};
+//# sourceMappingURL=mutator-registry.js.map

package/out/zql/src/mutate/mutator-registry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mutator-registry.js","sources":["../../../../../zql/src/mutate/mutator-registry.ts"],"sourcesContent":["import {\n  deepMerge,\n  isPlainObject,\n  type DeepMerge,\n} from '../../../shared/src/deep-merge.ts';\nimport type {ReadonlyJSONValue} from '../../../shared/src/json.ts';\nimport {\n  getValueAtPath,\n  iterateLeaves,\n} from '../../../shared/src/object-traversal.ts';\nimport type {DefaultSchema} from '../../../zero-types/src/default-types.ts';\nimport type {Schema} from '../../../zero-types/src/schema.ts';\nimport {validateInput} from '../query/validate-input.ts';\nimport type {Transaction} from './custom.ts';\nimport {\n  isMutator,\n  isMutatorDefinition,\n  type AnyMutator,\n  type AnyMutatorDefinition,\n  type MutateRequest,\n  type MutateRequestTypes,\n  type Mutator,\n  type MutatorDefinition,\n  type MutatorDefinitionFunction,\n  type MutatorTypes,\n} from './mutator.ts';\n\n/**\n * Creates a MutatorRegistry from a tree of MutatorDefinitions,\n * optionally extending a base MutatorRegistry.\n *\n * @example\n * ```ts\n * // Create a new registry\n * const mutators = defineMutators({\n *   user: {\n *     create: defineMutator(...),\n *     delete: defineMutator(...),\n *   },\n *   post: {\n *     publish: defineMutator(...),\n *   },\n * });\n *\n * // Extend an existing registry (e.g., for server-side overrides)\n * const serverMutators = defineMutators(mutators, {\n *   user: {\n *     create: defineMutator(...),  // overrides mutators.user.create\n *   },\n *   // post.publish is inherited from mutators\n * });\n *\n * // Access mutators by path\n * const mr = mutators.user.create({name: 'Alice'});\n *\n * // Execute on client\n * zero.mutate(mr);\n *\n * // Execute on server\n * mr.mutator.fn({tx, ctx, args: mr.args});\n *\n * // Lookup by name (for server-side dispatch)\n * const mutator = getMutator(mutators, 'user.create');\n * ```\n */\nexport function defineMutators<\n  // let MD infer freely so defaults aren't erased by a MutatorDefinitions constraint\n  const MD,\n  S extends Schema = DefaultSchema,\n>(\n  // we assert types here for clear error messages\n  definitions: MD & AssertMutatorDefinitions<MD>,\n): MutatorRegistry<EnsureMutatorDefinitions<MD>, S>;\n\nexport function defineMutators<\n  // same as MD above, but for TBase and TOverrides\n  const TBase,\n  const TOverrides,\n  S extends Schema = DefaultSchema,\n>(\n  base:\n    | MutatorRegistry<EnsureMutatorDefinitions<TBase>, S>\n    | (TBase & AssertMutatorDefinitions<TBase>),\n  overrides: TOverrides & AssertMutatorDefinitions<TOverrides>,\n): MutatorRegistry<\n  DeepMerge<\n    EnsureMutatorDefinitions<TBase>,\n    EnsureMutatorDefinitions<TOverrides>,\n    AnyMutatorDefinition\n  >,\n  S\n>;\n\nexport function defineMutators(\n  definitionsOrBase: MutatorDefinitions | AnyMutatorRegistry,\n  maybeOverrides?: MutatorDefinitions,\n): AnyMutatorRegistry {\n  function processDefinitions(\n    definitions: MutatorDefinitions,\n    path: string[],\n  ): Record<string | symbol, unknown> {\n    const result: Record<string | symbol, unknown> = {\n      ['~']: 'MutatorRegistry',\n    };\n\n    for (const [key, value] of Object.entries(definitions)) {\n      path.push(key);\n      const name = path.join('.');\n\n      if (isMutatorDefinition(value)) {\n        result[key] = createMutator(name, value);\n      } else {\n        // Nested definitions\n        result[key] = processDefinitions(value, path);\n      }\n      path.pop();\n    }\n\n    return result;\n  }\n\n  if (maybeOverrides !== undefined) {\n    // Merge base and overrides\n    let base: Record<string | symbol, unknown>;\n    if (!isMutatorRegistry(definitionsOrBase)) {\n      base = processDefinitions(definitionsOrBase, []);\n    } else {\n      base = definitionsOrBase;\n    }\n\n    const processed = processDefinitions(maybeOverrides, []);\n\n    const merged = deepMerge(base, processed, isMutatorLeaf);\n    merged['~'] = 'MutatorRegistry';\n    return merged as AnyMutatorRegistry;\n  }\n\n  return processDefinitions(\n    definitionsOrBase as MutatorDefinitions,\n    [],\n  ) as AnyMutatorRegistry;\n}\n\nconst isMutatorLeaf = (value: unknown): boolean =>\n  !isPlainObject(value) || isMutator(value);\n\n/**\n * Creates a function that can be used to define mutators with a specific schema.\n */\nexport function defineMutatorsWithType<\n  TSchema extends Schema,\n>(): TypedDefineMutators<TSchema> {\n  return defineMutators;\n}\n\n/**\n * The return type of defineMutatorsWithType. A function matching the\n * defineMutators overloads but with Schema pre-bound.\n */\ntype TypedDefineMutators<S extends Schema> = {\n  // Single definitions\n  <MD>(\n    definitions: MD & AssertMutatorDefinitions<MD>,\n  ): MutatorRegistry<EnsureMutatorDefinitions<MD>, S>;\n\n  // Base and overrides\n  <TBase, TOverrides>(\n    base:\n      | MutatorRegistry<EnsureMutatorDefinitions<TBase>, S>\n      | (TBase & AssertMutatorDefinitions<TBase>),\n    overrides: TOverrides,\n  ): MutatorRegistry<\n    DeepMerge<\n      EnsureMutatorDefinitions<TBase>,\n      EnsureMutatorDefinitions<TOverrides>,\n      AnyMutatorDefinition\n    >,\n    S\n  >;\n};\n\nexport type AssertMutatorDefinitions<MD> = MD extends MutatorDefinitions\n  ? unknown\n  : never;\n\nexport type EnsureMutatorDefinitions<MD> = MD extends MutatorDefinitions\n  ? MD\n  : never;\n\n/**\n * Checks if a value is a MutatorRegistry.\n */\nexport function isMutatorRegistry(value: unknown): value is AnyMutatorRegistry {\n  return (\n    typeof value === 'object' &&\n    value !== null &&\n    (value as Record<string, unknown>)['~'] === 'MutatorRegistry'\n  );\n}\n\nexport type MutatorRegistryTypes<TSchema extends Schema> = 'MutatorRegistry' & {\n  readonly $schema: TSchema;\n};\n\n/**\n * The result of defineMutators(). A tree of Mutators with a tag for detection.\n */\nexport type MutatorRegistry<\n  MD extends MutatorDefinitions,\n  TSchema extends Schema,\n> = ToMutatorTree<MD, TSchema> & {\n  ['~']: MutatorRegistryTypes<TSchema>;\n};\n\n/**\n * A branded type for use in type constraints. Use this instead of\n * `MutatorRegistry<S, C, any>` to avoid TypeScript drilling into\n * the complex ToMutatorTree structure and hitting variance issues.\n */\nexport type AnyMutatorRegistry = {\n  ['~']: MutatorRegistryTypes<Schema>;\n  [key: string]: unknown;\n};\n\n/**\n * Transforms a MutatorDefinitions into a tree of Mutators.\n * Each MutatorDefinition becomes a Mutator at the same path.\n * Uses TInput for the callable args (TOutput is only used internally for validation).\n */\nexport type ToMutatorTree<\n  MD extends MutatorDefinitions,\n  TSchema extends Schema,\n> = {\n  readonly [K in keyof MD]: MD[K] extends AnyMutatorDefinition\n    ? // pull types from the phantom property\n      Mutator<\n        MD[K]['~']['$input'],\n        TSchema,\n        MD[K]['~']['$context'],\n        MD[K]['~']['$wrappedTransaction']\n      >\n    : MD[K] extends MutatorDefinitions\n      ? ToMutatorTree<MD[K], TSchema>\n      : never;\n};\n\nexport type FromMutatorTree<\n  MD extends MutatorDefinitions,\n  TSchema extends Schema,\n> = {\n  readonly [K in keyof MD]: MD[K] extends AnyMutatorDefinition\n    ? // pull types from the phantom property\n      Mutator<\n        ReadonlyJSONValue | undefined, // intentionally left as generic to avoid variance issues\n        TSchema,\n        MD[K]['~']['$context'],\n        MD[K]['~']['$wrappedTransaction']\n      >\n    : MD[K] extends MutatorDefinitions\n      ? FromMutatorTree<MD[K], TSchema>\n      : never;\n}[keyof MD];\n\n/**\n * A tree of MutatorDefinitions, possibly nested.\n */\nexport type MutatorDefinitions = {\n  readonly [key: string]: AnyMutatorDefinition | MutatorDefinitions;\n};\n\nfunction createMutator<\n  ArgsInput extends ReadonlyJSONValue | undefined,\n  ArgsOutput extends ReadonlyJSONValue | undefined,\n  TSchema extends Schema,\n  C,\n  TWrappedTransaction,\n>(\n  name: string,\n  definition: MutatorDefinition<ArgsInput, ArgsOutput, C, TWrappedTransaction>,\n): Mutator<ArgsInput, TSchema, C, TWrappedTransaction> {\n  const {validator} = definition;\n\n  // fn takes ReadonlyJSONValue args because it's called during rebase (from\n  // stored JSON) and on the server (from wire format). Validation happens here.\n  const fn: MutatorDefinitionFunction<\n    ArgsInput,\n    C,\n    Transaction<TSchema, TWrappedTransaction>\n  > = async options => {\n    const validatedArgs = validator\n      ? validateInput(name, options.args, validator, 'mutator')\n      : (options.args as unknown as ArgsOutput);\n    await definition.fn({\n      args: validatedArgs,\n      ctx: options.ctx,\n      tx: options.tx,\n    });\n  };\n\n  const mutator = (\n    args: ArgsInput,\n  ): MutateRequest<ArgsInput, TSchema, C, TWrappedTransaction> => ({\n    args,\n    '~': 'MutateRequest' as MutateRequestTypes<\n      ArgsInput,\n      TSchema,\n      C,\n      TWrappedTransaction\n    >,\n    'mutator': mutator as unknown as Mutator<\n      ArgsInput,\n      TSchema,\n      C,\n      TWrappedTransaction\n    >,\n  });\n\n  mutator.mutatorName = name;\n  mutator.fn = fn;\n  mutator['~'] = 'Mutator' as unknown as MutatorTypes<\n    ArgsInput,\n    TSchema,\n    C,\n    TWrappedTransaction\n  >;\n\n  return mutator as unknown as Mutator<\n    ArgsInput,\n    TSchema,\n    C,\n    TWrappedTransaction\n  >;\n}\n\nexport function* iterateMutators(\n  registry: AnyMutatorRegistry,\n): Iterable<AnyMutator> {\n  yield* iterateLeaves(registry, isMutator);\n}\n\n/**\n * Gets a Mutator by its dot-separated name from a MutatorRegistry.\n * Returns undefined if not found.\n */\nexport function getMutator<\n  MD extends MutatorDefinitions,\n  TSchema extends Schema,\n>(\n  registry: MutatorRegistry<MD, TSchema>,\n  name: string,\n): FromMutatorTree<MD, TSchema> | undefined {\n  const m = getValueAtPath(registry, name, '.');\n  return m as FromMutatorTree<MD, TSchema> | undefined;\n}\n\n/**\n * Gets a Mutator by its dot-separated name from a MutatorRegistry.\n * Throws if not found.\n */\nexport function mustGetMutator<\n  MD extends MutatorDefinitions,\n  TSchema extends Schema,\n>(\n  registry: MutatorRegistry<MD, TSchema>,\n  name: string,\n): FromMutatorTree<MD, TSchema> {\n  const mutator = getMutator(registry, name);\n  if (mutator === undefined) {\n    throw new Error(`Mutator not found: ${name}`);\n  }\n  return mutator;\n}\n"],"names":[],"mappings":";;;;AA6FO,SAAS,eACd,mBACA,gBACoB;AACpB,WAAS,mBACP,aACA,MACkC;AAClC,UAAM,SAA2C;AAAA,MAC/C,CAAC,GAAG,GAAG;AAAA,IAAA;AAGT,eAAW,CAAC,KAAK,KAAK,KAAK,OAAO,QAAQ,WAAW,GAAG;AACtD,WAAK,KAAK,GAAG;AACb,YAAM,OAAO,KAAK,KAAK,GAAG;AAE1B,UAAI,oBAAoB,KAAK,GAAG;AAC9B,eAAO,GAAG,IAAI,cAAc,MAAM,KAAK;AAAA,MACzC,OAAO;AAEL,eAAO,GAAG,IAAI,mBAAmB,OAAO,IAAI;AAAA,MAC9C;AACA,WAAK,IAAA;AAAA,IACP;AAEA,WAAO;AAAA,EACT;AAEA,MAAI,mBAAmB,QAAW;AAEhC,QAAI;AACJ,QAAI,CAAC,kBAAkB,iBAAiB,GAAG;AACzC,aAAO,mBAAmB,mBAAmB,EAAE;AAAA,IACjD,OAAO;AACL,aAAO;AAAA,IACT;AAEA,UAAM,YAAY,mBAAmB,gBAAgB,EAAE;AAEvD,UAAM,SAAS,UAAU,MAAM,WAAW,aAAa;AACvD,WAAO,GAAG,IAAI;AACd,WAAO;AAAA,EACT;AAEA,SAAO;AAAA,IACL;AAAA,IACA,CAAA;AAAA,EAAC;AAEL;AAEA,MAAM,gBAAgB,CAAC,UACrB,CAAC,cAAc,KAAK,KAAK,UAAU,KAAK;AAKnC,SAAS,yBAEkB;AAChC,SAAO;AACT;AAuCO,SAAS,kBAAkB,OAA6C;AAC7E,SACE,OAAO,UAAU,YACjB,UAAU,QACT,MAAkC,GAAG,MAAM;AAEhD;AAwEA,SAAS,cAOP,MACA,YACqD;AACrD,QAAM,EAAC,cAAa;AAIpB,QAAM,KAIF,OAAM,YAAW;AACnB,UAAM,gBAAgB,YAClB,cAAc,MAAM,QAAQ,MAAM,WAAW,SAAS,IACrD,QAAQ;AACb,UAAM,WAAW,GAAG;AAAA,MAClB,MAAM;AAAA,MACN,KAAK,QAAQ;AAAA,MACb,IAAI,QAAQ;AAAA,IAAA,CACb;AAAA,EACH;AAEA,QAAM,UAAU,CACd,UAC+D;AAAA,IAC/D;AAAA,IACA,KAAK;AAAA,IAML,WAAW;AAAA,EAAA;AAQb,UAAQ,cAAc;AACtB,UAAQ,KAAK;AACb,UAAQ,GAAG,IAAI;AAOf,SAAO;AAMT;AAEO,UAAU,gBACf,UACsB;AACtB,SAAO,cAAc,UAAU,SAAS;AAC1C;AAMO,SAAS,WAId,UACA,MAC0C;AAC1C,QAAM,IAAI,eAAe,UAAU,MAAM,GAAG;AAC5C,SAAO;AACT;AAMO,SAAS,eAId,UACA,MAC8B;AAC9B,QAAM,UAAU,WAAW,UAAU,IAAI;AACzC,MAAI,YAAY,QAAW;AACzB,UAAM,IAAI,MAAM,sBAAsB,IAAI,EAAE;AAAA,EAC9C;AACA,SAAO;AACT;"}

package/out/zql/src/mutate/mutator.d.ts

@@ -0,0 +1,94 @@
+import type { StandardSchemaV1 } from '@standard-schema/spec';
+import type { ReadonlyJSONValue } from '../../../shared/src/json.ts';
+import type { DefaultContext, DefaultSchema, DefaultWrappedTransaction } from '../../../zero-types/src/default-types.ts';
+import type { Schema } from '../../../zero-types/src/schema.ts';
+import type { AnyTransaction, Transaction } from './custom.ts';
+export type MutatorDefinitionTypes<TInput extends ReadonlyJSONValue | undefined, TOutput, TContext, TWrappedTransaction> = 'MutatorDefinition' & {
+    readonly $input: TInput;
+    readonly $output: TOutput;
+    readonly $context: TContext;
+    readonly $wrappedTransaction: TWrappedTransaction;
+};
+export type MutatorDefinition<TInput extends ReadonlyJSONValue | undefined, TOutput extends ReadonlyJSONValue | undefined, TContext = DefaultContext, TWrappedTransaction = DefaultWrappedTransaction> = {
+    readonly 'fn': MutatorDefinitionFunction<TOutput, TContext, AnyTransaction>;
+    readonly 'validator': StandardSchemaV1<TInput, TOutput> | undefined;
+    readonly '~': MutatorDefinitionTypes<TInput, TOutput, TContext, TWrappedTransaction>;
+};
+export type AnyMutatorDefinition = MutatorDefinition<any, any, any, any>;
+export declare function isMutatorDefinition(f: unknown): f is AnyMutatorDefinition;
+export declare function defineMutator<TInput extends ReadonlyJSONValue | undefined = ReadonlyJSONValue | undefined, TSchema extends Schema = DefaultSchema, TContext = DefaultContext, TWrappedTransaction = DefaultWrappedTransaction>(mutator: MutatorDefinitionFunction<TInput, TContext, Transaction<TSchema, TWrappedTransaction>>): MutatorDefinition<TInput, TInput, TContext, TWrappedTransaction>;
+export declare function defineMutator<TInput extends ReadonlyJSONValue | undefined = undefined, TOutput extends ReadonlyJSONValue | undefined = TInput, TSchema extends Schema = DefaultSchema, TContext = DefaultContext, TWrappedTransaction = DefaultWrappedTransaction>(validator: StandardSchemaV1<TInput, TOutput>, mutator: MutatorDefinitionFunction<TOutput, TContext, Transaction<TSchema, TWrappedTransaction>>): MutatorDefinition<TInput, TOutput, TContext, TWrappedTransaction>;
+export declare function defineMutatorWithType<TSchema extends Schema, TContext = unknown, TWrappedTransaction = unknown>(): TypedDefineMutator<TSchema, TContext, TWrappedTransaction>;
+/**
+ * The return type of defineMutatorWithType. A function matching the
+ * defineMutator overloads but with Schema, Context, and WrappedTransaction
+ * pre-bound.
+ *
+ * This is used as a workaround to using DefaultTypes (e.g. when using
+ * multiple Zero instances).
+ */
+type TypedDefineMutator<TSchema extends Schema, TContext, TWrappedTransaction> = {
+    <TArgs extends ReadonlyJSONValue | undefined>(mutator: MutatorDefinitionFunction<TArgs, TContext, Transaction<TSchema, TWrappedTransaction>>): MutatorDefinition<TArgs, TArgs, TContext, TWrappedTransaction>;
+    <TInput extends ReadonlyJSONValue | undefined, TOutput extends ReadonlyJSONValue | undefined>(validator: StandardSchemaV1<TInput, TOutput>, mutator: MutatorDefinitionFunction<TOutput, TContext, Transaction<TSchema, TWrappedTransaction>>): MutatorDefinition<TInput, TOutput, TContext, TWrappedTransaction>;
+};
+export type MutatorDefinitionFunction<TOutput extends ReadonlyJSONValue | undefined, TContext, TTransaction> = (options: {
+    args: TOutput;
+    ctx: TContext;
+    tx: TTransaction;
+}) => Promise<void>;
+export type MutatorTypes<TInput extends ReadonlyJSONValue | undefined, TSchema extends Schema, TContext, TWrappedTransaction> = 'Mutator' & {
+    readonly $input: TInput;
+    readonly $schema: TSchema;
+    readonly $context: TContext;
+    readonly $wrappedTransaction: TWrappedTransaction;
+};
+/**
+ * A callable wrapper around a MutatorDefinition, created by `defineMutators()`.
+ *
+ * Accessed like `mutators.foo.bar`, and called to create a MutateRequest:
+ * `mutators.foo.bar(42)` returns a `MutateRequest`.
+ *
+ * The `fn` property is used for execution and takes raw JSON args (for rebase
+ * and server wire format cases) that are validated internally.
+ */
+export type Mutator<TInput extends ReadonlyJSONValue | undefined, TSchema extends Schema = DefaultSchema, TContext = DefaultContext, TWrappedTransaction = DefaultWrappedTransaction> = {
+    readonly 'mutatorName': string;
+    /**
+     * Execute the mutation. Args are ReadonlyJSONValue because this is called
+     * during rebase (from stored JSON) and on the server (from wire format).
+     * Validation happens internally before the recipe function runs.
+     */
+    readonly 'fn': MutatorDefinitionFunction<TInput, TContext, Transaction<TSchema, TWrappedTransaction>>;
+    readonly '~': MutatorTypes<TInput, TSchema, TContext, TWrappedTransaction>;
+} & MutatorCallable<TInput, TSchema, TContext, TWrappedTransaction>;
+type MutatorCallable<TInput extends ReadonlyJSONValue | undefined, TSchema extends Schema, TContext, TWrappedTransaction> = [TInput] extends [undefined] ? () => MutateRequest<TInput, TSchema, TContext, TWrappedTransaction> : undefined extends TInput ? {
+    (): MutateRequest<TInput, TSchema, TContext, TWrappedTransaction>;
+    (args?: TInput): MutateRequest<TInput, TSchema, TContext, TWrappedTransaction>;
+} : {
+    (args: TInput): MutateRequest<TInput, TSchema, TContext, TWrappedTransaction>;
+};
+export type AnyMutator = Mutator<any, any, any, any>;
+/**
+ * Checks if a value is a Mutator (the result of processing a MutatorDefinition
+ * through defineMutators).
+ */
+export declare function isMutator<S extends Schema>(value: unknown): value is Mutator<any, S, any, any>;
+export type MutateRequestTypes<TInput extends ReadonlyJSONValue | undefined, TSchema extends Schema, TContext, TWrappedTransaction> = 'MutateRequest' & {
+    readonly $input: TInput;
+    readonly $schema: TSchema;
+    readonly $context: TContext;
+    readonly $wrappedTransaction: TWrappedTransaction;
+};
+/**
+ * The result of calling a Mutator with arguments.
+ *
+ * Created by `mutators.foo.bar(42)`, executed by `zero.mutate(mr)` on the client
+ * or `mr.mutator.fn({tx, ctx, args: mr.args})` on the server.
+ */
+export type MutateRequest<TInput extends ReadonlyJSONValue | undefined, TSchema extends Schema = DefaultSchema, TContext = DefaultContext, TWrappedTransaction = DefaultWrappedTransaction> = {
+    readonly 'mutator': Mutator<TInput, TSchema, TContext, TWrappedTransaction>;
+    readonly 'args': TInput;
+    readonly '~': MutateRequestTypes<TInput, TSchema, TContext, TWrappedTransaction>;
+};
+export {};
+//# sourceMappingURL=mutator.d.ts.map

package/out/zql/src/mutate/mutator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mutator.d.ts","sourceRoot":"","sources":["../../../../../zql/src/mutate/mutator.ts"],"names":[],"mappings":"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"}

package/out/zql/src/mutate/mutator.js

@@ -0,0 +1,34 @@
+import { must } from "../../../shared/src/must.js";
+function isMutatorDefinition(f) {
+  return typeof f === "object" && f !== null && f["~"] === "MutatorDefinition";
+}
+function defineMutator(validatorOrMutator, mutator) {
+  let validator;
+  let actualMutator;
+  if (typeof validatorOrMutator === "function") {
+    validator = void 0;
+    actualMutator = validatorOrMutator;
+  } else {
+    validator = validatorOrMutator;
+    actualMutator = must(mutator);
+  }
+  const mutatorDefinition = {
+    "fn": actualMutator,
+    "validator": validator,
+    "~": "MutatorDefinition"
+  };
+  return mutatorDefinition;
+}
+function defineMutatorWithType() {
+  return defineMutator;
+}
+function isMutator(value) {
+  return typeof value === "function" && typeof value.mutatorName === "string" && typeof value.fn === "function";
+}
+export {
+  defineMutator,
+  defineMutatorWithType,
+  isMutator,
+  isMutatorDefinition
+};
+//# sourceMappingURL=mutator.js.map

package/out/zql/src/mutate/mutator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mutator.js","sources":["../../../../../zql/src/mutate/mutator.ts"],"sourcesContent":["import type {StandardSchemaV1} from '@standard-schema/spec';\nimport type {ReadonlyJSONValue} from '../../../shared/src/json.ts';\nimport {must} from '../../../shared/src/must.ts';\nimport type {\n  DefaultContext,\n  DefaultSchema,\n  DefaultWrappedTransaction,\n} from '../../../zero-types/src/default-types.ts';\nimport type {Schema} from '../../../zero-types/src/schema.ts';\nimport type {AnyTransaction, Transaction} from './custom.ts';\n\n// ----------------------------------------------------------------------------\n// defineMutator\n// ----------------------------------------------------------------------------\n\nexport type MutatorDefinitionTypes<\n  TInput extends ReadonlyJSONValue | undefined,\n  TOutput,\n  TContext,\n  TWrappedTransaction,\n> = 'MutatorDefinition' & {\n  readonly $input: TInput;\n  readonly $output: TOutput;\n  readonly $context: TContext;\n  readonly $wrappedTransaction: TWrappedTransaction;\n};\n\nexport type MutatorDefinition<\n  TInput extends ReadonlyJSONValue | undefined,\n  TOutput extends ReadonlyJSONValue | undefined,\n  TContext = DefaultContext,\n  TWrappedTransaction = DefaultWrappedTransaction,\n> = {\n  readonly 'fn': MutatorDefinitionFunction<TOutput, TContext, AnyTransaction>;\n  readonly 'validator': StandardSchemaV1<TInput, TOutput> | undefined;\n  readonly '~': MutatorDefinitionTypes<\n    TInput,\n    TOutput,\n    TContext,\n    TWrappedTransaction\n  >;\n};\n\n// oxlint-disable-next-line no-explicit-any\nexport type AnyMutatorDefinition = MutatorDefinition<any, any, any, any>;\n\nexport function isMutatorDefinition(f: unknown): f is AnyMutatorDefinition {\n  return (\n    typeof f === 'object' &&\n    f !== null &&\n    (f as {['~']?: unknown})['~'] === 'MutatorDefinition'\n  );\n}\n\n// Overload for no validator\nexport function defineMutator<\n  TInput extends ReadonlyJSONValue | undefined = ReadonlyJSONValue | undefined,\n  TSchema extends Schema = DefaultSchema,\n  TContext = DefaultContext,\n  TWrappedTransaction = DefaultWrappedTransaction,\n>(\n  mutator: MutatorDefinitionFunction<\n    TInput,\n    TContext,\n    Transaction<TSchema, TWrappedTransaction>\n  >,\n): MutatorDefinition<TInput, TInput, TContext, TWrappedTransaction>;\n\n// Overload for validator\nexport function defineMutator<\n  TInput extends ReadonlyJSONValue | undefined = undefined,\n  TOutput extends ReadonlyJSONValue | undefined = TInput,\n  TSchema extends Schema = DefaultSchema,\n  TContext = DefaultContext,\n  TWrappedTransaction = DefaultWrappedTransaction,\n>(\n  validator: StandardSchemaV1<TInput, TOutput>,\n  mutator: MutatorDefinitionFunction<\n    TOutput,\n    TContext,\n    Transaction<TSchema, TWrappedTransaction>\n  >,\n): MutatorDefinition<TInput, TOutput, TContext, TWrappedTransaction>;\n\n// Implementation\nexport function defineMutator<\n  TInput extends ReadonlyJSONValue | undefined = undefined,\n  TOutput extends ReadonlyJSONValue | undefined = TInput,\n  TSchema extends Schema = DefaultSchema,\n  TContext = DefaultContext,\n  TWrappedTransaction = DefaultWrappedTransaction,\n>(\n  validatorOrMutator:\n    | StandardSchemaV1<TInput, TOutput>\n    | MutatorDefinitionFunction<\n        TOutput,\n        TContext,\n        Transaction<TSchema, TWrappedTransaction>\n      >,\n  mutator?: MutatorDefinitionFunction<\n    TOutput,\n    TContext,\n    Transaction<TSchema, TWrappedTransaction>\n  >,\n): MutatorDefinition<TInput, TOutput, TContext, TWrappedTransaction> {\n  let validator: StandardSchemaV1<TInput, TOutput> | undefined;\n  let actualMutator: MutatorDefinitionFunction<\n    TOutput,\n    TContext,\n    Transaction<TSchema, TWrappedTransaction>\n  >;\n\n  if (typeof validatorOrMutator === 'function') {\n    // defineMutator(mutator) - no validator\n    validator = undefined;\n    actualMutator = validatorOrMutator;\n  } else {\n    // defineMutator(validator, mutator)\n    validator = validatorOrMutator;\n    actualMutator = must(mutator);\n  }\n\n  const mutatorDefinition: MutatorDefinition<\n    TInput,\n    TOutput,\n    TContext,\n    TWrappedTransaction\n  > = {\n    'fn': actualMutator as MutatorDefinitionFunction<\n      TOutput,\n      TContext,\n      AnyTransaction\n    >,\n    'validator': validator,\n    '~': 'MutatorDefinition' as unknown as MutatorDefinitionTypes<\n      TInput,\n      TOutput,\n      TContext,\n      TWrappedTransaction\n    >,\n  };\n  return mutatorDefinition;\n}\n\n// intentionally not using DefaultSchema, DefaultContext, or DefaultWrappedTransaction\nexport function defineMutatorWithType<\n  TSchema extends Schema,\n  TContext = unknown,\n  TWrappedTransaction = unknown,\n>(): TypedDefineMutator<TSchema, TContext, TWrappedTransaction> {\n  return defineMutator;\n}\n\n/**\n * The return type of defineMutatorWithType. A function matching the\n * defineMutator overloads but with Schema, Context, and WrappedTransaction\n * pre-bound.\n *\n * This is used as a workaround to using DefaultTypes (e.g. when using\n * multiple Zero instances).\n */\ntype TypedDefineMutator<\n  TSchema extends Schema,\n  TContext,\n  TWrappedTransaction,\n> = {\n  // Without validator\n  <TArgs extends ReadonlyJSONValue | undefined>(\n    mutator: MutatorDefinitionFunction<\n      TArgs,\n      TContext,\n      Transaction<TSchema, TWrappedTransaction>\n    >,\n  ): MutatorDefinition<TArgs, TArgs, TContext, TWrappedTransaction>;\n\n  // With validator\n  <\n    TInput extends ReadonlyJSONValue | undefined,\n    TOutput extends ReadonlyJSONValue | undefined,\n  >(\n    validator: StandardSchemaV1<TInput, TOutput>,\n    mutator: MutatorDefinitionFunction<\n      TOutput,\n      TContext,\n      Transaction<TSchema, TWrappedTransaction>\n    >,\n  ): MutatorDefinition<TInput, TOutput, TContext, TWrappedTransaction>;\n};\n\nexport type MutatorDefinitionFunction<\n  TOutput extends ReadonlyJSONValue | undefined,\n  TContext,\n  TTransaction,\n> = (options: {\n  args: TOutput;\n  ctx: TContext;\n  tx: TTransaction;\n}) => Promise<void>;\n\n// ----------------------------------------------------------------------------\n// Mutator and MutateRequest types\n// ----------------------------------------------------------------------------\n\nexport type MutatorTypes<\n  TInput extends ReadonlyJSONValue | undefined,\n  TSchema extends Schema,\n  TContext,\n  TWrappedTransaction,\n> = 'Mutator' & {\n  readonly $input: TInput;\n  readonly $schema: TSchema;\n  readonly $context: TContext;\n  readonly $wrappedTransaction: TWrappedTransaction;\n};\n\n/**\n * A callable wrapper around a MutatorDefinition, created by `defineMutators()`.\n *\n * Accessed like `mutators.foo.bar`, and called to create a MutateRequest:\n * `mutators.foo.bar(42)` returns a `MutateRequest`.\n *\n * The `fn` property is used for execution and takes raw JSON args (for rebase\n * and server wire format cases) that are validated internally.\n */\nexport type Mutator<\n  TInput extends ReadonlyJSONValue | undefined,\n  TSchema extends Schema = DefaultSchema,\n  TContext = DefaultContext,\n  TWrappedTransaction = DefaultWrappedTransaction,\n> = {\n  readonly 'mutatorName': string;\n  /**\n   * Execute the mutation. Args are ReadonlyJSONValue because this is called\n   * during rebase (from stored JSON) and on the server (from wire format).\n   * Validation happens internally before the recipe function runs.\n   */\n  readonly 'fn': MutatorDefinitionFunction<\n    TInput,\n    TContext,\n    Transaction<TSchema, TWrappedTransaction>\n  >;\n  readonly '~': MutatorTypes<TInput, TSchema, TContext, TWrappedTransaction>;\n} & MutatorCallable<TInput, TSchema, TContext, TWrappedTransaction>;\n\n// Helper type for the callable part of Mutator\n// When TInput is undefined, the function is callable with 0 args\n// When TInput includes undefined (optional), args is optional\n// Otherwise, args is required\ntype MutatorCallable<\n  TInput extends ReadonlyJSONValue | undefined,\n  TSchema extends Schema,\n  TContext,\n  TWrappedTransaction,\n> = [TInput] extends [undefined]\n  ? () => MutateRequest<TInput, TSchema, TContext, TWrappedTransaction>\n  : undefined extends TInput\n    ? {\n        (): MutateRequest<TInput, TSchema, TContext, TWrappedTransaction>;\n        (\n          args?: TInput,\n        ): MutateRequest<TInput, TSchema, TContext, TWrappedTransaction>;\n      }\n    : {\n        (\n          args: TInput,\n        ): MutateRequest<TInput, TSchema, TContext, TWrappedTransaction>;\n      };\n\n// oxlint-disable-next-line no-explicit-any\nexport type AnyMutator = Mutator<any, any, any, any>;\n\n/**\n * Checks if a value is a Mutator (the result of processing a MutatorDefinition\n * through defineMutators).\n */\nexport function isMutator<S extends Schema>(\n  value: unknown,\n  // oxlint-disable-next-line no-explicit-any\n): value is Mutator<any, S, any, any> {\n  return (\n    typeof value === 'function' &&\n    typeof (value as {mutatorName?: unknown}).mutatorName === 'string' &&\n    typeof (value as {fn?: unknown}).fn === 'function'\n  );\n}\n\nexport type MutateRequestTypes<\n  TInput extends ReadonlyJSONValue | undefined,\n  TSchema extends Schema,\n  TContext,\n  TWrappedTransaction,\n> = 'MutateRequest' & {\n  readonly $input: TInput;\n  readonly $schema: TSchema;\n  readonly $context: TContext;\n  readonly $wrappedTransaction: TWrappedTransaction;\n};\n\n/**\n * The result of calling a Mutator with arguments.\n *\n * Created by `mutators.foo.bar(42)`, executed by `zero.mutate(mr)` on the client\n * or `mr.mutator.fn({tx, ctx, args: mr.args})` on the server.\n */\nexport type MutateRequest<\n  TInput extends ReadonlyJSONValue | undefined,\n  TSchema extends Schema = DefaultSchema,\n  TContext = DefaultContext,\n  TWrappedTransaction = DefaultWrappedTransaction,\n> = {\n  readonly 'mutator': Mutator<TInput, TSchema, TContext, TWrappedTransaction>;\n  readonly 'args': TInput;\n  readonly '~': MutateRequestTypes<\n    TInput,\n    TSchema,\n    TContext,\n    TWrappedTransaction\n  >;\n};\n"],"names":[],"mappings":";AA8CO,SAAS,oBAAoB,GAAuC;AACzE,SACE,OAAO,MAAM,YACb,MAAM,QACL,EAAwB,GAAG,MAAM;AAEtC;AAiCO,SAAS,cAOd,oBAOA,SAKmE;AACnE,MAAI;AACJ,MAAI;AAMJ,MAAI,OAAO,uBAAuB,YAAY;AAE5C,gBAAY;AACZ,oBAAgB;AAAA,EAClB,OAAO;AAEL,gBAAY;AACZ,oBAAgB,KAAK,OAAO;AAAA,EAC9B;AAEA,QAAM,oBAKF;AAAA,IACF,MAAM;AAAA,IAKN,aAAa;AAAA,IACb,KAAK;AAAA,EAAA;AAOP,SAAO;AACT;AAGO,SAAS,wBAIgD;AAC9D,SAAO;AACT;AA4HO,SAAS,UACd,OAEoC;AACpC,SACE,OAAO,UAAU,cACjB,OAAQ,MAAkC,gBAAgB,YAC1D,OAAQ,MAAyB,OAAO;AAE5C;"}

package/out/zql/src/planner/planner-builder.d.ts

@@ -1,3 +1,4 @@
+import type { LogContext } from '@rocicorp/logger';
 import type { AST } from '../../../zero-protocol/src/ast.ts';
 import type { ConnectionCostModel } from './planner-connection.ts';
 import type { PlannerConstraint } from './planner-constraint.ts';
@@ -10,6 +11,6 @@ export type Plans = {
     };
 };
 export declare function buildPlanGraph(ast: AST, model: ConnectionCostModel, isRoot: boolean, baseConstraints?: PlannerConstraint): Plans;
-export declare function planQuery(ast: AST, model: ConnectionCostModel, planDebugger?: PlanDebugger): AST;
+export declare function planQuery(ast: AST, model: ConnectionCostModel, planDebugger?: PlanDebugger, lc?: LogContext): AST;
 export declare function applyPlansToAST(ast: AST, plans: Plans): AST;
 //# sourceMappingURL=planner-builder.d.ts.map

package/out/zql/src/planner/planner-builder.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"planner-builder.d.ts","sourceRoot":"","sources":["../../../../../zql/src/planner/planner-builder.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,GAAG,EAKJ,MAAM,mCAAmC,CAAC;AAE3C,OAAO,KAAK,EAAC,mBAAmB,EAAC,MAAM,yBAAyB,CAAC;AACjE,OAAO,KAAK,EAAC,iBAAiB,EAAC,MAAM,yBAAyB,CAAC;AAC/D,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,oBAAoB,CAAC;AAGrD,OAAO,EAAC,YAAY,EAAC,MAAM,oBAAoB,CAAC;AAoBhD,MAAM,MAAM,KAAK,GAAG;IAClB,IAAI,EAAE,YAAY,CAAC;IACnB,QAAQ,EAAE;QAAC,CAAC,GAAG,EAAE,MAAM,GAAG,KAAK,CAAA;KAAC,CAAC;CAClC,CAAC;AAEF,wBAAgB,cAAc,CAC5B,GAAG,EAAE,GAAG,EACR,KAAK,EAAE,mBAAmB,EAC1B,MAAM,EAAE,OAAO,EACf,eAAe,CAAC,EAAE,iBAAiB,GAClC,KAAK,CAmDP;AAsLD,wBAAgB,SAAS,CACvB,GAAG,EAAE,GAAG,EACR,KAAK,EAAE,mBAAmB,EAC1B,YAAY,CAAC,EAAE,YAAY,GAC1B,GAAG,CAIL;AAqCD,wBAAgB,eAAe,CAAC,GAAG,EAAE,GAAG,EAAE,KAAK,EAAE,KAAK,GAAG,GAAG,CAyB3D"}
+{"version":3,"file":"planner-builder.d.ts","sourceRoot":"","sources":["../../../../../zql/src/planner/planner-builder.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,kBAAkB,CAAC;AAGjD,OAAO,KAAK,EACV,GAAG,EAKJ,MAAM,mCAAmC,CAAC;AAE3C,OAAO,KAAK,EAAC,mBAAmB,EAAC,MAAM,yBAAyB,CAAC;AACjE,OAAO,KAAK,EAAC,iBAAiB,EAAC,MAAM,yBAAyB,CAAC;AAC/D,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,oBAAoB,CAAC;AAGrD,OAAO,EAAC,YAAY,EAAC,MAAM,oBAAoB,CAAC;AAoBhD,MAAM,MAAM,KAAK,GAAG;IAClB,IAAI,EAAE,YAAY,CAAC;IACnB,QAAQ,EAAE;QAAC,CAAC,GAAG,EAAE,MAAM,GAAG,KAAK,CAAA;KAAC,CAAC;CAClC,CAAC;AAEF,wBAAgB,cAAc,CAC5B,GAAG,EAAE,GAAG,EACR,KAAK,EAAE,mBAAmB,EAC1B,MAAM,EAAE,OAAO,EACf,eAAe,CAAC,EAAE,iBAAiB,GAClC,KAAK,CAmDP;AAoND,wBAAgB,SAAS,CACvB,GAAG,EAAE,GAAG,EACR,KAAK,EAAE,mBAAmB,EAC1B,YAAY,CAAC,EAAE,YAAY,EAC3B,EAAE,CAAC,EAAE,UAAU,GACd,GAAG,CAIL;AAqCD,wBAAgB,eAAe,CAAC,GAAG,EAAE,GAAG,EAAE,KAAK,EAAE,KAAK,GAAG,GAAG,CAyB3D"}