zodvex 0.2.4 → 0.3.1

package/dist/index.js

@@ -1,21 +1,20 @@
-'use strict';
-
-var customFunctions = require('convex-helpers/server/customFunctions');
-var zod = require('zod');
-var values = require('convex/values');
-var server = require('convex-helpers/server');
+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 { defineTable } from 'convex/server';
+import { Table } from 'convex-helpers/server';
 
+// src/index.ts
 var metadata = /* @__PURE__ */ new WeakMap();
 var registryHelpers = {
   getMetadata: (type) => metadata.get(type),
   setMetadata: (type, meta) => metadata.set(type, meta)
 };
 function zid(tableName) {
-  const baseSchema = zod.z.string().refine((val) => typeof val === "string" && val.length > 0, {
+  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}`);
+  }).describe(`convexId:${tableName}`);
   registryHelpers.setMetadata(baseSchema, {
     isConvexId: true,
     tableName
@@ -32,8 +31,8 @@ function findBaseCodec(schema) {
   return baseCodecs.find((codec) => codec.check(schema));
 }
 registerBaseCodec({
-  check: (schema) => schema instanceof zod.z.ZodDate,
-  toValidator: () => values.v.float64(),
+  check: (schema) => schema instanceof z.ZodDate,
+  toValidator: () => v.float64(),
   fromConvex: (value) => {
     if (typeof value === "number") {
       return new Date(value);
@@ -51,54 +50,104 @@ function asZodType(schema) {
   return schema;
 }
 function isDateSchema(schema) {
-  if (schema instanceof zod.z.ZodDate) return true;
-  if (schema instanceof zod.z.ZodOptional || schema instanceof zod.z.ZodNullable) {
+  if (schema instanceof z.ZodDate) return true;
+  if (schema instanceof z.ZodOptional || schema instanceof z.ZodNullable) {
     return isDateSchema(asZodType(schema.unwrap()));
   }
   return false;
 }
+function isZidSchema(schema) {
+  const description = schema.description;
+  return typeof description === "string" && description.startsWith("convexId:");
+}
+function getZidTableName(schema) {
+  const description = schema.description;
+  if (typeof description === "string" && description.startsWith("convexId:")) {
+    return description.slice("convexId:".length);
+  }
+  return void 0;
+}
+function zodvexJSONSchemaOverride(ctx) {
+  const { zodSchema, jsonSchema } = ctx;
+  if (isZidSchema(zodSchema)) {
+    const tableName = getZidTableName(zodSchema);
+    jsonSchema.type = "string";
+    if (tableName) {
+      jsonSchema.format = `convex-id:${tableName}`;
+    }
+    if (zodSchema.description) {
+      jsonSchema.description = zodSchema.description;
+    }
+    return;
+  }
+  if (zodSchema instanceof z.ZodDate || zodSchema.type === "date") {
+    jsonSchema.type = "string";
+    jsonSchema.format = "date-time";
+    return;
+  }
+}
+function composeOverrides(...overrides) {
+  return (ctx) => {
+    for (const override of overrides) {
+      override?.(ctx);
+    }
+  };
+}
+function toJSONSchema(schema, options) {
+  const userOverride = options?.override;
+  return z.toJSONSchema(schema, {
+    ...options,
+    // Default to 'any' so transforms don't throw
+    unrepresentable: options?.unrepresentable ?? "any",
+    // Chain our override with user's override
+    override: (ctx) => {
+      zodvexJSONSchemaOverride(ctx);
+      userOverride?.(ctx);
+    }
+  });
+}
 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) => values.v.literal(opt));
+    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 values.v.union(
+      return v.union(
         first,
         second,
         ...rest
       );
     } else {
-      return values.v.any();
+      return v.any();
     }
   } else {
-    return values.v.any();
+    return v.any();
   }
 }
 function convertNullableType(actualValidator, visited, zodToConvexInternal2) {
   const innerSchema = actualValidator.unwrap();
-  if (innerSchema && innerSchema instanceof zod.z.ZodType) {
-    if (innerSchema instanceof zod.z.ZodOptional) {
+  if (innerSchema && innerSchema instanceof z.ZodType) {
+    if (innerSchema instanceof z.ZodOptional) {
       const innerInnerSchema = innerSchema.unwrap();
       const innerInnerValidator = zodToConvexInternal2(innerInnerSchema, visited);
       return {
-        validator: values.v.union(innerInnerValidator, values.v.null()),
+        validator: v.union(innerInnerValidator, v.null()),
         isOptional: true
         // Mark as optional so it gets wrapped later
       };
     } else {
       const innerValidator = zodToConvexInternal2(innerSchema, visited);
       return {
-        validator: values.v.union(innerValidator, values.v.null()),
+        validator: v.union(innerValidator, v.null()),
         isOptional: false
       };
     }
   } else {
     return {
-      validator: values.v.any(),
+      validator: v.any(),
       isOptional: false
     };
   }
@@ -108,37 +157,37 @@ function convertRecordType(actualValidator, visited, zodToConvexInternal2) {
   if (!valueType) {
     valueType = actualValidator._def?.keyType;
   }
-  if (valueType && valueType instanceof zod.z.ZodType) {
-    const isZodOptional = valueType instanceof zod.z.ZodOptional || valueType instanceof zod.z.ZodDefault || valueType instanceof zod.z.ZodDefault && valueType.def.innerType instanceof zod.z.ZodOptional;
+  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 zod.z.ZodDefault) {
+      if (valueType instanceof z.ZodDefault) {
         recordHasDefault = true;
         recordDefaultValue = valueType.def.defaultValue;
         const innerFromDefault = valueType.def.innerType;
-        if (innerFromDefault instanceof zod.z.ZodOptional) {
+        if (innerFromDefault instanceof z.ZodOptional) {
           innerType = innerFromDefault.unwrap();
         } else {
           innerType = innerFromDefault;
         }
-      } else if (valueType instanceof zod.z.ZodOptional) {
+      } else if (valueType instanceof z.ZodOptional) {
         innerType = valueType.unwrap();
       } else {
         innerType = valueType;
       }
       const innerConvex = zodToConvexInternal2(innerType, visited);
-      const unionValidator = values.v.union(innerConvex, values.v.null());
+      const unionValidator = v.union(innerConvex, v.null());
       if (recordHasDefault) {
         unionValidator._zodDefault = recordDefaultValue;
       }
-      return values.v.record(values.v.string(), unionValidator);
+      return v.record(v.string(), unionValidator);
     } else {
-      return values.v.record(values.v.string(), zodToConvexInternal2(valueType, visited));
+      return v.record(v.string(), zodToConvexInternal2(valueType, visited));
     }
   } else {
-    return values.v.record(values.v.string(), values.v.any());
+    return v.record(v.string(), v.any());
   }
 }
 function convertDiscriminatedUnionType(actualValidator, visited, zodToConvexInternal2) {
@@ -151,16 +200,16 @@ function convertDiscriminatedUnionType(actualValidator, visited, zodToConvexInte
         return zodToConvexInternal2(opt, branchVisited);
       });
       const [first, second, ...rest] = convexOptions;
-      return values.v.union(
+      return v.union(
         first,
         second,
         ...rest
       );
     } else {
-      return values.v.any();
+      return v.any();
     }
   } else {
-    return values.v.any();
+    return v.any();
   }
 }
 function convertUnionType(actualValidator, visited, zodToConvexInternal2) {
@@ -175,17 +224,17 @@ function convertUnionType(actualValidator, visited, zodToConvexInternal2) {
       });
       if (convexOptions.length >= 2) {
         const [first, second, ...rest] = convexOptions;
-        return values.v.union(
+        return v.union(
           first,
           second,
           ...rest
         );
       } else {
-        return values.v.any();
+        return v.any();
       }
     }
   } else {
-    return values.v.any();
+    return v.any();
   }
 }
 function isZid(schema) {
@@ -194,12 +243,12 @@ function isZid(schema) {
 }
 function makeUnion(members) {
   const nonNull = members.filter(Boolean);
-  if (nonNull.length === 0) return values.v.any();
+  if (nonNull.length === 0) return v.any();
   if (nonNull.length === 1) return nonNull[0];
-  return values.v.union(nonNull[0], nonNull[1], ...nonNull.slice(2));
+  return v.union(nonNull[0], nonNull[1], ...nonNull.slice(2));
 }
 function getObjectShape(obj) {
-  if (obj instanceof zod.z.ZodObject) {
+  if (obj instanceof z.ZodObject) {
     return obj.shape;
   }
   if (obj && typeof obj === "object" && typeof obj.shape === "object") {
@@ -211,25 +260,25 @@ function getObjectShape(obj) {
 // src/mapping/core.ts
 function zodToConvexInternal(zodValidator, visited = /* @__PURE__ */ new Set()) {
   if (!zodValidator) {
-    return values.v.any();
+    return v.any();
   }
   if (visited.has(zodValidator)) {
-    return values.v.any();
+    return v.any();
   }
   visited.add(zodValidator);
   let actualValidator = zodValidator;
   let isOptional = false;
   let defaultValue = void 0;
   let hasDefault = false;
-  if (zodValidator instanceof zod.z.ZodDefault) {
+  if (zodValidator instanceof z.ZodDefault) {
     hasDefault = true;
     defaultValue = zodValidator.def?.defaultValue;
     actualValidator = zodValidator.def?.innerType;
   }
-  if (actualValidator instanceof zod.z.ZodOptional) {
+  if (actualValidator instanceof z.ZodOptional) {
     isOptional = true;
     actualValidator = actualValidator.unwrap();
-    if (actualValidator instanceof zod.z.ZodDefault) {
+    if (actualValidator instanceof z.ZodDefault) {
       hasDefault = true;
       defaultValue = actualValidator.def?.defaultValue;
       actualValidator = actualValidator.def?.innerType;
@@ -239,64 +288,64 @@ function zodToConvexInternal(zodValidator, visited = /* @__PURE__ */ new Set())
   if (isZid(actualValidator)) {
     const metadata2 = registryHelpers.getMetadata(actualValidator);
     const tableName = metadata2?.tableName || "unknown";
-    convexValidator = values.v.id(tableName);
+    convexValidator = v.id(tableName);
   } else {
     const defType = actualValidator.def?.type;
     switch (defType) {
       case "string":
-        convexValidator = values.v.string();
+        convexValidator = v.string();
         break;
       case "number":
-        convexValidator = values.v.float64();
+        convexValidator = v.float64();
         break;
       case "bigint":
-        convexValidator = values.v.int64();
+        convexValidator = v.int64();
         break;
       case "boolean":
-        convexValidator = values.v.boolean();
+        convexValidator = v.boolean();
         break;
       case "date":
-        convexValidator = values.v.float64();
+        convexValidator = v.float64();
         break;
       case "null":
-        convexValidator = values.v.null();
+        convexValidator = v.null();
         break;
       case "nan":
-        convexValidator = values.v.float64();
+        convexValidator = v.float64();
         break;
       case "array": {
-        if (actualValidator instanceof zod.z.ZodArray) {
+        if (actualValidator instanceof z.ZodArray) {
           const element = actualValidator.element;
-          if (element && element instanceof zod.z.ZodType) {
-            convexValidator = values.v.array(zodToConvexInternal(element, visited));
+          if (element && element instanceof z.ZodType) {
+            convexValidator = v.array(zodToConvexInternal(element, visited));
           } else {
-            convexValidator = values.v.array(values.v.any());
+            convexValidator = v.array(v.any());
           }
         } else {
-          convexValidator = values.v.array(values.v.any());
+          convexValidator = v.array(v.any());
         }
         break;
       }
       case "object": {
-        if (actualValidator instanceof zod.z.ZodObject) {
+        if (actualValidator instanceof z.ZodObject) {
           const shape = actualValidator.shape;
           const convexShape = {};
           for (const [key, value] of Object.entries(shape)) {
-            if (value && value instanceof zod.z.ZodType) {
+            if (value && value instanceof z.ZodType) {
               convexShape[key] = zodToConvexInternal(value, visited);
             }
           }
-          convexValidator = values.v.object(convexShape);
+          convexValidator = v.object(convexShape);
         } else {
-          convexValidator = values.v.object({});
+          convexValidator = v.object({});
         }
         break;
       }
       case "union": {
-        if (actualValidator instanceof zod.z.ZodUnion) {
+        if (actualValidator instanceof z.ZodUnion) {
           convexValidator = convertUnionType(actualValidator, visited, zodToConvexInternal);
         } else {
-          convexValidator = values.v.any();
+          convexValidator = v.any();
         }
         break;
       }
@@ -309,31 +358,31 @@ function zodToConvexInternal(zodValidator, visited = /* @__PURE__ */ new Set())
         break;
       }
       case "literal": {
-        if (actualValidator instanceof zod.z.ZodLiteral) {
+        if (actualValidator instanceof z.ZodLiteral) {
           const literalValue = actualValidator.value;
           if (literalValue !== void 0 && literalValue !== null) {
-            convexValidator = values.v.literal(literalValue);
+            convexValidator = v.literal(literalValue);
           } else {
-            convexValidator = values.v.any();
+            convexValidator = v.any();
           }
         } else {
-          convexValidator = values.v.any();
+          convexValidator = v.any();
         }
         break;
       }
       case "enum": {
-        if (actualValidator instanceof zod.z.ZodEnum) {
+        if (actualValidator instanceof z.ZodEnum) {
           convexValidator = convertEnumType(actualValidator);
         } else {
-          convexValidator = values.v.any();
+          convexValidator = v.any();
         }
         break;
       }
       case "record": {
-        if (actualValidator instanceof zod.z.ZodRecord) {
+        if (actualValidator instanceof z.ZodRecord) {
           convexValidator = convertRecordType(actualValidator, visited, zodToConvexInternal);
         } else {
-          convexValidator = values.v.record(values.v.string(), values.v.any());
+          convexValidator = v.record(v.string(), v.any());
         }
         break;
       }
@@ -347,75 +396,75 @@ function zodToConvexInternal(zodValidator, visited = /* @__PURE__ */ new Set())
           if (metadata2?.brand && metadata2?.originalSchema) {
             convexValidator = zodToConvexInternal(metadata2.originalSchema, visited);
           } else {
-            convexValidator = values.v.any();
+            convexValidator = v.any();
           }
         }
         break;
       }
       case "nullable": {
-        if (actualValidator instanceof zod.z.ZodNullable) {
+        if (actualValidator instanceof z.ZodNullable) {
           const result = convertNullableType(actualValidator, visited, zodToConvexInternal);
           convexValidator = result.validator;
           if (result.isOptional) {
             isOptional = true;
           }
         } else {
-          convexValidator = values.v.any();
+          convexValidator = v.any();
         }
         break;
       }
       case "tuple": {
-        if (actualValidator instanceof zod.z.ZodTuple) {
+        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 = values.v.object(convexShape);
+            convexValidator = v.object(convexShape);
           } else {
-            convexValidator = values.v.object({});
+            convexValidator = v.object({});
           }
         } else {
-          convexValidator = values.v.object({});
+          convexValidator = v.object({});
         }
         break;
       }
       case "lazy": {
-        if (actualValidator instanceof zod.z.ZodLazy) {
+        if (actualValidator instanceof z.ZodLazy) {
           try {
             const getter = actualValidator.def?.getter;
             if (getter) {
               const resolvedSchema = getter();
-              if (resolvedSchema && resolvedSchema instanceof zod.z.ZodType) {
+              if (resolvedSchema && resolvedSchema instanceof z.ZodType) {
                 convexValidator = zodToConvexInternal(resolvedSchema, visited);
               } else {
-                convexValidator = values.v.any();
+                convexValidator = v.any();
               }
             } else {
-              convexValidator = values.v.any();
+              convexValidator = v.any();
             }
           } catch {
-            convexValidator = values.v.any();
+            convexValidator = v.any();
           }
         } else {
-          convexValidator = values.v.any();
+          convexValidator = v.any();
         }
         break;
       }
       case "any":
-        convexValidator = values.v.any();
+        convexValidator = v.any();
         break;
       case "unknown":
-        convexValidator = values.v.any();
+        convexValidator = v.any();
         break;
       case "undefined":
       case "void":
       case "never":
-        convexValidator = values.v.any();
+        convexValidator = v.any();
         break;
       case "intersection":
-        convexValidator = values.v.any();
+        convexValidator = v.any();
         break;
       default:
         if (process.env.NODE_ENV !== "production") {
@@ -425,24 +474,24 @@ function zodToConvexInternal(zodValidator, visited = /* @__PURE__ */ new Set())
             actualValidator
           );
         }
-        convexValidator = values.v.any();
+        convexValidator = v.any();
         break;
     }
   }
-  const finalValidator = isOptional || hasDefault ? values.v.optional(convexValidator) : convexValidator;
+  const finalValidator = isOptional || hasDefault ? v.optional(convexValidator) : convexValidator;
   if (hasDefault && typeof finalValidator === "object" && finalValidator !== null) {
     finalValidator._zodDefault = defaultValue;
   }
   return finalValidator;
 }
-function zodToConvex(zod$1) {
-  if (typeof zod$1 === "object" && zod$1 !== null && !(zod$1 instanceof zod.z.ZodType)) {
-    return zodToConvexFields(zod$1);
+function zodToConvex(zod) {
+  if (typeof zod === "object" && zod !== null && !(zod instanceof z.ZodType)) {
+    return zodToConvexFields(zod);
   }
-  return zodToConvexInternal(zod$1);
+  return zodToConvexInternal(zod);
 }
-function zodToConvexFields(zod$1) {
-  const fields = zod$1 instanceof zod.z.ZodObject ? zod$1.shape : zod$1;
+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);
@@ -461,7 +510,7 @@ function convexCodec(schema) {
     encode: (value) => toConvexJS(schema, value),
     decode: (value) => fromConvexJS(value, schema),
     pick: (keys) => {
-      if (!(schema instanceof zod.z.ZodObject)) {
+      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;
@@ -501,18 +550,18 @@ function schemaToConvex(value, schema) {
   if (codec) {
     return codec.toConvex(value, schema);
   }
-  if (schema instanceof zod.z.ZodOptional || schema instanceof zod.z.ZodNullable || schema instanceof zod.z.ZodDefault) {
+  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 zod.z.ZodDate && value instanceof Date) {
+  if (schema instanceof z.ZodDate && value instanceof Date) {
     return value.getTime();
   }
-  if (schema instanceof zod.z.ZodArray) {
+  if (schema instanceof z.ZodArray) {
     if (!Array.isArray(value)) return value;
     return value.map((item) => schemaToConvex(item, schema.element));
   }
-  if (schema instanceof zod.z.ZodObject) {
+  if (schema instanceof z.ZodObject) {
     if (!value || typeof value !== "object") return value;
     const shape = schema.shape;
     const result = {};
@@ -523,7 +572,7 @@ function schemaToConvex(value, schema) {
     }
     return result;
   }
-  if (schema instanceof zod.z.ZodUnion) {
+  if (schema instanceof z.ZodUnion) {
     for (const option of schema.options) {
       try {
         ;
@@ -533,7 +582,7 @@ function schemaToConvex(value, schema) {
       }
     }
   }
-  if (schema instanceof zod.z.ZodRecord) {
+  if (schema instanceof z.ZodRecord) {
     if (!value || typeof value !== "object") return value;
     const result = {};
     for (const [k, v8] of Object.entries(value)) {
@@ -551,21 +600,21 @@ function fromConvexJS(value, schema) {
   if (codec) {
     return codec.fromConvex(value, schema);
   }
-  if (schema instanceof zod.z.ZodOptional || schema instanceof zod.z.ZodNullable || schema instanceof zod.z.ZodDefault) {
+  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 zod.z.ZodDate && typeof value === "number") {
+  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 zod.z.ZodArray) {
+  if (schema instanceof z.ZodArray) {
     if (!Array.isArray(value)) return value;
     return value.map((item) => fromConvexJS(item, schema.element));
   }
-  if (schema instanceof zod.z.ZodObject) {
+  if (schema instanceof z.ZodObject) {
     if (!value || typeof value !== "object") return value;
     const shape = schema.shape;
     const result = {};
@@ -574,7 +623,7 @@ function fromConvexJS(value, schema) {
     }
     return result;
   }
-  if (schema instanceof zod.z.ZodUnion) {
+  if (schema instanceof z.ZodUnion) {
     for (const option of schema.options) {
       try {
         const decoded = fromConvexJS(value, option);
@@ -584,7 +633,7 @@ function fromConvexJS(value, schema) {
       }
     }
   }
-  if (schema instanceof zod.z.ZodRecord) {
+  if (schema instanceof z.ZodRecord) {
     if (!value || typeof value !== "object") return value;
     const result = {};
     for (const [k, v8] of Object.entries(value)) {
@@ -592,7 +641,7 @@ function fromConvexJS(value, schema) {
     }
     return result;
   }
-  if (schema instanceof zod.z.ZodTransform) {
+  if (schema instanceof z.ZodTransform) {
     return value;
   }
   return value;
@@ -621,32 +670,32 @@ function formatZodIssues(error, context) {
   };
 }
 function handleZodValidationError(e, context) {
-  if (e instanceof zod.z.ZodError) {
-    throw new values.ConvexError(formatZodIssues(e, context));
+  if (e instanceof z.ZodError) {
+    throw new ConvexError(formatZodIssues(e, context));
   }
   throw e;
 }
 function zPaginated(item) {
-  return zod.z.object({
-    page: zod.z.array(item),
-    isDone: zod.z.boolean(),
-    continueCursor: zod.z.string().nullable().optional()
+  return z.object({
+    page: z.array(item),
+    isDone: z.boolean(),
+    continueCursor: z.string().nullable().optional()
   });
 }
 function mapDateFieldToNumber(field) {
-  if (field instanceof zod.z.ZodDate) {
-    return zod.z.number();
+  if (field instanceof z.ZodDate) {
+    return z.number();
   }
-  if (field instanceof zod.z.ZodOptional && field.unwrap() instanceof zod.z.ZodDate) {
-    return zod.z.number().optional();
+  if (field instanceof z.ZodOptional && field.unwrap() instanceof z.ZodDate) {
+    return z.number().optional();
   }
-  if (field instanceof zod.z.ZodNullable && field.unwrap() instanceof zod.z.ZodDate) {
-    return zod.z.number().nullable();
+  if (field instanceof z.ZodNullable && field.unwrap() instanceof z.ZodDate) {
+    return z.number().nullable();
   }
-  if (field instanceof zod.z.ZodDefault) {
+  if (field instanceof z.ZodDefault) {
     const inner = field.removeDefault();
-    if (inner instanceof zod.z.ZodDate) {
-      return zod.z.number().optional();
+    if (inner instanceof z.ZodDate) {
+      return z.number().optional();
     }
   }
   return field;
@@ -657,7 +706,7 @@ function toKeys(mask) {
 }
 function pickShape(schemaOrShape, mask) {
   const keys = toKeys(mask);
-  const shape = schemaOrShape instanceof zod.z.ZodObject ? getObjectShape(schemaOrShape) : schemaOrShape || {};
+  const shape = schemaOrShape instanceof z.ZodObject ? getObjectShape(schemaOrShape) : schemaOrShape || {};
   const out = {};
   for (const k of keys) {
     if (k in shape) out[k] = shape[k];
@@ -665,29 +714,30 @@ function pickShape(schemaOrShape, mask) {
   return out;
 }
 function safePick(schema, mask) {
-  return zod.z.object(pickShape(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 zod.z.object(picked);
+  return z.object(picked);
 }
 
 // src/custom.ts
 function customFnBuilder(builder, customization) {
-  const customInput = customization.input ?? customFunctions.NoOp.input;
-  const inputArgs = customization.args ?? customFunctions.NoOp.args;
+  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 zod.z.ZodType) ? zod.z.object(maybeObject) : maybeObject;
-    const returnValidator = returns && !fn.skipConvexValidation ? { returns: zodToConvex(returns) } : void 0;
-    if (args && !fn.skipConvexValidation) {
+    const skipConvexValidation = fn.skipConvexValidation ?? false;
+    const returns = maybeObject && !(maybeObject instanceof z.ZodType) ? z.object(maybeObject) : maybeObject;
+    const returnValidator = returns && !skipConvexValidation ? { returns: zodToConvex(returns) } : void 0;
+    if (args) {
       let argsValidator = args;
       let argsSchema;
-      if (argsValidator instanceof zod.z.ZodType) {
-        if (argsValidator instanceof zod.z.ZodObject) {
+      if (argsValidator instanceof z.ZodType) {
+        if (argsValidator instanceof z.ZodObject) {
           argsSchema = argsValidator;
           argsValidator = argsValidator.shape;
         } else {
@@ -696,11 +746,11 @@ function customFnBuilder(builder, customization) {
           );
         }
       } else {
-        argsSchema = zod.z.object(argsValidator);
+        argsSchema = z.object(argsValidator);
       }
-      const convexValidator = zodToConvexFields(argsValidator);
+      const convexArgs = skipConvexValidation ? inputArgs : { ...zodToConvexFields(argsValidator), ...inputArgs };
       return builder({
-        args: { ...convexValidator, ...inputArgs },
+        args: convexArgs,
         ...returnValidator,
         handler: async (ctx, allArgs) => {
           const added = await customInput(
@@ -720,7 +770,7 @@ function customFnBuilder(builder, customization) {
           const addedArgs = added?.args ?? {};
           const finalArgs = { ...baseArgs, ...addedArgs };
           const ret = await handler(finalCtx, finalArgs);
-          if (returns && !fn.skipConvexValidation) {
+          if (returns) {
             let validated;
             try {
               validated = returns.parse(ret);
@@ -757,7 +807,7 @@ function customFnBuilder(builder, customization) {
         const addedArgs = added?.args ?? {};
         const finalArgs = { ...baseArgs, ...addedArgs };
         const ret = await handler(finalCtx, finalArgs);
-        if (returns && !fn.skipConvexValidation) {
+        if (returns) {
           let validated;
           try {
             validated = returns.parse(ret);
@@ -802,17 +852,17 @@ function containsCustom(schema, maxDepth = 50, currentDepth = 0) {
     return false;
   }
   let result = false;
-  if (schema._def?.typeName === "ZodCustom") {
+  if (schema instanceof z.ZodCustom) {
     result = true;
-  } else if (schema instanceof zod.z.ZodUnion) {
+  } else if (schema instanceof z.ZodUnion) {
     result = schema.options.some(
       (opt) => containsCustom(opt, maxDepth, currentDepth + 1)
     );
-  } else if (schema instanceof zod.z.ZodOptional) {
+  } else if (schema instanceof z.ZodOptional) {
     result = containsCustom(schema.unwrap(), maxDepth, currentDepth + 1);
-  } else if (schema instanceof zod.z.ZodNullable) {
+  } else if (schema instanceof z.ZodNullable) {
     result = containsCustom(schema.unwrap(), maxDepth, currentDepth + 1);
-  } else if (schema instanceof zod.z.ZodDefault) {
+  } else if (schema instanceof z.ZodDefault) {
     result = containsCustom(schema.removeDefault(), maxDepth, currentDepth + 1);
   }
   customCheckCache.set(schema, result);
@@ -821,15 +871,15 @@ function containsCustom(schema, maxDepth = 50, currentDepth = 0) {
 function zQuery(query, input, handler, options) {
   let zodSchema;
   let args;
-  if (input instanceof zod.z.ZodObject) {
+  if (input instanceof z.ZodObject) {
     const zodObj = input;
     zodSchema = zodObj;
     args = zodToConvexFields(getObjectShape(zodObj));
-  } else if (input instanceof zod.z.ZodType) {
-    zodSchema = zod.z.object({ value: input });
+  } else if (input instanceof z.ZodType) {
+    zodSchema = z.object({ value: input });
     args = { value: zodToConvex(input) };
   } else {
-    zodSchema = zod.z.object(input);
+    zodSchema = z.object(input);
     args = zodToConvexFields(input);
   }
   const returns = options?.returns && !containsCustom(options.returns) ? zodToConvex(options.returns) : void 0;
@@ -860,15 +910,15 @@ function zQuery(query, input, handler, options) {
 function zMutation(mutation, input, handler, options) {
   let zodSchema;
   let args;
-  if (input instanceof zod.z.ZodObject) {
+  if (input instanceof z.ZodObject) {
     const zodObj = input;
     zodSchema = zodObj;
     args = zodToConvexFields(getObjectShape(zodObj));
-  } else if (input instanceof zod.z.ZodType) {
-    zodSchema = zod.z.object({ value: input });
+  } else if (input instanceof z.ZodType) {
+    zodSchema = z.object({ value: input });
     args = { value: zodToConvex(input) };
   } else {
-    zodSchema = zod.z.object(input);
+    zodSchema = z.object(input);
     args = zodToConvexFields(input);
   }
   const returns = options?.returns && !containsCustom(options.returns) ? zodToConvex(options.returns) : void 0;
@@ -899,15 +949,15 @@ function zMutation(mutation, input, handler, options) {
 function zAction(action, input, handler, options) {
   let zodSchema;
   let args;
-  if (input instanceof zod.z.ZodObject) {
+  if (input instanceof z.ZodObject) {
     const zodObj = input;
     zodSchema = zodObj;
     args = zodToConvexFields(getObjectShape(zodObj));
-  } else if (input instanceof zod.z.ZodType) {
-    zodSchema = zod.z.object({ value: input });
+  } else if (input instanceof z.ZodType) {
+    zodSchema = z.object({ value: input });
     args = { value: zodToConvex(input) };
   } else {
-    zodSchema = zod.z.object(input);
+    zodSchema = z.object(input);
     args = zodToConvexFields(input);
   }
   const returns = options?.returns && !containsCustom(options.returns) ? zodToConvex(options.returns) : void 0;
@@ -976,64 +1026,78 @@ function zCustomActionBuilder(action, customization) {
     customization
   );
 }
+function addSystemFields(tableName, schema) {
+  if (schema instanceof z.ZodUnion || schema instanceof z.ZodDiscriminatedUnion) {
+    const options = schema.options.map((variant) => {
+      if (variant instanceof z.ZodObject) {
+        return variant.extend({
+          _id: zid(tableName),
+          _creationTime: z.number()
+        });
+      }
+      return variant;
+    });
+    return z.union(options);
+  }
+  if (schema instanceof z.ZodObject) {
+    return schema.extend({
+      _id: zid(tableName),
+      _creationTime: z.number()
+    });
+  }
+  return schema;
+}
 function zodDoc(tableName, schema) {
   return schema.extend({
     _id: zid(tableName),
-    _creationTime: zod.z.number()
+    _creationTime: z.number()
   });
 }
 function zodDocOrNull(tableName, schema) {
-  return zod.z.union([zodDoc(tableName, schema), zod.z.null()]);
+  return z.union([zodDoc(tableName, schema), z.null()]);
 }
-function zodTable(name, shape) {
-  const convexFields = zodToConvexFields(shape);
-  const table = server.Table(name, convexFields);
-  const zDoc = zodDoc(name, zod.z.object(shape));
-  const docArray = zod.z.array(zDoc);
-  return Object.assign(table, {
-    shape,
-    zDoc,
-    docArray
-  });
+function isObjectShape(input) {
+  if (!input || typeof input !== "object") return false;
+  if (input instanceof z.ZodType) return false;
+  for (const key in input) {
+    if (!(input[key] instanceof z.ZodType)) {
+      return false;
+    }
+  }
+  return true;
+}
+function zodTable(name, schemaOrShape) {
+  if (isObjectShape(schemaOrShape)) {
+    const shape = schemaOrShape;
+    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
+    });
+  } else {
+    const schema = schemaOrShape;
+    const convexValidator = zodToConvex(schema);
+    const table = defineTable(convexValidator);
+    const withFields = addSystemFields(name, schema);
+    const docArray = z.array(withFields);
+    return {
+      table,
+      tableName: name,
+      validator: convexValidator,
+      schema,
+      docArray,
+      withSystemFields: () => addSystemFields(name, schema)
+    };
+  }
 }
 
-Object.defineProperty(exports, "customCtx", {
-  enumerable: true,
-  get: function () { return customFunctions.customCtx; }
-});
-exports.convexCodec = convexCodec;
-exports.customFnBuilder = customFnBuilder;
-exports.findBaseCodec = findBaseCodec;
-exports.formatZodIssues = formatZodIssues;
-exports.fromConvexJS = fromConvexJS;
-exports.getObjectShape = getObjectShape;
-exports.handleZodValidationError = handleZodValidationError;
-exports.isDateSchema = isDateSchema;
-exports.makeUnion = makeUnion;
-exports.mapDateFieldToNumber = mapDateFieldToNumber;
-exports.pick = pick;
-exports.pickShape = pickShape;
-exports.registerBaseCodec = registerBaseCodec;
-exports.registryHelpers = registryHelpers;
-exports.returnsAs = returnsAs;
-exports.safeOmit = safeOmit;
-exports.safePick = safePick;
-exports.toConvexJS = toConvexJS;
-exports.zActionBuilder = zActionBuilder;
-exports.zCustomAction = zCustomAction;
-exports.zCustomActionBuilder = zCustomActionBuilder;
-exports.zCustomMutation = zCustomMutation;
-exports.zCustomMutationBuilder = zCustomMutationBuilder;
-exports.zCustomQuery = zCustomQuery;
-exports.zCustomQueryBuilder = zCustomQueryBuilder;
-exports.zMutationBuilder = zMutationBuilder;
-exports.zPaginated = zPaginated;
-exports.zQueryBuilder = zQueryBuilder;
-exports.zid = zid;
-exports.zodDoc = zodDoc;
-exports.zodDocOrNull = zodDocOrNull;
-exports.zodTable = zodTable;
-exports.zodToConvex = zodToConvex;
-exports.zodToConvexFields = zodToConvexFields;
+export { addSystemFields, composeOverrides, convexCodec, customFnBuilder, findBaseCodec, formatZodIssues, fromConvexJS, getObjectShape, getZidTableName, handleZodValidationError, isDateSchema, isZidSchema, makeUnion, mapDateFieldToNumber, pick, pickShape, registerBaseCodec, registryHelpers, returnsAs, safeOmit, safePick, toConvexJS, toJSONSchema, zActionBuilder, zCustomAction, zCustomActionBuilder, zCustomMutation, zCustomMutationBuilder, zCustomQuery, zCustomQueryBuilder, zMutationBuilder, zPaginated, zQueryBuilder, zid, zodDoc, zodDocOrNull, zodTable, zodToConvex, zodToConvexFields, zodvexJSONSchemaOverride };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map