@getvision/adapter-express 0.0.0-develop-20251031183955

package/src/zod-utils.ts

@@ -0,0 +1,170 @@
+import type { ZodType, ZodObject, ZodTypeAny } from 'zod'
+import type { RequestBodySchema, SchemaField } from '@getvision/core'
+
+/**
+ * Generate JSON template with comments from Zod schema
+ */
+export function generateZodTemplate(schema: ZodType): RequestBodySchema | undefined {
+  try {
+    const fields = extractZodFields(schema)
+    const template = generateJsonTemplate(fields)
+    
+    return {
+      template,
+      fields,
+    }
+  } catch (error) {
+    console.warn('Failed to generate template from Zod schema:', error)
+    return undefined
+  }
+}
+
+/**
+ * Extract fields from Zod schema (supports v3 and v4)
+ */
+function extractZodFields(schema: ZodTypeAny, path: string[] = []): SchemaField[] {
+  const fields: SchemaField[] = []
+
+  // Support both v3 (_def) and v4 (def)
+  const def = (schema as any).def || (schema as any)._def
+  if (!def) return fields
+
+  // Unwrap ZodOptional, ZodNullable, ZodDefault - not needed for top level object
+  let unwrapped: any = schema
+
+  const currentDef = (unwrapped as any).def || (unwrapped as any)._def
+  const typeName = currentDef?.type || currentDef?.typeName
+
+  if (typeName === 'object' || typeName === 'ZodObject') {
+    // Get shape - it can be a function (getter) or direct object
+    const shapeValue = currentDef?.shape
+    const shape = typeof shapeValue === 'function' ? shapeValue() : shapeValue
+    
+    for (const [key, value] of Object.entries(shape || {})) {
+      const fieldSchema: any = value
+      const fieldDef = fieldSchema.def || fieldSchema._def
+      const isOptional = fieldSchema.type === 'optional' || 
+                        fieldDef?.type === 'optional' ||
+                        fieldDef?.typeName === 'ZodOptional' || 
+                        fieldDef?.typeName === 'ZodDefault'
+      
+      // Get description - might be in wrapped schema for optional fields
+      let description = fieldDef?.description || fieldSchema.description
+      if (!description && fieldDef?.wrapped) {
+        const wrappedDef = fieldDef.wrapped.def || fieldDef.wrapped._def
+        description = wrappedDef?.description || fieldDef.wrapped.description
+      }
+      
+      // Determine type
+      let fieldType = getZodType(fieldSchema)
+      
+      // Check for nested objects/arrays
+      const nested = extractZodFields(fieldSchema, [...path, key])
+      
+      fields.push({
+        name: key,
+        type: fieldType,
+        description,
+        required: !isOptional,
+        nested: nested.length > 0 ? nested : undefined,
+        example: getZodExample(fieldSchema, fieldType),
+      })
+    }
+  }
+
+  return fields
+}
+
+/**
+ * Get Zod type as string (supports v3 and v4)
+ */
+function getZodType(schema: ZodTypeAny): string {
+  let unwrapped: any = schema
+  let def = (unwrapped as any).def || (unwrapped as any)._def
+  
+  // Unwrap optional/nullable/default
+  while (def?.type === 'optional' || 
+         def?.type === 'nullable' ||
+         def?.type === 'default' ||
+         def?.typeName === 'ZodOptional' || 
+         def?.typeName === 'ZodNullable' ||
+         def?.typeName === 'ZodDefault') {
+    unwrapped = def?.innerType || def?.wrapped || unwrapped
+    def = (unwrapped as any).def || (unwrapped as any)._def
+  }
+
+  // Support both v4 (type) and v3 (typeName)
+  const typeName = def?.type || def?.typeName || (unwrapped as any).type
+  
+  switch (typeName) {
+    case 'string':
+    case 'ZodString': 
+      return 'string'
+    case 'number':
+    case 'ZodNumber': 
+      return 'number'
+    case 'boolean':
+    case 'ZodBoolean': 
+      return 'boolean'
+    case 'array':
+    case 'ZodArray': 
+      return 'array'
+    case 'object':
+    case 'ZodObject': 
+      return 'object'
+    case 'enum':
+    case 'ZodEnum': 
+      return 'enum'
+    case 'date':
+    case 'ZodDate': 
+      return 'date'
+    default: 
+      return 'any'
+  }
+}
+
+/**
+ * Get example value for Zod type
+ */
+function getZodExample(schema: ZodTypeAny, type: string): any {
+  switch (type) {
+    case 'string': return ''
+    case 'number': return 0
+    case 'boolean': return false
+    case 'array': return []
+    case 'object': return {}
+    default: return null
+  }
+}
+
+/**
+ * Generate JSONC template with comments
+ */
+function generateJsonTemplate(fields: SchemaField[], indent = 0): string {
+  const lines: string[] = []
+  const spacing = '  '.repeat(indent)
+  
+  lines.push('{')
+  
+  fields.forEach((field, index) => {
+    const isLast = index === fields.length - 1
+    const description = field.description || field.name
+    
+    // Add comment
+    lines.push(`${spacing}  // ${description}`)
+    
+    // Add field
+    let value: string
+    if (field.nested && field.nested.length > 0) {
+      value = generateJsonTemplate(field.nested, indent + 1)
+    } else {
+      value = JSON.stringify(field.example)
+    }
+    
+    lines.push(`${spacing}  "${field.name}": ${value}${isLast ? '' : ','}`)
+  })
+  
+  lines.push(`${spacing}}`)
+  
+  return lines.join('\n')
+}

