@engjts/nexus 0.1.6 → 0.1.8

package/src/core/index.ts

@@ -76,5 +76,19 @@ export {
 export { BufferPool, StreamUtils } from './performance/buffer-pool';
 export { MiddlewareOptimizer, PerformanceMonitor } from './performance/middleware-optimizer';
 
+// Fast JSON Serializer
+export {
+    createSerializer,
+    createArraySerializer,
+    serialize,
+    serializerRegistry,
+    SerializerRegistry,
+    CommonSchemas,
+    type JSONSchema,
+    type ResponseSchemaConfig,
+    type SerializerFunction,
+    type SerializerOptions
+} from './serializer';
+
 // Re-export Zod for convenience
 export { z } from 'zod';

package/src/core/middleware.ts

@@ -12,6 +12,7 @@ import { Context, Middleware, Handler, Response, Next, LifecycleHooks } from './
 export class MiddlewareExecutor {
     /**
      * Execute middleware chain with a final handler
+     * Optimized: skip recursion when no middleware
      */
     async execute(
         ctx: Context,
@@ -19,50 +20,57 @@ export class MiddlewareExecutor {
         handler: Handler,
         deps: any = {}
     ): Promise<Response> {
+        const len = middlewares.length;
+        
+        // Fast path: no middleware - call handler directly
+        if (len === 0) {
+            return this.executeHandler(ctx, handler, deps);
+        }
+        
+        // Single middleware - no recursion needed
+        if (len === 1) {
+            return middlewares[0](ctx, async (c) => this.executeHandler(c, handler, deps), deps);
+        }
+        
+        // Multiple middleware - use optimized loop
         let index = 0;
 
         const next: Next = async (currentCtx: Context): Promise<Response> => {
-            if (index < middlewares.length) {
+            if (index < len) {
                 const middleware = middlewares[index++];
-
-                try {
-                    // Execute middleware with next function and dependencies
-                    return await middleware(currentCtx, next, deps);
-                } catch (error) {
-                    // Propagate error to be caught by error handler
-                    throw error;
-                }
-            } else {
-                // All middleware executed, call final handler
-                try {
-                    const result = await handler(currentCtx, deps);
-
-                    // If handler returns an Error, throw it to be caught by error handler
-                    if (result instanceof Error) {
-                        // Mark as intentional (returned, not thrown)
-                        (result as any)._isIntentional = true;
-                        throw result;
-                    }
-
-                    // If handler returns a Response, use it
-                    if (this.isResponse(result)) {
-                        return result;
-                    }
-
-                    // Otherwise, wrap in JSON response
-                    return currentCtx.json(result);
-                } catch (error) {
-                    throw error;
-                }
+                return middleware(currentCtx, next, deps);
             }
+            return this.executeHandler(currentCtx, handler, deps);
         };
 
         return next(ctx);
     }
+    
+    /**
+     * Execute handler and normalize response - inlined for performance
+     */
+    private async executeHandler(ctx: Context, handler: Handler, deps: any): Promise<Response> {
+        const result = await handler(ctx, deps);
+
+        // If handler returns an Error, throw it
+        if (result instanceof Error) {
+            (result as any)._isIntentional = true;
+            throw result;
+        }
+
+        // Fast path: already a Response
+        if (result && typeof result === 'object' && 'statusCode' in result && 'body' in result) {
+            return result as Response;
+        }
+
+        // Wrap in JSON response
+        return ctx.json(result);
+    }
 
     /**
      * Execute middleware chain with lifecycle hooks
      * This method integrates hooks at the appropriate points in the request lifecycle
+     * Optimized to check hooks existence only once
      */
     async executeWithHooks(
         ctx: Context,
@@ -71,77 +79,79 @@ export class MiddlewareExecutor {
         hooks: LifecycleHooks,
         deps: any = {}
     ): Promise<Response> {
+        // Check if we have any hooks at all (optimization)
+        const hasHooks = hooks.beforeValidation || hooks.afterValidation || 
+                         hooks.beforeHandler || hooks.afterHandler;
+        
+        // Fast path: no hooks and no middleware
+        if (!hasHooks && middlewares.length === 0) {
+            return this.executeHandler(ctx, handler, deps);
+        }
+
+        // Fast path: no hooks but has middleware
+        if (!hasHooks) {
+            return this.execute(ctx, middlewares, handler, deps);
+        }
+
         let index = 0;
+        const len = middlewares.length;
 
         const next: Next = async (currentCtx: Context): Promise<Response> => {
-            if (index < middlewares.length) {
+            if (index < len) {
                 const middleware = middlewares[index++];
+                return middleware(currentCtx, next, deps);
+            }
+            
+            // All middleware executed, now run handler with hooks
+            
+            // === HOOK: beforeValidation ===
+            if (hooks.beforeValidation) {
+                const hookResult = await hooks.beforeValidation(currentCtx);
+                if (hookResult && typeof hookResult === 'object' && 'statusCode' in hookResult) {
+                    return hookResult as Response;
+                }
+            }
 
-                try {
-                    // Execute middleware with next function and dependencies
-                    return await middleware(currentCtx, next, deps);
-                } catch (error) {
-                    throw error;
+            // === HOOK: afterValidation ===
+            if (hooks.afterValidation) {
+                const hookResult = await hooks.afterValidation(currentCtx);
+                if (hookResult && typeof hookResult === 'object' && 'statusCode' in hookResult) {
+                    return hookResult as Response;
                 }
-            } else {
-                // All middleware executed, now run handler with hooks
-                
-                // === HOOK: beforeValidation ===
-                if (hooks.beforeValidation) {
-                    const hookResult = await hooks.beforeValidation(currentCtx);
-                    if (this.isResponse(hookResult)) {
-                        return hookResult;
-                    }
+            }
+
+            // === HOOK: beforeHandler ===
+            if (hooks.beforeHandler) {
+                const hookResult = await hooks.beforeHandler(currentCtx);
+                if (hookResult && typeof hookResult === 'object' && 'statusCode' in hookResult) {
+                    return hookResult as Response;
                 }
+            }
 
-                // TODO: Schema validation happens here (if route has schema)
-                // For now, validation is handled in middleware or by the handler itself
+            // Execute the handler with dependencies
+            let result = await handler(currentCtx, deps);
 
-                // === HOOK: afterValidation ===
-                if (hooks.afterValidation) {
-                    const hookResult = await hooks.afterValidation(currentCtx);
-                    if (this.isResponse(hookResult)) {
-                        return hookResult;
-                    }
-                }
+            // If handler returns an Error, throw it
+            if (result instanceof Error) {
+                (result as any)._isIntentional = true;
+                throw result;
+            }
 
-                // === HOOK: beforeHandler ===
-                if (hooks.beforeHandler) {
-                    const hookResult = await hooks.beforeHandler(currentCtx);
-                    if (this.isResponse(hookResult)) {
-                        return hookResult;
-                    }
+            // === HOOK: afterHandler ===
+            if (hooks.afterHandler) {
+                const transformedResult = await hooks.afterHandler(currentCtx, result);
+                if (transformedResult !== undefined) {
+                    result = transformedResult;
                 }
+            }
 
-                // Execute the handler with dependencies
-                try {
-                    let result = await handler(currentCtx, deps);
-
-                    // If handler returns an Error, throw it
-                    if (result instanceof Error) {
-                        (result as any)._isIntentional = true;
-                        throw result;
-                    }
-
-                    // === HOOK: afterHandler ===
-                    if (hooks.afterHandler) {
-                        const transformedResult = await hooks.afterHandler(currentCtx, result);
-                        if (transformedResult !== undefined) {
-                            result = transformedResult;
-                        }
-                    }
-
-                    // If result is a Response, return it
-                    if (this.isResponse(result)) {
-                        return result;
-                    }
-
-                    // Otherwise, wrap in JSON response
-                    return currentCtx.json(result);
-                } catch (error) {
-                    throw error;
-                }
+            // If result is a Response, return it
+            if (result && typeof result === 'object' && 'statusCode' in result && 'body' in result) {
+                return result as Response;
             }
+
+            // Otherwise, wrap in JSON response
+            return currentCtx.json(result);
         };
 
         return next(ctx);

package/src/core/router/file-router.ts

@@ -4,20 +4,26 @@
  * Automatically scans a directory and registers routes based on file/folder structure.
  * Designed for class-based routing: 1 file = 1 class = 1 route.
  * 
- * Smart filename conventions:
+ * Smart filename conventions (only if no body schema):
  * - `index.ts`  → GET (default), maps to parent path
  * - `create.ts` → POST, maps to parent path (not /create)
  * - `update.ts` → PUT, maps to parent path (not /update)
  * - `delete.ts` → DELETE, maps to parent path (not /delete)
  * - `patch.ts`  → PATCH, maps to parent path (not /patch)
- * - Other files → GET (or specify `method` in class)
+ * - Other files → GET (default)
+ * 
+ * Smart body detection (HIGHEST PRIORITY after explicit method):
+ * - If schema() returns object with `body` property → POST
+ * - Works with inheritance (parent class schema is checked too)
+ * - Overrides smart filename detection!
+ * - Override by explicitly setting `method` property in class
  * 
  * @example
  * ```
  * routes/
  *   api/
  *     auth/
- *       register.ts       → POST /api/auth/register (method = 'POST' in class)
+ *       register.ts       → POST /api/auth/register (auto-detected via ctx.body!)
  *       login.ts          → POST /api/auth/login
  *     users/
  *       index.ts          → GET /api/users
@@ -31,11 +37,18 @@
  * Each file exports a class:
  * ```typescript
  * export default class RegisterRoute {
- *   method = 'POST'  // Optional if filename is create/update/delete
+ *   // No need to specify method = 'POST' if schema has body!
+ *   
+ *   schema() {
+ *     return {
+ *       body: z.object({ ... })  // ← auto-detects POST!
+ *     };
+ *   }
  *   
- *   schema() { ... }
- *   meta() { ... }
- *   async handler(ctx: Context) { ... }
+ *   async handler(ctx: Context) {
+ *     const data = ctx.body;
+ *     ...
+ *   }
  * }
  * ```
  */
@@ -429,16 +442,32 @@ export class FileRouter {
             
             // Determine HTTP method:
             // 1. If class explicitly defines method → use it
-            // 2. If filename is smart (create/update/delete/patch/index) → auto-detect
-            // 3. Otherwise → default GET
+            // 2. If schema has body definition → auto-detect as POST (highest priority for body!)
+            // 3. If filename is smart (create/update/delete/patch/index) → auto-detect from filename
+            // 4. Otherwise → default GET
             let method: HTTPMethod;
+            
             if (route.method) {
                 // Handle both single method and array of methods (use first one for file-based routing)
                 method = Array.isArray(route.method) ? route.method[0] : route.method;
-            } else if (isSmartFilename(nameWithoutExt)) {
-                method = getSmartMethod(nameWithoutExt);
             } else {
-                method = DEFAULT_METHOD;
+                // Check schema for body definition first (works with inheritance!)
+                const schema = route.schema?.();
+                if (this.options.debug) {
+                    console.log(`🔍 Smart detection for ${filePath}:`);
+                    console.log(`   - schema:`, schema);
+                    console.log(`   - has body:`, !!schema?.body);
+                }
+                
+                if (schema?.body) {
+                    // Schema has body → POST (overrides smart filename!)
+                    method = 'POST';
+                } else if (isSmartFilename(nameWithoutExt)) {
+                    // Smart filename detection (create→POST, update→PUT, etc.)
+                    method = getSmartMethod(nameWithoutExt);
+                } else {
+                    method = DEFAULT_METHOD;
+                }
             }
             
             // Validate method