zodvex 0.3.2 → 0.4.1

package/dist/index.d.ts

@@ -1,600 +1,12 @@
-import { Customization } from 'convex-helpers/server/customFunctions';
 export { customCtx } from 'convex-helpers/server/customFunctions';
-import * as convex_server from 'convex/server';
-import { RegisteredQuery, RegisteredMutation, RegisteredAction, DefaultFunctionArgs, FunctionVisibility, ArgsArrayToObject, GenericDataModel, QueryBuilder, GenericQueryCtx, defineTable } from 'convex/server';
-import * as convex_values from 'convex/values';
-import { VAny, VOptional, VUnion, VId, GenericId, VString, VFloat64, VInt64, VBoolean, VNull, VArray, VObject, VLiteral, VRecord, PropertyValidators } from 'convex/values';
-import { z } from 'zod';
-import { Table } from 'convex-helpers/server';
-
-type IsZid<T> = T extends {
-    _tableName: infer _TableName extends string;
-} ? true : false;
-type ExtractTableName<T> = T extends {
-    _tableName: infer TableName;
-} ? TableName : never;
-type EnumToLiteralsTuple<T extends readonly [string, ...string[]]> = T['length'] extends 1 ? [VLiteral<T[0], 'required'>] : T['length'] extends 2 ? [VLiteral<T[0], 'required'>, VLiteral<T[1], 'required'>] : [
-    VLiteral<T[0], 'required'>,
-    VLiteral<T[1], 'required'>,
-    ...{
-        [K in keyof T]: K extends '0' | '1' ? never : K extends keyof T ? VLiteral<T[K], 'required'> : never;
-    }[keyof T & number][]
-];
-type ZodValidator = Record<string, z.ZodTypeAny>;
-type ConvexValidatorFromZodRequired<Z extends z.ZodTypeAny> = Z extends z.ZodOptional<infer T extends z.ZodTypeAny> ? VUnion<z.infer<T> | null, any[], 'required'> : ConvexValidatorFromZodBase<Z>;
-type ConvexValidatorFromZodBase<Z extends z.ZodTypeAny> = IsZid<Z> extends true ? ExtractTableName<Z> extends infer TableName extends string ? VId<GenericId<TableName>, 'required'> : VAny<'required'> : Z extends z.ZodString ? VString<z.infer<Z>, 'required'> : Z extends z.ZodNumber ? VFloat64<z.infer<Z>, 'required'> : Z extends z.ZodDate ? VFloat64<number, 'required'> : Z extends z.ZodBigInt ? VInt64<z.infer<Z>, 'required'> : Z extends z.ZodBoolean ? VBoolean<z.infer<Z>, 'required'> : Z extends z.ZodNull ? VNull<null, 'required'> : Z extends z.ZodArray<infer T extends z.ZodTypeAny> ? VArray<z.infer<Z>, ConvexValidatorFromZodRequired<T>, 'required'> : Z extends z.ZodObject<infer T> ? VObject<z.infer<Z>, ConvexValidatorFromZodFieldsAuto<T>, 'required', string> : Z extends z.ZodUnion<infer T> ? T extends readonly [z.ZodTypeAny, z.ZodTypeAny, ...z.ZodTypeAny[]] ? VUnion<z.infer<Z>, any[], 'required'> : never : Z extends z.ZodLiteral<infer T> ? VLiteral<T, 'required'> : Z extends z.ZodEnum<infer T> ? T extends readonly [string, ...string[]] ? T['length'] extends 1 ? VLiteral<T[0], 'required'> : T['length'] extends 2 ? VUnion<T[number], [
-    VLiteral<T[0], 'required'>,
-    VLiteral<T[1], 'required'>
-], 'required', never> : VUnion<T[number], EnumToLiteralsTuple<T>, 'required', never> : T extends Record<string, string | number> ? VUnion<T[keyof T], Array<VLiteral<T[keyof T], 'required'>>, 'required', never> : VUnion<string, any[], 'required', any> : Z extends z.ZodRecord<z.ZodString, infer V extends z.ZodTypeAny> ? VRecord<Record<string, z.infer<V>>, VString<string, 'required'>, ConvexValidatorFromZodRequired<V>, 'required', string> : Z extends z.ZodNullable<infer Inner extends z.ZodTypeAny> ? Inner extends z.ZodOptional<infer InnerInner extends z.ZodTypeAny> ? VOptional<VUnion<z.infer<InnerInner> | null, [
-    ConvexValidatorFromZodBase<InnerInner>,
-    VNull<null, 'required'>
-], 'required'>> : VUnion<z.infer<Inner> | null, [
-    ConvexValidatorFromZodBase<Inner>,
-    VNull<null, 'required'>
-], 'required'> : Z extends z.ZodAny ? VAny<'required'> : Z extends z.ZodUnknown ? VAny<'required'> : VAny<'required'>;
-type ConvexValidatorFromZod<Z extends z.ZodTypeAny, Constraint extends 'required' | 'optional' = 'required'> = Z extends z.ZodAny ? VAny<'required'> : Z extends z.ZodUnknown ? VAny<'required'> : Z extends z.ZodDefault<infer T extends z.ZodTypeAny> ? ConvexValidatorFromZod<T, Constraint> : Z extends z.ZodOptional<infer T extends z.ZodTypeAny> ? T extends z.ZodNullable<infer Inner extends z.ZodTypeAny> ? VOptional<VUnion<z.infer<Inner> | null, any[], 'required'>> : Constraint extends 'required' ? VUnion<z.infer<T>, any[], 'required'> : VOptional<ConvexValidatorFromZod<T, 'required'>> : Z extends z.ZodNullable<infer T extends z.ZodTypeAny> ? VUnion<z.infer<T> | null, any[], Constraint> : IsZid<Z> extends true ? ExtractTableName<Z> extends infer TableName extends string ? VId<GenericId<TableName>, Constraint> : VAny<'required'> : Z extends z.ZodString ? VString<z.infer<Z>, Constraint> : Z extends z.ZodNumber ? VFloat64<z.infer<Z>, Constraint> : Z extends z.ZodDate ? VFloat64<number, Constraint> : Z extends z.ZodBigInt ? VInt64<z.infer<Z>, Constraint> : Z extends z.ZodBoolean ? VBoolean<z.infer<Z>, Constraint> : Z extends z.ZodNull ? VNull<null, Constraint> : Z extends z.ZodArray<infer T extends z.ZodTypeAny> ? VArray<z.infer<Z>, ConvexValidatorFromZodRequired<T>, Constraint> : Z extends z.ZodObject<infer T> ? VObject<z.infer<Z>, ConvexValidatorFromZodFields<T, 'required'>, Constraint, string> : Z extends z.ZodUnion<infer T> ? T extends readonly [z.ZodTypeAny, z.ZodTypeAny, ...z.ZodTypeAny[]] ? VUnion<z.infer<Z>, any[], Constraint> : never : Z extends z.ZodLiteral<infer T> ? VLiteral<T, Constraint> : Z extends z.ZodEnum<infer T> ? T extends readonly [string, ...string[]] ? T['length'] extends 1 ? VLiteral<T[0], Constraint> : T['length'] extends 2 ? VUnion<T[number], [
-    VLiteral<T[0], 'required'>,
-    VLiteral<T[1], 'required'>
-], Constraint, never> : VUnion<T[number], EnumToLiteralsTuple<T>, Constraint, never> : T extends Record<string, string | number> ? VUnion<T[keyof T], Array<VLiteral<T[keyof T], 'required'>>, Constraint, never> : VUnion<string, any[], Constraint, any> : Z extends z.ZodRecord<z.ZodString, infer V extends z.ZodTypeAny> ? VRecord<Record<string, z.infer<V>>, VString<string, 'required'>, ConvexValidatorFromZodRequired<V>, Constraint, string> : VAny<'required'>;
-type ConvexValidatorFromZodFields<T extends {
-    [key: string]: any;
-}, Constraint extends 'required' | 'optional' = 'required'> = {
-    [K in keyof T]: T[K] extends z.ZodTypeAny ? ConvexValidatorFromZod<T[K], Constraint> : VAny<'required'>;
-};
-type ConvexValidatorFromZodFieldsAuto<T extends {
-    [key: string]: any;
-}> = {
-    [K in keyof T]: T[K] extends z.ZodOptional<any> ? ConvexValidatorFromZod<T[K], 'optional'> : T[K] extends z.ZodDefault<any> ? ConvexValidatorFromZod<T[K], 'optional'> : T[K] extends z.ZodNullable<any> ? ConvexValidatorFromZod<T[K], 'required'> : T[K] extends z.ZodEnum<any> ? ConvexValidatorFromZod<T[K], 'required'> : T[K] extends z.ZodTypeAny ? ConvexValidatorFromZod<T[K], 'required'> : VAny<'required'>;
-};
-
-declare function zodToConvex<Z extends z.ZodTypeAny | ZodValidator>(zod: Z): Z extends z.ZodTypeAny ? ConvexValidatorFromZod<Z, 'required'> : Z extends ZodValidator ? ConvexValidatorFromZodFieldsAuto<Z> : never;
-declare function zodToConvexFields<Z extends z.ZodRawShape>(zod: Z): ConvexValidatorFromZodFieldsAuto<Z>;
-
-/**
- * IDs + registry for Convex + Zod v4
- */
-
-declare const registryHelpers: {
-    getMetadata: (type: z.ZodTypeAny) => any;
-    setMetadata: (type: z.ZodTypeAny, meta: any) => WeakMap<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, any>;
-};
-/**
- * Create a Zod validator for a Convex Id
- *
- * Compatible with AI SDK and other tools that don't support transforms.
- * Uses type-level branding instead of runtime transforms for GenericId<T> compatibility.
- *
- * @param tableName - The Convex table name for this ID
- * @returns A Zod string validator typed as GenericId<TableName>
- */
-declare function zid<TableName extends string>(tableName: TableName): z.ZodType<GenericId<TableName>> & {
-    _tableName: TableName;
-};
-type Zid<TableName extends string> = ReturnType<typeof zid<TableName>>;
-
-declare function makeUnion(members: any[]): any;
-declare function getObjectShape(obj: any): Record<string, any>;
-
-type InferArgs<A> = A extends z.ZodObject<infer S> ? z.infer<z.ZodObject<S>> : A extends Record<string, z.ZodTypeAny> ? {
-    [K in keyof A]: z.infer<A[K]>;
-} : A extends z.ZodTypeAny ? z.infer<A> : Record<string, never>;
-type InferReturns<R> = R extends z.ZodType<any, any, any> ? z.output<R> : R extends undefined ? any : R;
-type InferHandlerReturns<R> = R extends z.ZodType<any, any, any> ? z.input<R> : any;
-/**
- * Extract the visibility type from a Convex builder function
- */
-type ExtractVisibility<Builder extends (...args: any) => any> = ReturnType<Builder> extends RegisteredQuery<infer V, any, any> ? V : ReturnType<Builder> extends RegisteredMutation<infer V, any, any> ? V : ReturnType<Builder> extends RegisteredAction<infer V, any, any> ? V : 'public';
-/**
- * @deprecated Use GenericQueryCtx, GenericMutationCtx, or GenericActionCtx directly instead
- */
-type ExtractCtx<Builder> = Builder extends {
-    (fn: {
-        handler: (ctx: infer Ctx, ...args: any[]) => any;
-    }): any;
-} ? Ctx : never;
-/**
- * @deprecated Return types are now specified explicitly using RegisteredQuery, RegisteredMutation, or RegisteredAction
- */
-type PreserveReturnType<Builder extends (...args: any) => any, ArgsType, ReturnsType> = ReturnType<Builder> extends RegisteredQuery<infer V, any, any> ? RegisteredQuery<V, ArgsType extends DefaultFunctionArgs ? ArgsType : DefaultFunctionArgs, Promise<ReturnsType>> : ReturnType<Builder> extends RegisteredMutation<infer V, any, any> ? RegisteredMutation<V, ArgsType extends DefaultFunctionArgs ? ArgsType : DefaultFunctionArgs, Promise<ReturnsType>> : ReturnType<Builder> extends RegisteredAction<infer V, any, any> ? RegisteredAction<V, ArgsType extends DefaultFunctionArgs ? ArgsType : DefaultFunctionArgs, Promise<ReturnsType>> : ReturnType<Builder>;
-type ZodToConvexArgs<A> = A extends z.ZodObject<any> ? z.infer<A> : A extends Record<string, z.ZodTypeAny> ? {
-    [K in keyof A]: z.infer<A[K]>;
-} : A extends z.ZodTypeAny ? {
-    value: z.infer<A>;
-} : Record<string, never>;
-
-type OneArgArray<ArgsObject extends DefaultFunctionArgs = DefaultFunctionArgs> = [ArgsObject];
-type NullToUndefinedOrNull<T> = T extends null ? T | undefined | void : T;
-type Returns<T> = Promise<NullToUndefinedOrNull<T>> | NullToUndefinedOrNull<T>;
-type ReturnValueInput<ReturnsValidator extends z.ZodTypeAny | ZodValidator | void> = [
-    ReturnsValidator
-] extends [z.ZodTypeAny] ? Returns<z.input<ReturnsValidator>> : [ReturnsValidator] extends [ZodValidator] ? Returns<z.input<z.ZodObject<ReturnsValidator>>> : any;
-type ReturnValueOutput<ReturnsValidator extends z.ZodTypeAny | ZodValidator | void> = [
-    ReturnsValidator
-] extends [z.ZodTypeAny] ? Returns<z.output<ReturnsValidator>> : [ReturnsValidator] extends [ZodValidator] ? Returns<z.output<z.ZodObject<ReturnsValidator>>> : any;
-type ArgsInput<ArgsValidator extends ZodValidator | z.ZodObject<any> | void> = [
-    ArgsValidator
-] extends [z.ZodObject<any>] ? [z.input<ArgsValidator>] : [ArgsValidator] extends [ZodValidator] ? [z.input<z.ZodObject<ArgsValidator>>] : OneArgArray;
-type ArgsOutput<ArgsValidator extends ZodValidator | z.ZodObject<any> | void> = [
-    ArgsValidator
-] extends [z.ZodObject<any>] ? [z.output<ArgsValidator>] : [ArgsValidator] extends [ZodValidator] ? [z.output<z.ZodObject<ArgsValidator>>] : OneArgArray;
-type Overwrite<T, U> = Omit<T, keyof U> & U;
-type Expand<ObjectType extends Record<any, any>> = ObjectType extends Record<any, any> ? {
-    [Key in keyof ObjectType]: ObjectType[Key];
-} : never;
-type ArgsForHandlerType<OneOrZeroArgs extends [] | [Record<string, any>], CustomMadeArgs extends Record<string, any>> = CustomMadeArgs extends Record<string, never> ? OneOrZeroArgs : OneOrZeroArgs extends [infer A] ? [Expand<A & CustomMadeArgs>] : [CustomMadeArgs];
-type Registration<FuncType extends 'query' | 'mutation' | 'action', Visibility extends FunctionVisibility, Args extends DefaultFunctionArgs, Output> = FuncType extends 'query' ? convex_server.RegisteredQuery<Visibility, Args, Output> : FuncType extends 'mutation' ? convex_server.RegisteredMutation<Visibility, Args, Output> : convex_server.RegisteredAction<Visibility, Args, Output>;
-/**
- * A builder that customizes a Convex function, whether or not it validates
- * arguments. If the customization requires arguments, however, the resulting
- * builder will require argument validation too.
- *
- * This is our own Zod-aware CustomBuilder type that properly handles Zod validators.
- */
-type CustomBuilder<FuncType extends 'query' | 'mutation' | 'action', CustomArgsValidator extends PropertyValidators, CustomCtx extends Record<string, any>, CustomMadeArgs extends Record<string, any>, InputCtx, Visibility extends FunctionVisibility, ExtraArgs extends Record<string, any>> = {
-    <ArgsValidator extends ZodValidator | z.ZodObject<any> | void, ReturnsZodValidator extends z.ZodTypeAny | ZodValidator | void = void, ReturnValue extends ReturnValueInput<ReturnsZodValidator> = any>(func: ({
-        /**
-         * Specify the arguments to the function as a Zod validator.
-         */
-        args?: ArgsValidator;
-        handler: (ctx: Overwrite<InputCtx, CustomCtx>, ...args: ArgsForHandlerType<ArgsOutput<ArgsValidator>, CustomMadeArgs>) => ReturnValue;
-        /**
-         * Validates the value returned by the function.
-         * Note: you can't pass an object directly without wrapping it
-         * in `z.object()`.
-         */
-        returns?: ReturnsZodValidator;
-        /**
-         * If true, the function will not be validated by Convex,
-         * in case you're seeing performance issues with validating twice.
-         */
-        skipConvexValidation?: boolean;
-    } & {
-        [key in keyof ExtraArgs as key extends 'args' | 'handler' | 'skipConvexValidation' | 'returns' ? never : key]: ExtraArgs[key];
-    }) | {
-        (ctx: Overwrite<InputCtx, CustomCtx>, ...args: ArgsForHandlerType<ArgsOutput<ArgsValidator>, CustomMadeArgs>): ReturnValue;
-    }): Registration<FuncType, Visibility, ArgsArrayToObject<CustomArgsValidator extends Record<string, never> ? ArgsInput<ArgsValidator> : ArgsInput<ArgsValidator> extends [infer A] ? [Expand<A & convex_values.ObjectType<CustomArgsValidator>>] : [convex_values.ObjectType<CustomArgsValidator>]>, ReturnsZodValidator extends void ? ReturnValue : ReturnValueOutput<ReturnsZodValidator>>;
-};
-declare function customFnBuilder<Ctx extends Record<string, any>, Builder extends (fn: any) => any, CustomArgsValidator extends PropertyValidators, CustomCtx extends Record<string, any>, CustomMadeArgs extends Record<string, any>, ExtraArgs extends Record<string, any> = Record<string, any>>(builder: Builder, customization: Customization<Ctx, CustomArgsValidator, CustomCtx, CustomMadeArgs, ExtraArgs>): (fn: any) => any;
-declare function zCustomQuery<CustomArgsValidator extends PropertyValidators, CustomCtx extends Record<string, any>, CustomMadeArgs extends Record<string, any>, Visibility extends FunctionVisibility, DataModel extends GenericDataModel, ExtraArgs extends Record<string, any> = Record<string, any>>(query: QueryBuilder<DataModel, Visibility>, customization: Customization<any, CustomArgsValidator, CustomCtx, CustomMadeArgs, ExtraArgs>): CustomBuilder<'query', CustomArgsValidator, CustomCtx, CustomMadeArgs, GenericQueryCtx<DataModel>, Visibility, ExtraArgs>;
-declare function zCustomQuery<CustomArgsValidator extends PropertyValidators, CustomCtx extends Record<string, any>, CustomMadeArgs extends Record<string, any>, Visibility extends FunctionVisibility, ExtraArgs extends Record<string, any> = Record<string, any>>(query: QueryBuilder<any, Visibility>, customization: Customization<any, CustomArgsValidator, CustomCtx, CustomMadeArgs, ExtraArgs>): CustomBuilder<'query', CustomArgsValidator, CustomCtx, CustomMadeArgs, any, Visibility, ExtraArgs>;
-declare function zCustomMutation<CustomArgsValidator extends PropertyValidators, CustomCtx extends Record<string, any>, CustomMadeArgs extends Record<string, any>, Builder extends (fn: any) => any, Visibility extends FunctionVisibility = 'public', ExtraArgs extends Record<string, any> = Record<string, any>>(mutation: Builder, customization: Customization<any, CustomArgsValidator, CustomCtx, CustomMadeArgs, ExtraArgs>): CustomBuilder<'mutation', CustomArgsValidator, CustomCtx, CustomMadeArgs, ExtractCtx<Builder>, Visibility, ExtraArgs>;
-declare function zCustomAction<CustomArgsValidator extends PropertyValidators, CustomCtx extends Record<string, any>, CustomMadeArgs extends Record<string, any>, Builder extends (fn: any) => any, Visibility extends FunctionVisibility = 'public', ExtraArgs extends Record<string, any> = Record<string, any>>(action: Builder, customization: Customization<any, CustomArgsValidator, CustomCtx, CustomMadeArgs, ExtraArgs>): CustomBuilder<'action', CustomArgsValidator, CustomCtx, CustomMadeArgs, ExtractCtx<Builder>, Visibility, ExtraArgs>;
-
-/**
- * Creates a reusable query builder from a Convex query builder.
- * Returns a builder function that accepts Convex-style config objects with args, handler, and returns.
- *
- * @example
- * ```ts
- * import { query } from './_generated/server'
- * import { zQueryBuilder } from 'zodvex'
- *
- * // Create a reusable builder
- * export const zq = zQueryBuilder(query)
- *
- * // Use it with Convex-style object syntax
- * export const getUser = zq({
- *   args: { id: z.string() },
- *   handler: async (ctx, { id }) => {
- *     return ctx.db.get(id)
- *   }
- * })
- * ```
- */
-declare function zQueryBuilder<Builder extends (fn: any) => any>(builder: Builder): <A extends z.ZodTypeAny | Record<string, z.ZodTypeAny>, R extends z.ZodTypeAny | undefined = undefined, Visibility extends FunctionVisibility = ExtractVisibility<Builder>>(config: {
-    args?: A;
-    handler: (ctx: ExtractCtx<Builder>, args: ZodToConvexArgs<A extends undefined ? Record<string, never> : A>) => InferHandlerReturns<R> | Promise<InferHandlerReturns<R>>;
-    returns?: R;
-}) => RegisteredQuery<Visibility, ZodToConvexArgs<A extends undefined ? Record<string, never> : A>, Promise<InferReturns<R>>>;
-/**
- * Creates a reusable mutation builder from a Convex mutation builder.
- * Returns a builder function that accepts Convex-style config objects with args, handler, and returns.
- *
- * @example
- * ```ts
- * import { mutation } from './_generated/server'
- * import { zMutationBuilder } from 'zodvex'
- *
- * // Create a reusable builder
- * export const zm = zMutationBuilder(mutation)
- *
- * // Use it with Convex-style object syntax
- * export const updateUser = zm({
- *   args: { id: z.string(), name: z.string() },
- *   handler: async (ctx, { id, name }) => {
- *     return ctx.db.patch(id, { name })
- *   }
- * })
- * ```
- */
-declare function zMutationBuilder<Builder extends (fn: any) => any>(builder: Builder): <A extends z.ZodTypeAny | Record<string, z.ZodTypeAny>, R extends z.ZodTypeAny | undefined = undefined, Visibility extends FunctionVisibility = ExtractVisibility<Builder>>(config: {
-    args?: A;
-    handler: (ctx: ExtractCtx<Builder>, args: ZodToConvexArgs<A extends undefined ? Record<string, never> : A>) => InferHandlerReturns<R> | Promise<InferHandlerReturns<R>>;
-    returns?: R;
-}) => RegisteredMutation<Visibility, ZodToConvexArgs<A extends undefined ? Record<string, never> : A>, Promise<InferReturns<R>>>;
-/**
- * Creates a reusable action builder from a Convex action builder.
- * Returns a builder function that accepts Convex-style config objects with args, handler, and returns.
- *
- * @example
- * ```ts
- * import { action } from './_generated/server'
- * import { zActionBuilder } from 'zodvex'
- *
- * // Create a reusable builder
- * export const za = zActionBuilder(action)
- *
- * // Use it with Convex-style object syntax
- * export const sendEmail = za({
- *   args: { to: z.string().email(), subject: z.string() },
- *   handler: async (ctx, { to, subject }) => {
- *     // Send email
- *   }
- * })
- * ```
- */
-declare function zActionBuilder<Builder extends (fn: any) => any>(builder: Builder): <A extends z.ZodTypeAny | Record<string, z.ZodTypeAny>, R extends z.ZodTypeAny | undefined = undefined, Visibility extends FunctionVisibility = ExtractVisibility<Builder>>(config: {
-    args?: A;
-    handler: (ctx: ExtractCtx<Builder>, args: ZodToConvexArgs<A extends undefined ? Record<string, never> : A>) => InferHandlerReturns<R> | Promise<InferHandlerReturns<R>>;
-    returns?: R;
-}) => RegisteredAction<Visibility, ZodToConvexArgs<A extends undefined ? Record<string, never> : A>, Promise<InferReturns<R>>>;
-/**
- * Creates a custom query builder with context injection from a Convex query builder.
- * Allows you to add custom context (like auth, permissions, etc.) to your queries.
- *
- * @example
- * ```ts
- * import { type QueryCtx, query } from './_generated/server'
- * import { zCustomQueryBuilder, customCtx } from 'zodvex'
- *
- * // Create a builder with auth context
- * export const authQuery = zCustomQueryBuilder(
- *   query,
- *   customCtx(async (ctx: QueryCtx) => {
- *     const user = await getUserOrThrow(ctx)
- *     return { user }
- *   })
- * )
- *
- * // Use it with automatic user injection
- * export const getMyProfile = authQuery({
- *   args: {},
- *   handler: async (ctx) => {
- *     // ctx.user is automatically available
- *     return ctx.db.get(ctx.user._id)
- *   }
- * })
- * ```
- */
-declare function zCustomQueryBuilder<Builder extends (fn: any) => any, CustomArgsValidator extends PropertyValidators, CustomCtx extends Record<string, any>, CustomMadeArgs extends Record<string, any>, Visibility extends FunctionVisibility = ExtractVisibility<Builder>, ExtraArgs extends Record<string, any> = Record<string, any>>(query: Builder, customization: Customization<any, CustomArgsValidator, CustomCtx, CustomMadeArgs, ExtraArgs>): CustomBuilder<'query', CustomArgsValidator, CustomCtx, CustomMadeArgs, ExtractCtx<Builder>, Visibility, ExtraArgs>;
-/**
- * Creates a custom mutation builder with context injection from a Convex mutation builder.
- * Allows you to add custom context (like auth, permissions, etc.) to your mutations.
- *
- * @example
- * ```ts
- * import { type MutationCtx, mutation } from './_generated/server'
- * import { zCustomMutationBuilder, customCtx } from 'zodvex'
- *
- * // Create a builder with auth context
- * export const authMutation = zCustomMutationBuilder(
- *   mutation,
- *   customCtx(async (ctx: MutationCtx) => {
- *     const user = await getUserOrThrow(ctx)
- *     return { user }
- *   })
- * )
- *
- * // Use it with automatic user injection
- * export const updateProfile = authMutation({
- *   args: { name: z.string() },
- *   handler: async (ctx, { name }) => {
- *     // ctx.user is automatically available
- *     await ctx.db.patch(ctx.user._id, { name })
- *   }
- * })
- * ```
- */
-declare function zCustomMutationBuilder<Builder extends (fn: any) => any, CustomArgsValidator extends PropertyValidators, CustomCtx extends Record<string, any>, CustomMadeArgs extends Record<string, any>, Visibility extends FunctionVisibility = ExtractVisibility<Builder>, ExtraArgs extends Record<string, any> = Record<string, any>>(mutation: Builder, customization: Customization<any, CustomArgsValidator, CustomCtx, CustomMadeArgs, ExtraArgs>): CustomBuilder<'mutation', CustomArgsValidator, CustomCtx, CustomMadeArgs, ExtractCtx<Builder>, Visibility, ExtraArgs>;
-/**
- * Creates a custom action builder with context injection from a Convex action builder.
- * Allows you to add custom context (like auth, permissions, etc.) to your actions.
- *
- * @example
- * ```ts
- * import { type ActionCtx, action } from './_generated/server'
- * import { zCustomActionBuilder, customCtx } from 'zodvex'
- *
- * // Create a builder with auth context
- * export const authAction = zCustomActionBuilder(
- *   action,
- *   customCtx(async (ctx: ActionCtx) => {
- *     const identity = await ctx.auth.getUserIdentity()
- *     if (!identity) throw new Error('Unauthorized')
- *     return { userId: identity.subject }
- *   })
- * )
- *
- * // Use it with automatic auth injection
- * export const sendEmail = authAction({
- *   args: { to: z.string().email() },
- *   handler: async (ctx, { to }) => {
- *     // ctx.userId is automatically available
- *     await sendEmailService(to, ctx.userId)
- *   }
- * })
- * ```
- */
-declare function zCustomActionBuilder<Builder extends (fn: any) => any, CustomArgsValidator extends PropertyValidators, CustomCtx extends Record<string, any>, CustomMadeArgs extends Record<string, any>, Visibility extends FunctionVisibility = ExtractVisibility<Builder>, ExtraArgs extends Record<string, any> = Record<string, any>>(action: Builder, customization: Customization<any, CustomArgsValidator, CustomCtx, CustomMadeArgs, ExtraArgs>): CustomBuilder<'action', CustomArgsValidator, CustomCtx, CustomMadeArgs, ExtractCtx<Builder>, Visibility, ExtraArgs>;
-
-type ConvexCodec<T> = {
-    validator: any;
-    encode: (value: T) => any;
-    decode: (value: any) => T;
-    pick: <K extends keyof T>(keys: K[]) => ConvexCodec<Pick<T, K>>;
-};
-declare function convexCodec<T>(schema: z.ZodType<T>): ConvexCodec<T>;
-declare function toConvexJS(schema?: any, value?: any): any;
-declare function fromConvexJS(value: any, schema: any): any;
-
-type BaseCodec = {
-    check: (schema: any) => boolean;
-    toValidator: (schema: any) => any;
-    fromConvex: (value: any, schema: any) => any;
-    toConvex: (value: any, schema: any) => any;
-};
-declare function registerBaseCodec(codec: BaseCodec): void;
-declare function findBaseCodec(schema: any): BaseCodec | undefined;
-declare function isDateSchema(schema: any): boolean;
-/**
- * Checks if a schema is a zid (Convex ID) schema by looking at its description.
- * zid schemas are marked with "convexId:{tableName}" in their description.
- */
-declare function isZidSchema(schema: z.ZodTypeAny): boolean;
-/**
- * Extracts the table name from a zid schema's description.
- * Returns undefined if not a zid schema.
- */
-declare function getZidTableName(schema: z.ZodTypeAny): string | undefined;
-/**
- * Context object passed to the JSON Schema override function.
- * Uses 'any' types for compatibility with Zod's internal types.
- */
-interface JSONSchemaOverrideContext {
-    zodSchema: any;
-    jsonSchema: any;
-}
-/**
- * Override function for z.toJSONSchema that handles zodvex-managed types.
- *
- * Handles:
- * - zid schemas: Converts to { type: "string" } with convexId format
- * - z.date(): Converts to { type: "string", format: "date-time" }
- *
- * @example
- * ```ts
- * import { z } from 'zod'
- * import { zid, zodvexJSONSchemaOverride } from 'zodvex'
- *
- * const schema = z.object({
- *   userId: zid('users'),
- *   name: z.string()
- * })
- *
- * const jsonSchema = z.toJSONSchema(schema, {
- *   unrepresentable: 'any',
- *   override: zodvexJSONSchemaOverride
- * })
- * // => { type: "object", properties: { userId: { type: "string" }, name: { type: "string" } } }
- * ```
- */
-declare function zodvexJSONSchemaOverride(ctx: JSONSchemaOverrideContext): void;
-/**
- * Composes multiple JSON Schema override functions into one.
- * Overrides run in order - first override runs first.
- *
- * @example
- * ```ts
- * import { composeOverrides, zodvexJSONSchemaOverride } from 'zodvex'
- *
- * const myOverride = (ctx) => {
- *   if (ctx.zodSchema.description?.startsWith('myType:')) {
- *     ctx.jsonSchema.type = 'string'
- *     ctx.jsonSchema.format = 'my-format'
- *   }
- * }
- *
- * // User's override runs first, then zodvex's
- * z.toJSONSchema(schema, {
- *   unrepresentable: 'any',
- *   override: composeOverrides(myOverride, zodvexJSONSchemaOverride)
- * })
- * ```
- */
-declare function composeOverrides(...overrides: Array<((ctx: JSONSchemaOverrideContext) => void) | undefined>): (ctx: JSONSchemaOverrideContext) => void;
-/**
- * Options for toJSONSchema, matching Zod's interface.
- */
-interface ToJSONSchemaOptions {
-    target?: 'draft-4' | 'draft-7' | 'draft-2020-12' | 'openapi-3.0';
-    unrepresentable?: 'throw' | 'any';
-    cycles?: 'ref' | 'throw';
-    reused?: 'ref' | 'inline';
-    io?: 'input' | 'output';
-    override?: (ctx: JSONSchemaOverrideContext) => void;
-}
-/**
- * Converts a Zod schema to JSON Schema with zodvex-aware overrides.
- *
- * This is a convenience wrapper around z.toJSONSchema that automatically
- * handles zodvex-managed types like zid and dates.
- *
- * @example
- * ```ts
- * import { zid, toJSONSchema } from 'zodvex'
- *
- * const schema = z.object({
- *   userId: zid('users'),
- *   createdAt: z.date(),
- *   name: z.string()
- * })
- *
- * const jsonSchema = toJSONSchema(schema)
- * // Works with AI SDK's generateObject, etc.
- * ```
- */
-declare function toJSONSchema<T extends z.ZodTypeAny>(schema: T, options?: ToJSONSchemaOptions): Record<string, any>;
-
-/**
- * Helper type for Convex system fields added to documents
- */
-type SystemFields<TableName extends string> = {
-    _id: ReturnType<typeof zid<TableName>>;
-    _creationTime: z.ZodNumber;
-};
-/**
- * Maps over union options, extending each ZodObject variant with system fields.
- * Non-object variants are preserved as-is.
- */
-type MapSystemFields<TableName extends string, Options extends readonly z.ZodTypeAny[]> = {
-    [K in keyof Options]: Options[K] extends z.ZodObject<infer Shape extends z.ZodRawShape> ? z.ZodObject<Shape & SystemFields<TableName>> : Options[K];
-};
-/**
- * Adds Convex system fields (_id, _creationTime) to a Zod schema.
- *
- * For object schemas: extends with system fields
- * For union schemas: adds system fields to each variant
- *
- * @param tableName - The Convex table name
- * @param schema - The Zod schema (object or union)
- * @returns Schema with system fields added
- */
-declare function addSystemFields<TableName extends string, Shape extends z.ZodRawShape>(tableName: TableName, schema: z.ZodObject<Shape>): z.ZodObject<Shape & SystemFields<TableName>>;
-declare function addSystemFields<TableName extends string, Options extends readonly z.ZodTypeAny[]>(tableName: TableName, schema: z.ZodUnion<Options>): z.ZodUnion<MapSystemFields<TableName, Options>>;
-declare function addSystemFields<TableName extends string, Options extends readonly z.ZodObject<z.ZodRawShape>[], Discriminator extends string>(tableName: TableName, schema: z.ZodDiscriminatedUnion<Options, Discriminator>): z.ZodDiscriminatedUnion<MapSystemFields<TableName, Options>, Discriminator>;
-declare function addSystemFields<TableName extends string, S extends z.ZodTypeAny>(tableName: TableName, schema: S): S;
-declare function zodDoc<TableName extends string, Shape extends z.ZodRawShape, Schema extends z.ZodObject<Shape>>(tableName: TableName, schema: Schema): z.ZodObject<Shape & {
-    _id: ReturnType<typeof zid<TableName>>;
-    _creationTime: z.ZodNumber;
-}>;
-declare function zodDocOrNull<TableName extends string, Shape extends z.ZodRawShape, Schema extends z.ZodObject<Shape>>(tableName: TableName, schema: Schema): z.ZodUnion<readonly [z.ZodObject<Readonly<{
-    [k: string]: z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
-}> & {
-    _id: z.ZodType<GenericId<TableName>, unknown, z.core.$ZodTypeInternals<GenericId<TableName>, unknown>> & {
-        _tableName: TableName;
-    };
-    _creationTime: z.ZodNumber;
-}, z.core.$strip>, z.ZodNull]>;
-/**
- * Defines a Convex table using either:
- * - A raw Zod shape (an object mapping field names to Zod types)
- * - A Zod union schema (for polymorphic tables)
- *
- * For object shapes, this function intentionally accepts a raw shape instead of a ZodObject instance.
- * Accepting raw shapes allows TypeScript to infer field types more accurately and efficiently,
- * leading to better type inference and performance throughout the codebase.
- *
- * For union schemas, this enables polymorphic tables with discriminated unions.
- *
- * Returns the Table definition along with Zod schemas for documents and arrays.
- *
- * @param name - The table name
- * @param schemaOrShape - Either a raw object shape or a Zod union schema
- * @returns A Table with attached helpers (shape, schema, zDoc, docArray, withSystemFields)
- *
- * @example Object shape
- * ```ts
- * const Users = zodTable('users', {
- *   name: z.string(),
- *   email: z.string().email(),
- *   age: z.number().optional()
- * })
- *
- * // Use in schema
- * export default defineSchema({ users: Users.table })
- *
- * // Use for return types
- * export const getUsers = zQuery(query, {},
- *   async (ctx) => ctx.db.query('users').collect(),
- *   { returns: Users.docArray }
- * )
- * ```
- *
- * @example Union schema (polymorphic table)
- * ```ts
- * const shapeSchema = z.union([
- *   z.object({ kind: z.literal('circle'), r: z.number() }),
- *   z.object({ kind: z.literal('rectangle'), width: z.number() })
- * ])
- *
- * const Shapes = zodTable('shapes', shapeSchema)
- *
- * // Use in schema
- * export default defineSchema({ shapes: Shapes.table })
- *
- * // Use for return types with system fields
- * export const getShapes = zQuery(query, {},
- *   async (ctx) => ctx.db.query('shapes').collect(),
- *   { returns: Shapes.docArray }
- * )
- * ```
- */
-type AddSystemFieldsResult<TableName extends string, Schema extends z.ZodTypeAny> = Schema extends z.ZodObject<infer Shape extends z.ZodRawShape> ? z.ZodObject<Shape & SystemFields<TableName>> : Schema extends z.ZodUnion<infer Options extends readonly z.ZodTypeAny[]> ? z.ZodUnion<MapSystemFields<TableName, Options>> : Schema extends z.ZodDiscriminatedUnion<infer Options extends readonly z.ZodObject<z.ZodRawShape>[], infer Disc extends string> ? z.ZodDiscriminatedUnion<MapSystemFields<TableName, Options>, Disc> : Schema;
-declare function zodTable<TableName extends string, Shape extends Record<string, z.ZodTypeAny>>(name: TableName, shape: Shape): ReturnType<typeof Table<ConvexValidatorFromZodFieldsAuto<Shape>, TableName>> & {
-    shape: Shape;
-    zDoc: z.ZodObject<Shape & {
-        _id: ReturnType<typeof zid<TableName>>;
-        _creationTime: z.ZodNumber;
-    }>;
-    docArray: z.ZodArray<z.ZodObject<Shape & {
-        _id: ReturnType<typeof zid<TableName>>;
-        _creationTime: z.ZodNumber;
-    }>>;
-};
-declare function zodTable<TableName extends string, Schema extends z.ZodTypeAny>(name: TableName, schema: Schema): {
-    table: ReturnType<typeof defineTable>;
-    tableName: TableName;
-    validator: ReturnType<typeof zodToConvex<Schema>>;
-    schema: Schema;
-    docArray: z.ZodArray<AddSystemFieldsResult<TableName, Schema>>;
-    withSystemFields: () => AddSystemFieldsResult<TableName, Schema>;
-};
-
-declare function pick<T extends Record<string, any>, K extends keyof T>(obj: T, keys: K[]): Pick<T, K>;
-declare function returnsAs<R extends z.ZodTypeAny>(): <T extends z.input<R>>(v: T) => T;
-declare function formatZodIssues(error: z.ZodError, context?: 'args' | 'returns' | 'input' | 'output' | 'codec'): {
-    error: string;
-    context: "output" | "input" | "args" | "returns" | "codec" | undefined;
-    issues: {
-        path: string;
-        code: "custom" | "invalid_type" | "unrecognized_keys" | "invalid_union" | "invalid_value" | "invalid_key" | "too_big" | "too_small" | "invalid_format" | "not_multiple_of" | "invalid_element";
-        message: string;
-    }[];
-    flatten: any;
-};
-declare function handleZodValidationError(e: unknown, context: 'args' | 'returns' | 'input' | 'output' | 'codec'): never;
-declare function zPaginated<T extends z.ZodTypeAny>(item: T): z.ZodObject<{
-    page: z.ZodArray<T>;
-    isDone: z.ZodBoolean;
-    continueCursor: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-}, z.core.$strip>;
-/**
- * Maps Date fields to number fields for docSchema generation.
- * Handles Date, Date.optional(), Date.nullable(), and Date.default() cases.
- * Returns the original field for non-Date types.
- */
-declare function mapDateFieldToNumber(field: z.ZodTypeAny): z.ZodTypeAny;
-type Mask = readonly string[] | Record<string, boolean | 1 | true>;
-/**
- * Returns a plain shape object containing only the selected fields.
- * Accepts either a ZodObject or a raw shape object.
- */
-declare function pickShape(schemaOrShape: z.ZodObject<any> | Record<string, any>, mask: Mask): Record<string, any>;
-declare function safePick(schema: z.ZodObject<any>, mask: Mask): z.ZodObject<any>;
-/**
- * Convenience: omit a set of keys by building the complement.
- * Avoids using Zod's .omit() which can cause type depth issues.
- */
-declare function safeOmit(schema: z.ZodObject<any>, mask: Mask): z.ZodObject<any>;
-
-export { type ConvexCodec, type ConvexValidatorFromZod, type ConvexValidatorFromZodFieldsAuto, type CustomBuilder, type ExtractCtx, type ExtractVisibility, type InferArgs, type InferHandlerReturns, type InferReturns, type JSONSchemaOverrideContext, type PreserveReturnType, type ToJSONSchemaOptions, type Zid, type ZodToConvexArgs, type ZodValidator, 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 };
+export * from './builders';
+export * from './codec';
+export * from './custom';
+export * from './ids';
+export * from './mapping';
+export * from './registry';
+export * from './results';
+export * from './tables';
+export * from './types';
+export * from './utils';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,SAAS,EAAE,MAAM,uCAAuC,CAAA;AACjE,cAAc,YAAY,CAAA;AAC1B,cAAc,SAAS,CAAA;AACvB,cAAc,UAAU,CAAA;AACxB,cAAc,OAAO,CAAA;AACrB,cAAc,WAAW,CAAA;AACzB,cAAc,YAAY,CAAA;AAC1B,cAAc,WAAW,CAAA;AACzB,cAAc,UAAU,CAAA;AACxB,cAAc,SAAS,CAAA;AACvB,cAAc,SAAS,CAAA"}