@getvision/server 0.4.0-6e5c887-develop → 0.4.1-b47357d-develop

package/CHANGELOG.md

@@ -1,5 +1,32 @@
 # @getvision/server
 
+## 0.4.0
+
+### Minor Changes
+
+- 6e5c887: Migrate all adapters to use UniversalValidator supporting Zod, Valibot, and Standard Schema v1. The new validation system provides:
+  - Unified `validator()` function that works with any validation library
+  - Automatic error response formatting with proper issue paths
+  - Schema introspection for template generation
+  - Backward compatibility with existing zValidator (deprecated)
+
+  **Breaking changes:**
+  - `zValidator` is now deprecated in favor of universal `validator()`
+  - Error response format has been standardized across all adapters
+  - Some internal types have changed to support multiple validation libraries
+
+  Migration guide:
+
+  ```ts
+  // Before
+  import { zValidator } from "@getvision/adapter-hono";
+  app.post("/users", zValidator("json", userSchema));
+
+  // After (works with Zod, Valibot, or Standard Schema)
+  import { validator } from "@getvision/adapter-hono";
+  app.post("/users", validator("json", userSchema));
+  ```
+
 ## 0.3.6
 
 ### Patch Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@getvision/server",
-  "version": "0.4.0-6e5c887-develop",
+  "version": "0.4.1-b47357d-develop",
   "type": "module",
   "description": "Vision Server - Meta-framework with built-in observability, pub/sub, and type-safe APIs",
   "exports": {

package/src/service.ts

@@ -145,20 +145,42 @@ export class ServiceBuilder<
   public getRoutesMetadata(): Array<{
     method: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH'
     path: string
+    queryParams?: any
     requestBody?: any
     responseBody?: any
   }> {
     const routes: Array<{
       method: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH'
       path: string
+      queryParams?: any
       requestBody?: any
       responseBody?: any
     }> = []
     this.endpoints.forEach((ep) => {
       let requestBody = undefined
-      if (ep.schema.input && ['POST', 'PUT', 'PATCH'].includes(ep.method)) {
-        requestBody = generateTemplate(ep.schema.input)
+      let queryParams = undefined
+      
+      if (ep.schema.input) {
+        if (['POST', 'PUT', 'PATCH'].includes(ep.method)) {
+          requestBody = generateTemplate(ep.schema.input)
+        } else if (ep.method === 'GET' || ep.method === 'DELETE') {
+          // Exclude path params from query params
+          const pathParamNames = (ep.path.match(/:([^/]+)/g) || []).map((p: string) => p.slice(1))
+          const fullTemplate = generateTemplate(ep.schema.input)
+          
+          if (fullTemplate && pathParamNames.length > 0) {
+            const queryFields = fullTemplate.fields.filter(
+              (f: { name: string }) => !pathParamNames.includes(f.name)
+            )
+            if (queryFields.length > 0) {
+              queryParams = { ...fullTemplate, fields: queryFields }
+            }
+          } else {
+            queryParams = fullTemplate
+          }
+        }
       }
+      
       let responseBody = undefined
       if (ep.schema.output) {
         responseBody = generateTemplate(ep.schema.output)
@@ -166,6 +188,7 @@ export class ServiceBuilder<
       routes.push({
         method: ep.method,
         path: ep.path,
+        queryParams,
         requestBody,
         responseBody,
       })
@@ -384,13 +407,34 @@ export class ServiceBuilder<
   build(app: Hono, servicesAccumulator?: Array<{ name: string; routes: any[] }>) {
     // Prepare routes with Zod schemas
     const routes = Array.from(this.endpoints.values()).map(ep => {
-      // Generate requestBody schema (input)
+      // Generate requestBody schema (input) for POST/PUT/PATCH
       let requestBody = undefined
-      if (ep.schema.input && ['POST', 'PUT', 'PATCH'].includes(ep.method)) {
-        requestBody = generateTemplate(ep.schema.input)
+      let queryParams = undefined
+      
+      if (ep.schema.input) {
+        if (['POST', 'PUT', 'PATCH'].includes(ep.method)) {
+          requestBody = generateTemplate(ep.schema.input)
+        } else if (ep.method === 'GET' || ep.method === 'DELETE') {
+          // For GET/DELETE, input schema represents query parameters
+          // BUT we need to exclude path params from query params
+          const pathParamNames = (ep.path.match(/:([^/]+)/g) || []).map((p: string) => p.slice(1))
+          const fullTemplate = generateTemplate(ep.schema.input)
+          
+          if (fullTemplate && pathParamNames.length > 0) {
+            // Filter out path params from query params
+            const queryFields = fullTemplate.fields.filter(
+              (f: { name: string }) => !pathParamNames.includes(f.name)
+            )
+            if (queryFields.length > 0) {
+              queryParams = { ...fullTemplate, fields: queryFields }
+            }
+          } else {
+            queryParams = fullTemplate
+          }
+        }
       }
       
-      // Generate responseBody schema (output) - NEW!
+      // Generate responseBody schema (output)
       let responseBody = undefined
       if (ep.schema.output) {
         responseBody = generateTemplate(ep.schema.output)
@@ -401,6 +445,7 @@ export class ServiceBuilder<
         path: ep.path,
         handler: this.name,
         middleware: [],
+        queryParams,
         requestBody,
         responseBody,
       }
@@ -525,8 +570,12 @@ export class ServiceBuilder<
           // Validate input with UniversalValidator (supports Zod, Valibot, etc.)
           const validated = UniversalValidator.parse(ep.schema.input, input)
           
+          // Merge back path params that are not in the schema
+          // This ensures path params like :id are always available to the handler
+          const finalInput = { ...params, ...(validated || {}) }
+          
           // Execute handler
-          const result = await ep.handler(validated, c as any)
+          const result = await ep.handler(finalInput, c as any)
 
           // If an output schema exists, validate and return JSON
           if (ep.schema.output) {

package/src/vision-app.ts

@@ -1,5 +1,5 @@
 import { Hono } from 'hono'
-import type { Env, Schema, Input, MiddlewareHandler } from 'hono'
+import type { Env, Schema } from 'hono'
 import { VisionCore, runInTraceContext } from '@getvision/core'
 import type { RouteMetadata } from '@getvision/core'
 import { AsyncLocalStorage } from 'async_hooks'
@@ -161,9 +161,7 @@ export class Vision<
   private eventBus: EventBus
   private config: VisionConfig
   private serviceBuilders: ServiceBuilder<any, E>[] = []
-  private fileBasedRoutes: RouteMetadata[] = []
   private bunServer?: any
-  private _cleanupPromise?: Promise<void>
   private signalHandler?: () => Promise<void>
 
   constructor(config?: VisionConfig) {
@@ -540,6 +538,7 @@ export class Vision<
         method: r.method,
         path: r.path,
         handler: name,
+        queryParams: r.queryParams,
         requestBody: r.requestBody,
         responseBody: r.responseBody,
       }))
@@ -559,31 +558,6 @@ export class Vision<
       builder.build(this as any, allServices)
     }
     
-    // Group file-based routes by path prefix (e.g., /products, /analytics)
-    if (this.fileBasedRoutes.length > 0) {
-      const groupedRoutes = new Map<string, RouteMetadata[]>()
-      
-      for (const route of this.fileBasedRoutes) {
-        // Extract first path segment as service name
-        const segments = route.path.split('/').filter(s => s && !s.startsWith(':'))
-        const serviceName = segments[0] || 'root'
-        
-        if (!groupedRoutes.has(serviceName)) {
-          groupedRoutes.set(serviceName, [])
-        }
-        groupedRoutes.get(serviceName)!.push(route)
-      }
-      
-      // Add each group as a service
-      for (const [name, routes] of groupedRoutes.entries()) {
-        const capitalizedName = name.charAt(0).toUpperCase() + name.slice(1)
-        allServices.push({
-          name: capitalizedName,
-          routes
-        })
-      }
-    }
-    
     // Don't register to VisionCore here - let start() handle it after sub-apps are loaded
     // Just return allServices so they can be registered later
     return allServices