package/src/zod-validator.ts

@@ -0,0 +1,118 @@
+import type { Request, Response, NextFunction, RequestHandler } from 'express'
+import type { ZodSchema, ZodError } from 'zod'
+
+// Store schemas for Vision introspection
+const routeSchemas = new Map<string, { method: string; path: string; schema: ZodSchema }>()
+
+/**
+ * Get stored schema for a route
+ */
+export function getRouteSchema(method: string, path: string): ZodSchema | undefined {
+  const key = `${method}:${path}`
+  return routeSchemas.get(key)?.schema
+}
+
+/**
+ * Get all stored schemas
+ */
+export function getAllRouteSchemas(): Map<string, { method: string; path: string; schema: ZodSchema }> {
+  return routeSchemas
+}
+
+type ValidateTarget = 'body' | 'query' | 'params'
+
+/**
+ * Zod validator middleware for Express
+ * Similar to @hono/zod-validator but stores schema for Vision introspection
+ * 
+ * @example
+ * ```ts
+ * import { zValidator } from '@getvision/adapter-express'
+ * import { z } from 'zod'
+ * 
+ * const schema = z.object({
+ *   name: z.string().describe('User name'),
+ *   email: z.string().email().describe('User email'),
+ * })
+ * 
+ * app.post('/users', zValidator('body', schema), (req, res) => {
+ *   // req.body is now typed and validated
+ *   const { name, email } = req.body
+ *   res.json({ name, email })
+ * })
+ * ```
+ */
+export function zValidator<T extends ZodSchema>(
+  target: ValidateTarget,
+  schema: T
+): RequestHandler {
+  const middleware: RequestHandler = (req: Request, res: Response, next: NextFunction) => {
+    // Store schema for Vision (we'll update it later with actual route info)
+    const key = `${req.method}:${req.route?.path || req.path}`
+    if (req.route?.path) {
+      routeSchemas.set(key, {
+        method: req.method,
+        path: req.route.path,
+        schema,
+      })
+    }
+
+    // Get data to validate based on target
+    let data: unknown
+    switch (target) {
+      case 'body':
+        data = req.body
+        break
+      case 'query':
+        data = req.query
+        break
+      case 'params':
+        data = req.params
+        break
+      default:
+        return next(new Error(`Invalid validation target: ${target}`))
+    }
+
+    // Validate data
+    const result = schema.safeParse(data)
+
+    if (!result.success) {
+      // Validation failed
+      const error = result.error as ZodError
+      return res.status(400).json({
+        error: 'Validation failed',
+        issues: error.issues,
+      })
+    }
+
+    // Store validated data back
+    switch (target) {
+      case 'body':
+        req.body = result.data
+        break
+      case 'query':
+        req.query = result.data as any
+        break
+      case 'params':
+        req.params = result.data as any
+        break
+    }
+
+    next()
+  }
+  
+  // Attach schema to middleware for Vision introspection
+  ;(middleware as any).__visionSchema = schema
+  ;(middleware as any).__visionTarget = target
+  
+  return middleware
+}
+
+/**
+ * Extract Zod schema from validator middleware
+ * Used internally by Vision to generate API docs
+ */
+export function extractSchema(middleware: RequestHandler): ZodSchema | undefined {
+  // This is a simplified version - in reality, we store schemas in the Map above
+  return undefined
+}

package/tsconfig.json

@@ -0,0 +1,13 @@
+{
+  "extends": "@repo/typescript-config/base.json",
+  "compilerOptions": {
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "lib": ["ES2022"],
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "bundler"
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}