zodvex 0.1.0

package/src/wrappers.ts

@@ -0,0 +1,184 @@
+import { z } from 'zod'
+import { toConvexJS } from './codec'
+import { getObjectShape, zodToConvex, zodToConvexFields } from './mapping'
+import {
+  type ExtractCtx,
+  type InferArgs,
+  type InferReturns,
+  type PreserveReturnType,
+  type ZodToConvexArgs
+} from './types'
+
+export function zQuery<
+  Builder extends (fn: any) => any,
+  A extends z.ZodTypeAny | Record<string, z.ZodTypeAny>,
+  R extends z.ZodTypeAny | undefined = undefined
+>(
+  query: Builder,
+  input: A,
+  handler: (
+    ctx: ExtractCtx<Builder>,
+    args: InferArgs<A>
+  ) => Promise<InferReturns<R>> | InferReturns<R>,
+  options?: { returns?: R }
+): PreserveReturnType<Builder, ZodToConvexArgs<A>, InferReturns<R>> {
+  let zodSchema: z.ZodTypeAny
+  let args: Record<string, any>
+  if (input instanceof z.ZodObject) {
+    zodSchema = input
+    args = zodToConvexFields(getObjectShape(input))
+  } else if (input instanceof z.ZodType) {
+    zodSchema = z.object({ value: input as z.ZodTypeAny })
+    args = { value: zodToConvex(input as z.ZodTypeAny) }
+  } else {
+    zodSchema = z.object(input as Record<string, z.ZodTypeAny>)
+    args = zodToConvexFields(input as Record<string, z.ZodTypeAny>)
+  }
+  const returns = options?.returns ? zodToConvex(options.returns) : undefined
+
+  return query({
+    args,
+    returns,
+    handler: async (ctx: ExtractCtx<Builder>, argsObject: unknown) => {
+      const parsed = zodSchema.parse(argsObject) as InferArgs<A>
+      const raw = await handler(ctx, parsed)
+      if (options?.returns) {
+        const validated = (options.returns as z.ZodTypeAny).parse(raw)
+        return toConvexJS(options.returns as z.ZodTypeAny, validated)
+      }
+      return raw as any
+    }
+  }) as PreserveReturnType<Builder, ZodToConvexArgs<A>, InferReturns<R>>
+}
+
+export function zInternalQuery<
+  Builder extends (fn: any) => any,
+  A extends z.ZodTypeAny | Record<string, z.ZodTypeAny>,
+  R extends z.ZodTypeAny | undefined = undefined
+>(
+  internalQuery: Builder,
+  input: A,
+  handler: (
+    ctx: ExtractCtx<Builder>,
+    args: InferArgs<A>
+  ) => Promise<InferReturns<R>> | InferReturns<R>,
+  options?: { returns?: R }
+): PreserveReturnType<Builder, ZodToConvexArgs<A>, InferReturns<R>> {
+  return zQuery(internalQuery, input, handler, options)
+}
+
+export function zMutation<
+  Builder extends (fn: any) => any,
+  A extends z.ZodTypeAny | Record<string, z.ZodTypeAny>,
+  R extends z.ZodTypeAny | undefined = undefined
+>(
+  mutation: Builder,
+  input: A,
+  handler: (
+    ctx: ExtractCtx<Builder>,
+    args: InferArgs<A>
+  ) => Promise<InferReturns<R>> | InferReturns<R>,
+  options?: { returns?: R }
+): PreserveReturnType<Builder, ZodToConvexArgs<A>, InferReturns<R>> {
+  let zodSchema: z.ZodTypeAny
+  let args: Record<string, any>
+  if (input instanceof z.ZodObject) {
+    zodSchema = input
+    args = zodToConvexFields(getObjectShape(input))
+  } else if (input instanceof z.ZodType) {
+    zodSchema = z.object({ value: input as z.ZodTypeAny })
+    args = { value: zodToConvex(input as z.ZodTypeAny) }
+  } else {
+    zodSchema = z.object(input as Record<string, z.ZodTypeAny>)
+    args = zodToConvexFields(input as Record<string, z.ZodTypeAny>)
+  }
+  const returns = options?.returns ? zodToConvex(options.returns) : undefined
+
+  return mutation({
+    args,
+    returns,
+    handler: async (ctx: ExtractCtx<Builder>, argsObject: unknown) => {
+      const parsed = zodSchema.parse(argsObject) as InferArgs<A>
+      const raw = await handler(ctx, parsed)
+      if (options?.returns) {
+        const validated = (options.returns as z.ZodTypeAny).parse(raw)
+        return toConvexJS(options.returns as z.ZodTypeAny, validated)
+      }
+      return raw as any
+    }
+  }) as PreserveReturnType<Builder, ZodToConvexArgs<A>, InferReturns<R>>
+}
+
+export function zInternalMutation<
+  Builder extends (fn: any) => any,
+  A extends z.ZodTypeAny | Record<string, z.ZodTypeAny>,
+  R extends z.ZodTypeAny | undefined = undefined
+>(
+  internalMutation: Builder,
+  input: A,
+  handler: (
+    ctx: ExtractCtx<Builder>,
+    args: InferArgs<A>
+  ) => Promise<InferReturns<R>> | InferReturns<R>,
+  options?: { returns?: R }
+): PreserveReturnType<Builder, ZodToConvexArgs<A>, InferReturns<R>> {
+  return zMutation(internalMutation, input, handler, options)
+}
+
+export function zAction<
+  Builder extends (fn: any) => any,
+  A extends z.ZodTypeAny | Record<string, z.ZodTypeAny>,
+  R extends z.ZodTypeAny | undefined = undefined
+>(
+  action: Builder,
+  input: A,
+  handler: (
+    ctx: ExtractCtx<Builder>,
+    args: InferArgs<A>
+  ) => Promise<InferReturns<R>> | InferReturns<R>,
+  options?: { returns?: R }
+): PreserveReturnType<Builder, ZodToConvexArgs<A>, InferReturns<R>> {
+  let zodSchema: z.ZodTypeAny
+  let args: Record<string, any>
+  if (input instanceof z.ZodObject) {
+    zodSchema = input
+    args = zodToConvexFields(getObjectShape(input))
+  } else if (input instanceof z.ZodType) {
+    zodSchema = z.object({ value: input as z.ZodTypeAny })
+    args = { value: zodToConvex(input as z.ZodTypeAny) }
+  } else {
+    zodSchema = z.object(input as Record<string, z.ZodTypeAny>)
+    args = zodToConvexFields(input as Record<string, z.ZodTypeAny>)
+  }
+  const returns = options?.returns ? zodToConvex(options.returns) : undefined
+
+  return action({
+    args,
+    returns,
+    handler: async (ctx: ExtractCtx<Builder>, argsObject: unknown) => {
+      const parsed = zodSchema.parse(argsObject) as InferArgs<A>
+      const raw = await handler(ctx, parsed)
+      if (options?.returns) {
+        const validated = (options.returns as z.ZodTypeAny).parse(raw)
+        return toConvexJS(options.returns as z.ZodTypeAny, validated)
+      }
+      return raw as any
+    }
+  }) as PreserveReturnType<Builder, ZodToConvexArgs<A>, InferReturns<R>>
+}
+
+export function zInternalAction<
+  Builder extends (fn: any) => any,
+  A extends z.ZodTypeAny | Record<string, z.ZodTypeAny>,
+  R extends z.ZodTypeAny | undefined = undefined
+>(
+  internalAction: Builder,
+  input: A,
+  handler: (
+    ctx: ExtractCtx<Builder>,
+    args: InferArgs<A>
+  ) => Promise<InferReturns<R>> | InferReturns<R>,
+  options?: { returns?: R }
+): PreserveReturnType<Builder, ZodToConvexArgs<A>, InferReturns<R>> {
+  return zAction(internalAction, input, handler, options)
+}

package/src/zodV4Compat.ts

@@ -0,0 +1,36 @@
+/**
+ * Minimal compatibility for convex-helpers/server/zodV4 imports
+ * This library itself IS the Zod v4 compatibility layer
+ */
+
+import type { GenericId } from 'convex/values'
+import { z } from 'zod'
+
+// Simple registry for metadata
+const metadata = new WeakMap<z.ZodTypeAny, any>()
+
+export const registryHelpers = {
+  getMetadata: (type: z.ZodTypeAny) => metadata.get(type),
+  setMetadata: (type: z.ZodTypeAny, meta: any) => metadata.set(type, meta)
+}
+
+/**
+ * Create a Zod validator for a Convex Id
+ */
+export function zid<TableName extends string>(tableName: TableName): z.ZodTypeAny {
+  const schema = z
+    .string()
+    .refine((val): val is GenericId<TableName> => typeof val === 'string' && val.length > 0, {
+      message: `Invalid ID for table "${tableName}"`
+    })
+
+  // Store metadata for registry lookup
+  registryHelpers.setMetadata(schema, {
+    isConvexId: true,
+    tableName
+  })
+
+  return schema as z.ZodTypeAny
+}
+
+export type Zid<TableName extends string> = ReturnType<typeof zid<TableName>>