@engjts/nexus 0.1.7 → 0.1.8

package/src/core/router/index.ts

@@ -4,222 +4,255 @@
 
 import { RadixTree } from './radix-tree';
 import {
-    HTTPMethod,
-    Handler,
-    Middleware,
-    RouteConfig,
-    RouteMatch,
-    SchemaConfig,
-    RouteMeta,
-    Context
+  HTTPMethod,
+  Handler,
+  Middleware,
+  RouteConfig,
+  RouteMatch,
+  SchemaConfig,
+  RouteMeta,
+  Context
 } from '../types';
+import { SerializerFunction, createSerializer, JSONSchema } from '../serializer';
 
 /**
  * Route with validation schema and metadata
  */
 export interface RouteEntry {
-    handler: Handler;
-    middlewares: Middleware[];
-    schema?: SchemaConfig;
-    meta?: RouteMeta;
+  handler: Handler;
+  middlewares: Middleware[];
+  schema?: SchemaConfig;
+  meta?: RouteMeta;
+  serializers?: Map<number | string, SerializerFunction>;
 }
 
 /**
  * Router class
  */
 export class Router {
-    private trees: Map<HTTPMethod, RadixTree> = new Map();
-    private routes: Array<{ method: HTTPMethod; path: string; config: RouteEntry }> = [];
-    private prefix: string = '';
-
-    constructor(prefix: string = '') {
-        this.prefix = prefix;
-        // Initialize trees for each HTTP method
-        const methods: HTTPMethod[] = ['GET', 'POST', 'PUT', 'DELETE', 'PATCH', 'HEAD', 'OPTIONS'];
-        for (const method of methods) {
-            this.trees.set(method, new RadixTree());
-        }
-    }
+  private trees: Map<HTTPMethod, RadixTree> = new Map();
+  private routes: Array<{ method: HTTPMethod; path: string; config: RouteEntry }> = [];
+  private prefix: string = '';
 
-    /**
-     * Register a route
-     */
-    addRoute(config: RouteConfig): void {
-        const { method, path, handler, middlewares = [], schema, meta } = config;
-        const fullPath = this.prefix ? `${this.prefix}${path}` : path;
+  constructor(prefix: string = '') {
+    this.prefix = prefix;
+    // Initialize trees for each HTTP method
+    const methods: HTTPMethod[] = ['GET', 'POST', 'PUT', 'DELETE', 'PATCH', 'HEAD', 'OPTIONS'];
+    for (const method of methods) {
+      this.trees.set(method, new RadixTree());
+    }
+  }
 
-        const tree = this.trees.get(method);
-        if (!tree) {
-            throw new Error(`Unsupported HTTP method: ${method}`);
-        }
+  /**
+   * Register a route
+   */
+  addRoute(config: RouteConfig): void {
+    const { method, path, handler, middlewares = [], schema, meta } = config;
+    const fullPath = this.prefix ? `${this.prefix}${path}` : path;
 
-        // Wrap handler with schema validation if provided
-        const wrappedHandler = schema ? this.wrapWithValidation(handler, schema) : handler;
+    const tree = this.trees.get(method);
+    if (!tree) {
+      throw new Error(`Unsupported HTTP method: ${method}`);
+    }
 
-        tree.insert(fullPath, wrappedHandler, middlewares);
+    // Wrap handler with schema validation if provided
+    const wrappedHandler = schema ? this.wrapWithValidation(handler, schema) : handler;
 
-        // Store for introspection (including schema and meta for documentation)
-        this.routes.push({
-            method,
-            path: fullPath,
-            config: { handler: wrappedHandler, middlewares, schema, meta }
-        });
+    // Compile response serializers if response schema is provided
+    let serializers: Map<number | string, SerializerFunction> | undefined;
+    if (schema?.response) {
+      serializers = this.compileResponseSerializers(schema.response);
     }
 
-    /**
-     * Find a matching route
-     */
-    match(method: string, path: string): RouteMatch | null {
-        const tree = this.trees.get(method as HTTPMethod);
-        if (!tree) {
-            return null;
-        }
+    tree.insert(fullPath, wrappedHandler, middlewares, serializers);
 
-        const result = tree.search(path);
-        if (!result) {
-            return null;
-        }
+    // Store for introspection (including schema, meta, and serializers for documentation)
+    this.routes.push({
+      method,
+      path: fullPath,
+      config: { handler: wrappedHandler, middlewares, schema, meta, serializers }
+    });
+  }
 
-        return {
-            handler: result.handler,
-            params: result.params,
-            middlewares: result.middlewares,
-            schema: undefined // Schema already applied in wrapped handler
-        };
-    }
+  /**
+   * Compile response schemas into fast serializers
+   */
+  private compileResponseSerializers(
+    responseSchema: Record<string | number, any>
+  ): Map<number | string, SerializerFunction> {
+    const serializers = new Map<number | string, SerializerFunction>();
 
-    /**
-     * Get all registered routes with full metadata
-     */
-    getRoutes(): Array<{ method: string; path: string; schema?: SchemaConfig; meta?: RouteMeta }> {
-        return this.routes.map(r => ({ 
-            method: r.method, 
-            path: r.path,
-            schema: r.config.schema,
-            meta: r.config.meta
-        }));
+    for (const [statusKey, schema] of Object.entries(responseSchema)) {
+      if (schema && typeof schema === 'object') {
+        try {
+          const serializer = createSerializer(schema as JSONSchema);
+          serializers.set(statusKey, serializer);
+        } catch (e) {
+          // If compilation fails, skip this serializer (will fall back to JSON.stringify)
+          console.warn(`[Router] Failed to compile serializer for status ${statusKey}:`, e);
+        }
+      }
     }
 
-    /**
-     * Get raw route configs for merging into Application
-     */
-    getRawRoutes(): Array<{ method: HTTPMethod; path: string; config: RouteEntry }> {
-        return this.routes;
-    }
+    return serializers;
+  }
 
-    /**
-     * Get internal radix trees for merging
-     */
-    getTrees(): Map<HTTPMethod, RadixTree> {
-        return this.trees;
+  /**
+   * Find a matching route
+   */
+  match(method: string, path: string): RouteMatch | null {
+    const tree = this.trees.get(method as HTTPMethod);
+    if (!tree) {
+      return null;
     }
 
-    /**
-     * Mount another router with a prefix (group routes)
-     * 
-     * @example
-     * ```typescript
-     * const userRoutes = new Router();
-     * userRoutes.get('/', getAllUsers);
-     * userRoutes.get('/:id', getUserById);
-     * 
-     * const router = new Router();
-     * router.group('/api/users', userRoutes);
-     * ```
-     */
-    group(prefix: string, router: Router): void {
-        const routes = router.getRawRoutes();
-        for (const route of routes) {
-            const fullPath = `${prefix}${route.path}`;
-            this.addRoute({
-                method: route.method,
-                path: fullPath,
-                handler: route.config.handler,
-                middlewares: route.config.middlewares,
-                schema: route.config.schema,
-                meta: route.config.meta
-            });
-        }
+    const result = tree.search(path);
+    if (!result) {
+      return null;
     }
 
-    /**
-     * Convenience methods for HTTP verbs
-     */
-    get(path: string, handler: Handler, options?: Partial<RouteConfig>): void {
-        this.addRoute({ method: 'GET', path, handler, ...options });
-    }
+    return {
+      handler: result.handler,
+      params: result.params,
+      middlewares: result.middlewares,
+      schema: undefined, // Schema already applied in wrapped handler
+      _serializer: result.serializers || undefined
+    };
+  }
 
-    post(path: string, handler: Handler, options?: Partial<RouteConfig>): void {
-        this.addRoute({ method: 'POST', path, handler, ...options });
-    }
+  /**
+   * Get all registered routes with full metadata
+   */
+  getRoutes(): Array<{ method: string; path: string; schema?: SchemaConfig; meta?: RouteMeta }> {
+    return this.routes.map(r => ({
+      method: r.method,
+      path: r.path,
+      schema: r.config.schema,
+      meta: r.config.meta
+    }));
+  }
 
-    put(path: string, handler: Handler, options?: Partial<RouteConfig>): void {
-        this.addRoute({ method: 'PUT', path, handler, ...options });
-    }
+  /**
+   * Get raw route configs for merging into Application
+   */
+  getRawRoutes(): Array<{ method: HTTPMethod; path: string; config: RouteEntry }> {
+    return this.routes;
+  }
 
-    delete(path: string, handler: Handler, options?: Partial<RouteConfig>): void {
-        this.addRoute({ method: 'DELETE', path, handler, ...options });
-    }
+  /**
+   * Get internal radix trees for merging
+   */
+  getTrees(): Map<HTTPMethod, RadixTree> {
+    return this.trees;
+  }
 
-    patch(path: string, handler: Handler, options?: Partial<RouteConfig>): void {
-        this.addRoute({ method: 'PATCH', path, handler, ...options });
+  /**
+   * Mount another router with a prefix (group routes)
+   * 
+   * @example
+   * ```typescript
+   * const userRoutes = new Router();
+   * userRoutes.get('/', getAllUsers);
+   * userRoutes.get('/:id', getUserById);
+   * 
+   * const router = new Router();
+   * router.group('/api/users', userRoutes);
+   * ```
+   */
+  group(prefix: string, router: Router): void {
+    const routes = router.getRawRoutes();
+    for (const route of routes) {
+      const fullPath = `${prefix}${route.path}`;
+      this.addRoute({
+        method: route.method,
+        path: fullPath,
+        handler: route.config.handler,
+        middlewares: route.config.middlewares,
+        schema: route.config.schema,
+        meta: route.config.meta
+      });
     }
+  }
+
+  /**
+   * Convenience methods for HTTP verbs
+   */
+  get(path: string, handler: Handler, options?: Partial<RouteConfig>): void {
+    this.addRoute({ method: 'GET', path, handler, ...options });
+  }
 
-    /**
-     * Wrap handler with schema validation
-     */
-    private wrapWithValidation(handler: Handler, schema: SchemaConfig): Handler {
-        return async (ctx: Context) => {
-            try {
-                // Validate params
-                if (schema.params) {
-                    ctx.params = await schema.params.parseAsync(ctx.params);
-                }
-
-                // Validate query
-                if (schema.query) {
-                    ctx.query = await schema.query.parseAsync(ctx.query);
-                }
-
-                // Validate body
-                if (schema.body) {
-                    ctx.body = await schema.body.parseAsync(ctx.body);
-                }
-
-                // Validate headers
-                if (schema.headers) {
-                    ctx.headers = await schema.headers.parseAsync(ctx.headers);
-                }
-
-                // Call original handler with validated data
-                return handler(ctx, {});
-            } catch (error: any) {
-                // Zod validation error
-                if (error.name === 'ZodError') {
-                    // Use custom error handler if provided
-                    if (schema.onValidationError) {
-                        const customResponse = schema.onValidationError(error.errors, ctx);
-                        // If it's already a Response object, return it
-                        if (customResponse?.statusCode) {
-                            return customResponse;
-                        }
-                        // Otherwise wrap it as JSON response
-                        return ctx.json(customResponse, 400);
-                    }
-                    
-                    // Default error response - extract first error message
-                    const firstError = error.errors[0];
-                    const message = firstError?.message || 'Validation failed';
-                    
-                    return ctx.json({
-                        success: false,
-                        message
-                    }, 400);
-                }
-                throw error;
+  post(path: string, handler: Handler, options?: Partial<RouteConfig>): void {
+    this.addRoute({ method: 'POST', path, handler, ...options });
+  }
+
+  put(path: string, handler: Handler, options?: Partial<RouteConfig>): void {
+    this.addRoute({ method: 'PUT', path, handler, ...options });
+  }
+
+  delete(path: string, handler: Handler, options?: Partial<RouteConfig>): void {
+    this.addRoute({ method: 'DELETE', path, handler, ...options });
+  }
+
+  patch(path: string, handler: Handler, options?: Partial<RouteConfig>): void {
+    this.addRoute({ method: 'PATCH', path, handler, ...options });
+  }
+
+  /**
+   * Wrap handler with schema validation
+   */
+  private wrapWithValidation(handler: Handler, schema: SchemaConfig): Handler {
+    return async (ctx: Context) => {
+      try {
+        // Validate params
+        if (schema.params) {
+          ctx.params = await schema.params.parseAsync(ctx.params);
+        }
+
+        // Validate query
+        if (schema.query) {
+          ctx.query = await schema.query.parseAsync(ctx.query);
+        }
+
+        // Validate body - MUST await getBody() first to parse the request body
+        if (schema.body) {
+          const rawBody = await ctx.getBody();
+          ctx.body = await schema.body.parseAsync(rawBody);
+        }
+
+        // Validate headers
+        if (schema.headers) {
+          ctx.headers = await schema.headers.parseAsync(ctx.headers);
+        }
+
+        // Call original handler with validated data
+        return handler(ctx, {});
+      } catch (error: any) {
+        // Zod validation error
+        if (error.name === 'ZodError') {
+          // Use custom error handler if provided
+          if (schema.onValidationError) {
+            const customResponse = schema.onValidationError(error.errors, ctx);
+            // If it's already a Response object, return it
+            if (customResponse?.statusCode) {
+              return customResponse;
             }
-        };
-    }
+            // Otherwise wrap it as JSON response
+            return ctx.json(customResponse, 400);
+          }
+
+          // Default error response - extract first error message
+          const firstError = error.errors[0];
+          const message = firstError?.message || 'Validation failed';
+
+          return ctx.json({
+            success: false,
+            message
+          }, 400);
+        }
+        throw error;
+      }
+    };
+  }
 }
 
 // Re-export file router

package/src/core/router/radix-tree.ts

@@ -4,6 +4,7 @@
  */
 
 import { Handler, Middleware } from '../types';
+import { SerializerFunction } from '../serializer';
 
 /**
  * Node in the radix tree
@@ -30,6 +31,9 @@ export class RadixNode {
     // Parameter name for param nodes
     paramName?: string;
 
+    // Compiled serializers for response (status code → serializer)
+    serializers: Map<number | string, SerializerFunction> | null = null;
+
     constructor(segment: string, fullPath: string) {
         this.segment = segment;
         this.fullPath = fullPath;
@@ -103,7 +107,12 @@ export class RadixTree {
     /**
      * Insert a route into the tree
      */
-    insert(path: string, handler: Handler, middlewares: Middleware[] = []): void {
+    insert(
+        path: string, 
+        handler: Handler, 
+        middlewares: Middleware[] = [],
+        serializers?: Map<number | string, SerializerFunction>
+    ): void {
         const segments = this.splitPath(path);
         let current = this.root;
 
@@ -120,15 +129,21 @@ export class RadixTree {
             current = child;
         }
 
-        // Set handler and middleware at terminal node
+        // Set handler, middleware, and serializers at terminal node
         current.handler = handler;
         current.middlewares = middlewares;
+        current.serializers = serializers || null;
     }
 
     /**
      * Search for a route match
      */
-    search(path: string): { handler: Handler; params: Record<string, string>; middlewares: Middleware[] } | null {
+    search(path: string): { 
+        handler: Handler; 
+        params: Record<string, string>; 
+        middlewares: Middleware[];
+        serializers: Map<number | string, SerializerFunction> | null;
+    } | null {
         const segments = this.splitPath(path);
         const params: Record<string, string> = {};
 
@@ -138,7 +153,8 @@ export class RadixTree {
             return {
                 handler: result.handler!,
                 params,
-                middlewares: result.middlewares
+                middlewares: result.middlewares,
+                serializers: result.serializers
             };
         }