zodvex 0.2.4 → 0.3.1

package/dist/index.mjs

@@ -1,1001 +0,0 @@
-import { NoOp } from 'convex-helpers/server/customFunctions';
-export { customCtx } from 'convex-helpers/server/customFunctions';
-import { z } from 'zod';
-import { v, ConvexError } from 'convex/values';
-import { Table } from 'convex-helpers/server';
-
-var metadata = /* @__PURE__ */ new WeakMap();
-var registryHelpers = {
-  getMetadata: (type) => metadata.get(type),
-  setMetadata: (type, meta) => metadata.set(type, meta)
-};
-function zid(tableName) {
-  const baseSchema = z.string().refine((val) => typeof val === "string" && val.length > 0, {
-    message: `Invalid ID for table "${tableName}"`
-  }).transform((val) => {
-    return val;
-  }).brand(`ConvexId_${tableName}`).describe(`convexId:${tableName}`);
-  registryHelpers.setMetadata(baseSchema, {
-    isConvexId: true,
-    tableName
-  });
-  const branded = baseSchema;
-  branded._tableName = tableName;
-  return branded;
-}
-var baseCodecs = [];
-function registerBaseCodec(codec) {
-  baseCodecs.unshift(codec);
-}
-function findBaseCodec(schema) {
-  return baseCodecs.find((codec) => codec.check(schema));
-}
-registerBaseCodec({
-  check: (schema) => schema instanceof z.ZodDate,
-  toValidator: () => v.float64(),
-  fromConvex: (value) => {
-    if (typeof value === "number") {
-      return new Date(value);
-    }
-    return value;
-  },
-  toConvex: (value) => {
-    if (value instanceof Date) {
-      return value.getTime();
-    }
-    return value;
-  }
-});
-function asZodType(schema) {
-  return schema;
-}
-function isDateSchema(schema) {
-  if (schema instanceof z.ZodDate) return true;
-  if (schema instanceof z.ZodOptional || schema instanceof z.ZodNullable) {
-    return isDateSchema(asZodType(schema.unwrap()));
-  }
-  return false;
-}
-function convertEnumType(actualValidator) {
-  const options = actualValidator.options;
-  if (options && Array.isArray(options) && options.length > 0) {
-    const validLiterals = options.filter((opt) => opt !== void 0 && opt !== null).map((opt) => v.literal(opt));
-    if (validLiterals.length === 1) {
-      const [first] = validLiterals;
-      return first;
-    } else if (validLiterals.length >= 2) {
-      const [first, second, ...rest] = validLiterals;
-      return v.union(
-        first,
-        second,
-        ...rest
-      );
-    } else {
-      return v.any();
-    }
-  } else {
-    return v.any();
-  }
-}
-function convertNullableType(actualValidator, visited, zodToConvexInternal2) {
-  const innerSchema = actualValidator.unwrap();
-  if (innerSchema && innerSchema instanceof z.ZodType) {
-    if (innerSchema instanceof z.ZodOptional) {
-      const innerInnerSchema = innerSchema.unwrap();
-      const innerInnerValidator = zodToConvexInternal2(innerInnerSchema, visited);
-      return {
-        validator: v.union(innerInnerValidator, v.null()),
-        isOptional: true
-        // Mark as optional so it gets wrapped later
-      };
-    } else {
-      const innerValidator = zodToConvexInternal2(innerSchema, visited);
-      return {
-        validator: v.union(innerValidator, v.null()),
-        isOptional: false
-      };
-    }
-  } else {
-    return {
-      validator: v.any(),
-      isOptional: false
-    };
-  }
-}
-function convertRecordType(actualValidator, visited, zodToConvexInternal2) {
-  let valueType = actualValidator._def?.valueType;
-  if (!valueType) {
-    valueType = actualValidator._def?.keyType;
-  }
-  if (valueType && valueType instanceof z.ZodType) {
-    const isZodOptional = valueType instanceof z.ZodOptional || valueType instanceof z.ZodDefault || valueType instanceof z.ZodDefault && valueType.def.innerType instanceof z.ZodOptional;
-    if (isZodOptional) {
-      let innerType;
-      let recordDefaultValue = void 0;
-      let recordHasDefault = false;
-      if (valueType instanceof z.ZodDefault) {
-        recordHasDefault = true;
-        recordDefaultValue = valueType.def.defaultValue;
-        const innerFromDefault = valueType.def.innerType;
-        if (innerFromDefault instanceof z.ZodOptional) {
-          innerType = innerFromDefault.unwrap();
-        } else {
-          innerType = innerFromDefault;
-        }
-      } else if (valueType instanceof z.ZodOptional) {
-        innerType = valueType.unwrap();
-      } else {
-        innerType = valueType;
-      }
-      const innerConvex = zodToConvexInternal2(innerType, visited);
-      const unionValidator = v.union(innerConvex, v.null());
-      if (recordHasDefault) {
-        unionValidator._zodDefault = recordDefaultValue;
-      }
-      return v.record(v.string(), unionValidator);
-    } else {
-      return v.record(v.string(), zodToConvexInternal2(valueType, visited));
-    }
-  } else {
-    return v.record(v.string(), v.any());
-  }
-}
-function convertDiscriminatedUnionType(actualValidator, visited, zodToConvexInternal2) {
-  const options = actualValidator.def?.options || actualValidator.def?.optionsMap?.values();
-  if (options) {
-    const opts = Array.isArray(options) ? options : Array.from(options);
-    if (opts.length >= 2) {
-      const convexOptions = opts.map((opt) => {
-        const branchVisited = new Set(visited);
-        return zodToConvexInternal2(opt, branchVisited);
-      });
-      const [first, second, ...rest] = convexOptions;
-      return v.union(
-        first,
-        second,
-        ...rest
-      );
-    } else {
-      return v.any();
-    }
-  } else {
-    return v.any();
-  }
-}
-function convertUnionType(actualValidator, visited, zodToConvexInternal2) {
-  const options = actualValidator.options;
-  if (options && Array.isArray(options) && options.length > 0) {
-    if (options.length === 1) {
-      return zodToConvexInternal2(options[0], visited);
-    } else {
-      const convexOptions = options.map((opt) => {
-        const branchVisited = new Set(visited);
-        return zodToConvexInternal2(opt, branchVisited);
-      });
-      if (convexOptions.length >= 2) {
-        const [first, second, ...rest] = convexOptions;
-        return v.union(
-          first,
-          second,
-          ...rest
-        );
-      } else {
-        return v.any();
-      }
-    }
-  } else {
-    return v.any();
-  }
-}
-function isZid(schema) {
-  const metadata2 = registryHelpers.getMetadata(schema);
-  return metadata2?.isConvexId === true && metadata2?.tableName && typeof metadata2.tableName === "string";
-}
-function makeUnion(members) {
-  const nonNull = members.filter(Boolean);
-  if (nonNull.length === 0) return v.any();
-  if (nonNull.length === 1) return nonNull[0];
-  return v.union(nonNull[0], nonNull[1], ...nonNull.slice(2));
-}
-function getObjectShape(obj) {
-  if (obj instanceof z.ZodObject) {
-    return obj.shape;
-  }
-  if (obj && typeof obj === "object" && typeof obj.shape === "object") {
-    return obj.shape;
-  }
-  return {};
-}
-
-// src/mapping/core.ts
-function zodToConvexInternal(zodValidator, visited = /* @__PURE__ */ new Set()) {
-  if (!zodValidator) {
-    return v.any();
-  }
-  if (visited.has(zodValidator)) {
-    return v.any();
-  }
-  visited.add(zodValidator);
-  let actualValidator = zodValidator;
-  let isOptional = false;
-  let defaultValue = void 0;
-  let hasDefault = false;
-  if (zodValidator instanceof z.ZodDefault) {
-    hasDefault = true;
-    defaultValue = zodValidator.def?.defaultValue;
-    actualValidator = zodValidator.def?.innerType;
-  }
-  if (actualValidator instanceof z.ZodOptional) {
-    isOptional = true;
-    actualValidator = actualValidator.unwrap();
-    if (actualValidator instanceof z.ZodDefault) {
-      hasDefault = true;
-      defaultValue = actualValidator.def?.defaultValue;
-      actualValidator = actualValidator.def?.innerType;
-    }
-  }
-  let convexValidator;
-  if (isZid(actualValidator)) {
-    const metadata2 = registryHelpers.getMetadata(actualValidator);
-    const tableName = metadata2?.tableName || "unknown";
-    convexValidator = v.id(tableName);
-  } else {
-    const defType = actualValidator.def?.type;
-    switch (defType) {
-      case "string":
-        convexValidator = v.string();
-        break;
-      case "number":
-        convexValidator = v.float64();
-        break;
-      case "bigint":
-        convexValidator = v.int64();
-        break;
-      case "boolean":
-        convexValidator = v.boolean();
-        break;
-      case "date":
-        convexValidator = v.float64();
-        break;
-      case "null":
-        convexValidator = v.null();
-        break;
-      case "nan":
-        convexValidator = v.float64();
-        break;
-      case "array": {
-        if (actualValidator instanceof z.ZodArray) {
-          const element = actualValidator.element;
-          if (element && element instanceof z.ZodType) {
-            convexValidator = v.array(zodToConvexInternal(element, visited));
-          } else {
-            convexValidator = v.array(v.any());
-          }
-        } else {
-          convexValidator = v.array(v.any());
-        }
-        break;
-      }
-      case "object": {
-        if (actualValidator instanceof z.ZodObject) {
-          const shape = actualValidator.shape;
-          const convexShape = {};
-          for (const [key, value] of Object.entries(shape)) {
-            if (value && value instanceof z.ZodType) {
-              convexShape[key] = zodToConvexInternal(value, visited);
-            }
-          }
-          convexValidator = v.object(convexShape);
-        } else {
-          convexValidator = v.object({});
-        }
-        break;
-      }
-      case "union": {
-        if (actualValidator instanceof z.ZodUnion) {
-          convexValidator = convertUnionType(actualValidator, visited, zodToConvexInternal);
-        } else {
-          convexValidator = v.any();
-        }
-        break;
-      }
-      case "discriminatedUnion": {
-        convexValidator = convertDiscriminatedUnionType(
-          actualValidator,
-          visited,
-          zodToConvexInternal
-        );
-        break;
-      }
-      case "literal": {
-        if (actualValidator instanceof z.ZodLiteral) {
-          const literalValue = actualValidator.value;
-          if (literalValue !== void 0 && literalValue !== null) {
-            convexValidator = v.literal(literalValue);
-          } else {
-            convexValidator = v.any();
-          }
-        } else {
-          convexValidator = v.any();
-        }
-        break;
-      }
-      case "enum": {
-        if (actualValidator instanceof z.ZodEnum) {
-          convexValidator = convertEnumType(actualValidator);
-        } else {
-          convexValidator = v.any();
-        }
-        break;
-      }
-      case "record": {
-        if (actualValidator instanceof z.ZodRecord) {
-          convexValidator = convertRecordType(actualValidator, visited, zodToConvexInternal);
-        } else {
-          convexValidator = v.record(v.string(), v.any());
-        }
-        break;
-      }
-      case "transform":
-      case "pipe": {
-        const codec = findBaseCodec(actualValidator);
-        if (codec) {
-          convexValidator = codec.toValidator(actualValidator);
-        } else {
-          const metadata2 = registryHelpers.getMetadata(actualValidator);
-          if (metadata2?.brand && metadata2?.originalSchema) {
-            convexValidator = zodToConvexInternal(metadata2.originalSchema, visited);
-          } else {
-            convexValidator = v.any();
-          }
-        }
-        break;
-      }
-      case "nullable": {
-        if (actualValidator instanceof z.ZodNullable) {
-          const result = convertNullableType(actualValidator, visited, zodToConvexInternal);
-          convexValidator = result.validator;
-          if (result.isOptional) {
-            isOptional = true;
-          }
-        } else {
-          convexValidator = v.any();
-        }
-        break;
-      }
-      case "tuple": {
-        if (actualValidator instanceof z.ZodTuple) {
-          const items = actualValidator.def?.items;
-          if (items && items.length > 0) {
-            const convexShape = {};
-            items.forEach((item, index) => {
-              convexShape[`_${index}`] = zodToConvexInternal(item, visited);
-            });
-            convexValidator = v.object(convexShape);
-          } else {
-            convexValidator = v.object({});
-          }
-        } else {
-          convexValidator = v.object({});
-        }
-        break;
-      }
-      case "lazy": {
-        if (actualValidator instanceof z.ZodLazy) {
-          try {
-            const getter = actualValidator.def?.getter;
-            if (getter) {
-              const resolvedSchema = getter();
-              if (resolvedSchema && resolvedSchema instanceof z.ZodType) {
-                convexValidator = zodToConvexInternal(resolvedSchema, visited);
-              } else {
-                convexValidator = v.any();
-              }
-            } else {
-              convexValidator = v.any();
-            }
-          } catch {
-            convexValidator = v.any();
-          }
-        } else {
-          convexValidator = v.any();
-        }
-        break;
-      }
-      case "any":
-        convexValidator = v.any();
-        break;
-      case "unknown":
-        convexValidator = v.any();
-        break;
-      case "undefined":
-      case "void":
-      case "never":
-        convexValidator = v.any();
-        break;
-      case "intersection":
-        convexValidator = v.any();
-        break;
-      default:
-        if (process.env.NODE_ENV !== "production") {
-          console.warn(
-            `[zodvex] Unrecognized Zod type "${defType}" encountered. Falling back to v.any().`,
-            "Schema:",
-            actualValidator
-          );
-        }
-        convexValidator = v.any();
-        break;
-    }
-  }
-  const finalValidator = isOptional || hasDefault ? v.optional(convexValidator) : convexValidator;
-  if (hasDefault && typeof finalValidator === "object" && finalValidator !== null) {
-    finalValidator._zodDefault = defaultValue;
-  }
-  return finalValidator;
-}
-function zodToConvex(zod) {
-  if (typeof zod === "object" && zod !== null && !(zod instanceof z.ZodType)) {
-    return zodToConvexFields(zod);
-  }
-  return zodToConvexInternal(zod);
-}
-function zodToConvexFields(zod) {
-  const fields = zod instanceof z.ZodObject ? zod.shape : zod;
-  const result = {};
-  for (const [key, value] of Object.entries(fields)) {
-    result[key] = zodToConvexInternal(value);
-  }
-  return result;
-}
-
-// src/codec.ts
-function asZodType2(schema) {
-  return schema;
-}
-function convexCodec(schema) {
-  const validator = zodToConvex(schema);
-  return {
-    validator,
-    encode: (value) => toConvexJS(schema, value),
-    decode: (value) => fromConvexJS(value, schema),
-    pick: (keys) => {
-      if (!(schema instanceof z.ZodObject)) {
-        throw new Error("pick() can only be called on object schemas");
-      }
-      const pickObj = Array.isArray(keys) ? keys.reduce((acc, k) => ({ ...acc, [k]: true }), {}) : keys;
-      const pickedSchema = schema.pick(pickObj);
-      return convexCodec(pickedSchema);
-    }
-  };
-}
-function toConvexJS(schema, value) {
-  if (!schema || arguments.length === 1) {
-    value = schema;
-    return basicToConvex(value);
-  }
-  return schemaToConvex(value, schema);
-}
-function basicToConvex(value) {
-  if (value === void 0) return void 0;
-  if (value === null) return null;
-  if (value instanceof Date) return value.getTime();
-  if (Array.isArray(value)) {
-    return value.map(basicToConvex);
-  }
-  if (value && typeof value === "object") {
-    const result = {};
-    for (const [k, v8] of Object.entries(value)) {
-      if (v8 !== void 0) {
-        result[k] = basicToConvex(v8);
-      }
-    }
-    return result;
-  }
-  return value;
-}
-function schemaToConvex(value, schema) {
-  if (value === void 0 || value === null) return value;
-  const codec = findBaseCodec(schema);
-  if (codec) {
-    return codec.toConvex(value, schema);
-  }
-  if (schema instanceof z.ZodOptional || schema instanceof z.ZodNullable || schema instanceof z.ZodDefault) {
-    const inner = schema.unwrap();
-    return schemaToConvex(value, asZodType2(inner));
-  }
-  if (schema instanceof z.ZodDate && value instanceof Date) {
-    return value.getTime();
-  }
-  if (schema instanceof z.ZodArray) {
-    if (!Array.isArray(value)) return value;
-    return value.map((item) => schemaToConvex(item, schema.element));
-  }
-  if (schema instanceof z.ZodObject) {
-    if (!value || typeof value !== "object") return value;
-    const shape = schema.shape;
-    const result = {};
-    for (const [k, v8] of Object.entries(value)) {
-      if (v8 !== void 0) {
-        result[k] = shape[k] ? schemaToConvex(v8, shape[k]) : basicToConvex(v8);
-      }
-    }
-    return result;
-  }
-  if (schema instanceof z.ZodUnion) {
-    for (const option of schema.options) {
-      try {
-        ;
-        option.parse(value);
-        return schemaToConvex(value, option);
-      } catch {
-      }
-    }
-  }
-  if (schema instanceof z.ZodRecord) {
-    if (!value || typeof value !== "object") return value;
-    const result = {};
-    for (const [k, v8] of Object.entries(value)) {
-      if (v8 !== void 0) {
-        result[k] = schemaToConvex(v8, schema.valueType);
-      }
-    }
-    return result;
-  }
-  return basicToConvex(value);
-}
-function fromConvexJS(value, schema) {
-  if (value === void 0 || value === null) return value;
-  const codec = findBaseCodec(schema);
-  if (codec) {
-    return codec.fromConvex(value, schema);
-  }
-  if (schema instanceof z.ZodOptional || schema instanceof z.ZodNullable || schema instanceof z.ZodDefault) {
-    const inner = schema.unwrap();
-    return fromConvexJS(value, asZodType2(inner));
-  }
-  if (schema instanceof z.ZodDate && typeof value === "number") {
-    return new Date(value);
-  }
-  if (isDateSchema(schema) && typeof value === "number") {
-    return new Date(value);
-  }
-  if (schema instanceof z.ZodArray) {
-    if (!Array.isArray(value)) return value;
-    return value.map((item) => fromConvexJS(item, schema.element));
-  }
-  if (schema instanceof z.ZodObject) {
-    if (!value || typeof value !== "object") return value;
-    const shape = schema.shape;
-    const result = {};
-    for (const [k, v8] of Object.entries(value)) {
-      result[k] = shape[k] ? fromConvexJS(v8, shape[k]) : v8;
-    }
-    return result;
-  }
-  if (schema instanceof z.ZodUnion) {
-    for (const option of schema.options) {
-      try {
-        const decoded = fromConvexJS(value, option);
-        option.parse(decoded);
-        return decoded;
-      } catch {
-      }
-    }
-  }
-  if (schema instanceof z.ZodRecord) {
-    if (!value || typeof value !== "object") return value;
-    const result = {};
-    for (const [k, v8] of Object.entries(value)) {
-      result[k] = fromConvexJS(v8, schema.valueType);
-    }
-    return result;
-  }
-  if (schema instanceof z.ZodTransform) {
-    return value;
-  }
-  return value;
-}
-function pick(obj, keys) {
-  const result = {};
-  for (const key of keys) {
-    if (key in obj) result[key] = obj[key];
-  }
-  return result;
-}
-function returnsAs() {
-  return (v8) => v8;
-}
-function formatZodIssues(error, context) {
-  return {
-    error: "ZodValidationError",
-    context,
-    issues: error.issues.map((issue) => ({
-      path: Array.isArray(issue.path) ? issue.path.join(".") : String(issue.path ?? ""),
-      code: issue.code,
-      message: issue.message
-    })),
-    // Keep a flattened snapshot for easier debugging without cyclic refs
-    flatten: JSON.parse(JSON.stringify(error.flatten?.() ?? {}))
-  };
-}
-function handleZodValidationError(e, context) {
-  if (e instanceof z.ZodError) {
-    throw new ConvexError(formatZodIssues(e, context));
-  }
-  throw e;
-}
-function zPaginated(item) {
-  return z.object({
-    page: z.array(item),
-    isDone: z.boolean(),
-    continueCursor: z.string().nullable().optional()
-  });
-}
-function mapDateFieldToNumber(field) {
-  if (field instanceof z.ZodDate) {
-    return z.number();
-  }
-  if (field instanceof z.ZodOptional && field.unwrap() instanceof z.ZodDate) {
-    return z.number().optional();
-  }
-  if (field instanceof z.ZodNullable && field.unwrap() instanceof z.ZodDate) {
-    return z.number().nullable();
-  }
-  if (field instanceof z.ZodDefault) {
-    const inner = field.removeDefault();
-    if (inner instanceof z.ZodDate) {
-      return z.number().optional();
-    }
-  }
-  return field;
-}
-function toKeys(mask) {
-  if (Array.isArray(mask)) return mask.map(String);
-  return Object.keys(mask).filter((k) => !!mask[k]);
-}
-function pickShape(schemaOrShape, mask) {
-  const keys = toKeys(mask);
-  const shape = schemaOrShape instanceof z.ZodObject ? getObjectShape(schemaOrShape) : schemaOrShape || {};
-  const out = {};
-  for (const k of keys) {
-    if (k in shape) out[k] = shape[k];
-  }
-  return out;
-}
-function safePick(schema, mask) {
-  return z.object(pickShape(schema, mask));
-}
-function safeOmit(schema, mask) {
-  const shape = getObjectShape(schema);
-  const omit = new Set(toKeys(mask));
-  const keep = Object.keys(shape).filter((k) => !omit.has(k));
-  const picked = pickShape(schema, keep);
-  return z.object(picked);
-}
-
-// src/custom.ts
-function customFnBuilder(builder, customization) {
-  const customInput = customization.input ?? NoOp.input;
-  const inputArgs = customization.args ?? NoOp.args;
-  return function customBuilder(fn) {
-    const { args, handler = fn, returns: maybeObject, ...extra } = fn;
-    const returns = maybeObject && !(maybeObject instanceof z.ZodType) ? z.object(maybeObject) : maybeObject;
-    const returnValidator = returns && !fn.skipConvexValidation ? { returns: zodToConvex(returns) } : void 0;
-    if (args && !fn.skipConvexValidation) {
-      let argsValidator = args;
-      let argsSchema;
-      if (argsValidator instanceof z.ZodType) {
-        if (argsValidator instanceof z.ZodObject) {
-          argsSchema = argsValidator;
-          argsValidator = argsValidator.shape;
-        } else {
-          throw new Error(
-            "Unsupported non-object Zod schema for args; please provide an args schema using z.object({...}), e.g. z.object({ foo: z.string() })"
-          );
-        }
-      } else {
-        argsSchema = z.object(argsValidator);
-      }
-      const convexValidator = zodToConvexFields(argsValidator);
-      return builder({
-        args: { ...convexValidator, ...inputArgs },
-        ...returnValidator,
-        handler: async (ctx, allArgs) => {
-          const added = await customInput(
-            ctx,
-            pick(allArgs, Object.keys(inputArgs)),
-            extra
-          );
-          const argKeys = Object.keys(argsValidator);
-          const rawArgs = pick(allArgs, argKeys);
-          const decoded = fromConvexJS(rawArgs, argsSchema);
-          const parsed = argsSchema.safeParse(decoded);
-          if (!parsed.success) {
-            handleZodValidationError(parsed.error, "args");
-          }
-          const finalCtx = { ...ctx, ...added?.ctx ?? {} };
-          const baseArgs = parsed.data;
-          const addedArgs = added?.args ?? {};
-          const finalArgs = { ...baseArgs, ...addedArgs };
-          const ret = await handler(finalCtx, finalArgs);
-          if (returns && !fn.skipConvexValidation) {
-            let validated;
-            try {
-              validated = returns.parse(ret);
-            } catch (e) {
-              handleZodValidationError(e, "returns");
-            }
-            if (added?.onSuccess) {
-              await added.onSuccess({
-                ctx,
-                args: parsed.data,
-                result: validated
-              });
-            }
-            return toConvexJS(returns, validated);
-          }
-          if (added?.onSuccess) {
-            await added.onSuccess({ ctx, args: parsed.data, result: ret });
-          }
-          return ret;
-        }
-      });
-    }
-    return builder({
-      args: inputArgs,
-      ...returnValidator,
-      handler: async (ctx, allArgs) => {
-        const added = await customInput(
-          ctx,
-          pick(allArgs, Object.keys(inputArgs)),
-          extra
-        );
-        const finalCtx = { ...ctx, ...added?.ctx ?? {} };
-        const baseArgs = allArgs;
-        const addedArgs = added?.args ?? {};
-        const finalArgs = { ...baseArgs, ...addedArgs };
-        const ret = await handler(finalCtx, finalArgs);
-        if (returns && !fn.skipConvexValidation) {
-          let validated;
-          try {
-            validated = returns.parse(ret);
-          } catch (e) {
-            handleZodValidationError(e, "returns");
-          }
-          if (added?.onSuccess) {
-            await added.onSuccess({ ctx, args: allArgs, result: validated });
-          }
-          return toConvexJS(returns, validated);
-        }
-        if (added?.onSuccess) {
-          await added.onSuccess({ ctx, args: allArgs, result: ret });
-        }
-        return ret;
-      }
-    });
-  };
-}
-function zCustomQuery(query, customization) {
-  return customFnBuilder(query, customization);
-}
-function zCustomMutation(mutation, customization) {
-  return customFnBuilder(
-    mutation,
-    customization
-  );
-}
-function zCustomAction(action, customization) {
-  return customFnBuilder(
-    action,
-    customization
-  );
-}
-var customCheckCache = /* @__PURE__ */ new WeakMap();
-function containsCustom(schema, maxDepth = 50, currentDepth = 0) {
-  const cached = customCheckCache.get(schema);
-  if (cached !== void 0) {
-    return cached;
-  }
-  if (currentDepth > maxDepth) {
-    return false;
-  }
-  let result = false;
-  if (schema._def?.typeName === "ZodCustom") {
-    result = true;
-  } else if (schema instanceof z.ZodUnion) {
-    result = schema.options.some(
-      (opt) => containsCustom(opt, maxDepth, currentDepth + 1)
-    );
-  } else if (schema instanceof z.ZodOptional) {
-    result = containsCustom(schema.unwrap(), maxDepth, currentDepth + 1);
-  } else if (schema instanceof z.ZodNullable) {
-    result = containsCustom(schema.unwrap(), maxDepth, currentDepth + 1);
-  } else if (schema instanceof z.ZodDefault) {
-    result = containsCustom(schema.removeDefault(), maxDepth, currentDepth + 1);
-  }
-  customCheckCache.set(schema, result);
-  return result;
-}
-function zQuery(query, input, handler, options) {
-  let zodSchema;
-  let args;
-  if (input instanceof z.ZodObject) {
-    const zodObj = input;
-    zodSchema = zodObj;
-    args = zodToConvexFields(getObjectShape(zodObj));
-  } else if (input instanceof z.ZodType) {
-    zodSchema = z.object({ value: input });
-    args = { value: zodToConvex(input) };
-  } else {
-    zodSchema = z.object(input);
-    args = zodToConvexFields(input);
-  }
-  const returns = options?.returns && !containsCustom(options.returns) ? zodToConvex(options.returns) : void 0;
-  return query({
-    args,
-    returns,
-    handler: async (ctx, argsObject) => {
-      const decoded = fromConvexJS(argsObject, zodSchema);
-      let parsed;
-      try {
-        parsed = zodSchema.parse(decoded);
-      } catch (e) {
-        handleZodValidationError(e, "args");
-      }
-      const raw = await handler(ctx, parsed);
-      if (options?.returns) {
-        try {
-          const validated = options.returns.parse(raw);
-          return toConvexJS(options.returns, validated);
-        } catch (e) {
-          handleZodValidationError(e, "returns");
-        }
-      }
-      return toConvexJS(raw);
-    }
-  });
-}
-function zMutation(mutation, input, handler, options) {
-  let zodSchema;
-  let args;
-  if (input instanceof z.ZodObject) {
-    const zodObj = input;
-    zodSchema = zodObj;
-    args = zodToConvexFields(getObjectShape(zodObj));
-  } else if (input instanceof z.ZodType) {
-    zodSchema = z.object({ value: input });
-    args = { value: zodToConvex(input) };
-  } else {
-    zodSchema = z.object(input);
-    args = zodToConvexFields(input);
-  }
-  const returns = options?.returns && !containsCustom(options.returns) ? zodToConvex(options.returns) : void 0;
-  return mutation({
-    args,
-    returns,
-    handler: async (ctx, argsObject) => {
-      const decoded = fromConvexJS(argsObject, zodSchema);
-      let parsed;
-      try {
-        parsed = zodSchema.parse(decoded);
-      } catch (e) {
-        handleZodValidationError(e, "args");
-      }
-      const raw = await handler(ctx, parsed);
-      if (options?.returns) {
-        try {
-          const validated = options.returns.parse(raw);
-          return toConvexJS(options.returns, validated);
-        } catch (e) {
-          handleZodValidationError(e, "returns");
-        }
-      }
-      return toConvexJS(raw);
-    }
-  });
-}
-function zAction(action, input, handler, options) {
-  let zodSchema;
-  let args;
-  if (input instanceof z.ZodObject) {
-    const zodObj = input;
-    zodSchema = zodObj;
-    args = zodToConvexFields(getObjectShape(zodObj));
-  } else if (input instanceof z.ZodType) {
-    zodSchema = z.object({ value: input });
-    args = { value: zodToConvex(input) };
-  } else {
-    zodSchema = z.object(input);
-    args = zodToConvexFields(input);
-  }
-  const returns = options?.returns && !containsCustom(options.returns) ? zodToConvex(options.returns) : void 0;
-  return action({
-    args,
-    returns,
-    handler: async (ctx, argsObject) => {
-      const decoded = fromConvexJS(argsObject, zodSchema);
-      let parsed;
-      try {
-        parsed = zodSchema.parse(decoded);
-      } catch (e) {
-        handleZodValidationError(e, "args");
-      }
-      const raw = await handler(ctx, parsed);
-      if (options?.returns) {
-        try {
-          const validated = options.returns.parse(raw);
-          return toConvexJS(options.returns, validated);
-        } catch (e) {
-          handleZodValidationError(e, "returns");
-        }
-      }
-      return toConvexJS(raw);
-    }
-  });
-}
-
-// src/builders.ts
-function zQueryBuilder(builder) {
-  return (config) => {
-    return zQuery(builder, config.args ?? {}, config.handler, {
-      returns: config.returns
-    });
-  };
-}
-function zMutationBuilder(builder) {
-  return (config) => {
-    return zMutation(builder, config.args ?? {}, config.handler, {
-      returns: config.returns
-    });
-  };
-}
-function zActionBuilder(builder) {
-  return (config) => {
-    return zAction(builder, config.args ?? {}, config.handler, {
-      returns: config.returns
-    });
-  };
-}
-function zCustomQueryBuilder(query, customization) {
-  return customFnBuilder(
-    query,
-    customization
-  );
-}
-function zCustomMutationBuilder(mutation, customization) {
-  return customFnBuilder(
-    mutation,
-    customization
-  );
-}
-function zCustomActionBuilder(action, customization) {
-  return customFnBuilder(
-    action,
-    customization
-  );
-}
-function zodDoc(tableName, schema) {
-  return schema.extend({
-    _id: zid(tableName),
-    _creationTime: z.number()
-  });
-}
-function zodDocOrNull(tableName, schema) {
-  return z.union([zodDoc(tableName, schema), z.null()]);
-}
-function zodTable(name, shape) {
-  const convexFields = zodToConvexFields(shape);
-  const table = Table(name, convexFields);
-  const zDoc = zodDoc(name, z.object(shape));
-  const docArray = z.array(zDoc);
-  return Object.assign(table, {
-    shape,
-    zDoc,
-    docArray
-  });
-}
-
-export { convexCodec, customFnBuilder, findBaseCodec, formatZodIssues, fromConvexJS, getObjectShape, handleZodValidationError, isDateSchema, makeUnion, mapDateFieldToNumber, pick, pickShape, registerBaseCodec, registryHelpers, returnsAs, safeOmit, safePick, toConvexJS, zActionBuilder, zCustomAction, zCustomActionBuilder, zCustomMutation, zCustomMutationBuilder, zCustomQuery, zCustomQueryBuilder, zMutationBuilder, zPaginated, zQueryBuilder, zid, zodDoc, zodDocOrNull, zodTable, zodToConvex, zodToConvexFields };
-//# sourceMappingURL=index.mjs.map
-//# sourceMappingURL=index.mjs.map