wynkjs 1.0.3 → 1.0.6

package/dist/factory.js

@@ -2,28 +2,51 @@ import { Elysia } from "elysia";
 import "reflect-metadata";
 import { container } from "tsyringe";
 import { Value } from "@sinclair/typebox/value";
-import { createExecutionContext, executeGuards, } from "./decorators/guard.decorators";
-import { executeInterceptors } from "./decorators/interceptor.decorators";
-import { executePipes } from "./decorators/pipe.decorators";
-import { executeExceptionFilters, HttpException, } from "./decorators/exception.decorators";
+import { executeExceptionFilters, } from "./decorators/exception.decorators";
+import { schemaRegistry } from "./schema-registry";
+import { setupCors } from "./cors";
+import { normalizePrefixPath } from "./global-prefix";
+import { buildUltraOptimizedHandler, buildMiddlewareChain, } from "./ultra-optimized-handler";
 export class WynkFramework {
     app;
     controllers = [];
+    providers = []; // Store registered providers
     globalGuards = [];
     globalInterceptors = [];
     globalPipes = [];
     globalFilters = [];
     validationFormatter;
+    shutdownHandlersRegistered = false; // Prevent duplicate signal handlers
+    globalPrefix; // Store global prefix for route registration
+    isBuilt = false; // Track if build() has been called
     constructor(options = {}) {
         this.app = new Elysia();
         this.validationFormatter = options.validationErrorFormatter;
+        // Store global prefix for later use
+        if (options.globalPrefix) {
+            this.globalPrefix = normalizePrefixPath(options.globalPrefix);
+        }
+        // Register providers if provided
+        if (options.providers && options.providers.length > 0) {
+            this.providers.push(...options.providers);
+        }
+        // Apply CORS configuration
+        if (options.cors) {
+            setupCors(this.app, options.cors);
+        }
         // Configure Elysia's error handling for validation errors
-        this.app.onError(({ code, error, set }) => {
+        this.app.onError(({ code, error, set, request }) => {
             // Handle ValidationError from Elysia
             if (code === "VALIDATION" ||
                 error?.constructor?.name === "ValidationError") {
                 const validationError = error;
                 set.status = 400;
+                // Get the validation type (body, query, params)
+                const validationType = validationError.on || "body";
+                // Try to find the schema key for this route
+                const method = request.method;
+                const path = new URL(request.url).pathname;
+                const schemaKey = schemaRegistry.getSchemaKeyForRoute(method, path, validationType);
                 // Try to collect all validation errors using TypeBox
                 const allErrors = {};
                 // Check if we have the validator and value to collect all errors
@@ -38,7 +61,15 @@ export class WynkFramework {
                                 if (!allErrors[field]) {
                                     allErrors[field] = [];
                                 }
-                                allErrors[field].push(err.message || "Validation failed");
+                                // Try to get custom error message from schema registry
+                                let message = err.message || "Validation failed";
+                                if (schemaKey) {
+                                    const customMessage = schemaRegistry.getErrorMessage(schemaKey, field);
+                                    if (customMessage) {
+                                        message = customMessage;
+                                    }
+                                }
+                                allErrors[field].push(message);
                             });
                         }
                         else {
@@ -46,9 +77,16 @@ export class WynkFramework {
                             const field = validationError.valueError?.path?.replace(/^\//, "") ||
                                 validationError.on ||
                                 "body";
-                            const message = validationError.customError ||
+                            let message = validationError.customError ||
                                 validationError.valueError?.message ||
                                 "Validation failed";
+                            // Try to get custom error message
+                            if (schemaKey) {
+                                const customMessage = schemaRegistry.getErrorMessage(schemaKey, field);
+                                if (customMessage) {
+                                    message = customMessage;
+                                }
+                            }
                             allErrors[field] = [message];
                         }
                     }
@@ -57,9 +95,16 @@ export class WynkFramework {
                         const field = validationError.valueError?.path?.replace(/^\//, "") ||
                             validationError.on ||
                             "body";
-                        const message = validationError.customError ||
+                        let message = validationError.customError ||
                             validationError.valueError?.message ||
                             "Validation failed";
+                        // Try to get custom error message
+                        if (schemaKey) {
+                            const customMessage = schemaRegistry.getErrorMessage(schemaKey, field);
+                            if (customMessage) {
+                                message = customMessage;
+                            }
+                        }
                         allErrors[field] = [message];
                     }
                 }
@@ -68,9 +113,16 @@ export class WynkFramework {
                     const field = validationError.valueError?.path?.replace(/^\//, "") ||
                         validationError.on ||
                         "body";
-                    const message = validationError.customError ||
+                    let message = validationError.customError ||
                         validationError.valueError?.message ||
                         "Validation failed";
+                    // Try to get custom error message
+                    if (schemaKey) {
+                        const customMessage = schemaRegistry.getErrorMessage(schemaKey, field);
+                        if (customMessage) {
+                            message = customMessage;
+                        }
+                    }
                     allErrors[field] = [message];
                 }
                 // If a custom formatter is provided, use it
@@ -101,13 +153,10 @@ export class WynkFramework {
                 error: err.name || "Error",
             };
         });
-        // Apply CORS if enabled
-        if (options.cors) {
-            // CORS configuration would go here
-        }
         // Apply global prefix if specified
         if (options.globalPrefix) {
-            // Global prefix handling
+            // Global prefix is handled during route registration
+            console.log(`✅ Global prefix configured: ${this.globalPrefix}`);
         }
         return this;
     }
@@ -116,11 +165,21 @@ export class WynkFramework {
      */
     static create(options = {}) {
         const app = new WynkFramework(options);
+        // Don't re-register providers/controllers if they were already added in constructor
+        // The constructor already handles options.providers
         if (options.controllers && options.controllers.length) {
             app.registerControllers(...options.controllers);
         }
         return app;
     }
+    /**
+     * Register providers with the application
+     * Providers are singleton services that are initialized when the app starts
+     */
+    registerProviders(...providers) {
+        this.providers.push(...providers);
+        return this;
+    }
     /**
      * Register controllers with the application
      */
@@ -156,10 +215,42 @@ export class WynkFramework {
         this.globalFilters.push(...filters);
         return this;
     }
+    /**
+     * Initialize all registered providers
+     * Providers with onModuleInit() method will be called
+     */
+    async initializeProviders() {
+        console.log(`🔧 Initializing ${this.providers.length} providers...`);
+        for (const ProviderClass of this.providers) {
+            try {
+                console.log(`  ⚙️  Initializing provider: ${ProviderClass.name}`);
+                // Resolve provider instance from DI container
+                const instance = container.resolve(ProviderClass);
+                // Check if provider has onModuleInit lifecycle hook
+                if (typeof instance.onModuleInit === "function") {
+                    await instance.onModuleInit();
+                    console.log(`  ✅ ${ProviderClass.name} initialized successfully`);
+                }
+                else {
+                    // Just register in container for injection
+                    console.log(`  ✅ ${ProviderClass.name} registered in container`);
+                }
+            }
+            catch (error) {
+                console.error(`  ❌ Failed to initialize provider ${ProviderClass.name}:`, error);
+                throw new Error(`Provider initialization failed for ${ProviderClass.name}: ${error.message}`);
+            }
+        }
+        console.log(`✅ All providers initialized successfully\n`);
+    }
     /**
      * Build the application - register all routes
      */
     async build() {
+        // Initialize providers first (database connections, etc.)
+        if (this.providers.length > 0) {
+            await this.initializeProviders();
+        }
         // Register global error handler if filters exist
         if (this.globalFilters.length > 0) {
             this.app.onError(async ({ error, set, request }) => {
@@ -198,8 +289,33 @@ export class WynkFramework {
         for (const ControllerClass of this.controllers) {
             await this.registerController(ControllerClass);
         }
+        this.isBuilt = true;
         return this.app;
     }
+    /**
+     * Cleanup all providers when app shuts down
+     * Providers with onModuleDestroy() method will be called
+     */
+    async destroyProviders() {
+        console.log(`\n🔧 Cleaning up ${this.providers.length} providers...`);
+        for (const ProviderClass of this.providers) {
+            try {
+                // Resolve provider instance from DI container
+                const instance = container.resolve(ProviderClass);
+                // Check if provider has onModuleDestroy lifecycle hook
+                if (typeof instance.onModuleDestroy === "function") {
+                    console.log(`  🧹 Destroying provider: ${ProviderClass.name}`);
+                    await instance.onModuleDestroy();
+                    console.log(`  ✅ ${ProviderClass.name} destroyed successfully`);
+                }
+            }
+            catch (error) {
+                console.error(`  ❌ Failed to destroy provider ${ProviderClass.name}:`, error);
+                // Continue cleanup even if one provider fails
+            }
+        }
+        console.log(`✅ All providers cleaned up\n`);
+    }
     /**
      * Start listening on a port
      */
@@ -207,6 +323,29 @@ export class WynkFramework {
         await this.build();
         this.app.listen(port);
         console.log(`🚀 Application is running on http://localhost:${port}`);
+        // Register signal handlers only once to prevent memory leaks
+        if (!this.shutdownHandlersRegistered) {
+            this.shutdownHandlersRegistered = true;
+            // Setup graceful shutdown handlers
+            const gracefulShutdown = async (signal) => {
+                console.log(`\n📡 Received ${signal}, shutting down gracefully...`);
+                try {
+                    // Cleanup providers (close database connections, etc.)
+                    await this.destroyProviders();
+                    // Stop the Elysia server
+                    await this.app.stop();
+                    console.log("👋 Application shut down successfully");
+                    process.exit(0);
+                }
+                catch (error) {
+                    console.error("❌ Error during shutdown:", error);
+                    process.exit(1);
+                }
+            };
+            // Register signal handlers (only once)
+            process.once("SIGTERM", () => gracefulShutdown("SIGTERM"));
+            process.once("SIGINT", () => gracefulShutdown("SIGINT"));
+        }
     }
     /**
      * Get the underlying Elysia instance
@@ -214,6 +353,16 @@ export class WynkFramework {
     getApp() {
         return this.app;
     }
+    /**
+     * Handle an HTTP request
+     * Automatically builds the app if not already built
+     */
+    async handle(request) {
+        if (!this.isBuilt) {
+            await this.build();
+        }
+        return this.app.handle(request);
+    }
     /**
      * Register a single controller
      */
@@ -237,7 +386,11 @@ export class WynkFramework {
         // Get @Use() middleware (simple pattern like user's working code)
         const controllerUses = Reflect.getMetadata("uses", ControllerClass) || [];
         for (const route of routes) {
-            const fullPath = basePath + route.path;
+            // Apply global prefix to route path
+            let fullPath = basePath + route.path;
+            if (this.globalPrefix) {
+                fullPath = this.globalPrefix + fullPath;
+            }
             const method = route.method.toLowerCase();
             const methodName = route.methodName;
             // Get method-specific metadata
@@ -248,19 +401,24 @@ export class WynkFramework {
             // Get @Use() middleware for this method
             const methodUses = Reflect.getMetadata("uses", instance, methodName) || [];
             const params = Reflect.getMetadata("params", instance, methodName) || [];
+            // Sort params once during registration, not on every request
+            if (params.length > 0) {
+                params.sort((a, b) => a.index - b.index);
+            }
             const httpCode = Reflect.getMetadata("route:httpCode", instance, methodName);
             const headers = Reflect.getMetadata("route:headers", instance, methodName);
             const redirect = Reflect.getMetadata("route:redirect", instance, methodName);
-            // Combine guards, interceptors, pipes, filters (global -> controller -> method)
+            // Combine guards, interceptors, pipes, filters
+            // Order: method -> controller -> global (method is innermost/closest to handler)
             const allGuards = [
                 ...this.globalGuards,
                 ...controllerGuards,
                 ...methodGuards,
             ];
             const allInterceptors = [
-                ...this.globalInterceptors,
-                ...controllerInterceptors,
                 ...methodInterceptors,
+                ...controllerInterceptors,
+                ...this.globalInterceptors,
             ];
             const allPipes = [
                 ...this.globalPipes,
@@ -278,189 +436,53 @@ export class WynkFramework {
             if (bodySchema && !routeOptions.body) {
                 routeOptions.body = bodySchema;
             }
-            // Create route handler
-            const handler = async (ctx) => {
-                try {
-                    // Create execution context
-                    const executionContext = createExecutionContext(ctx, instance[methodName], ControllerClass);
-                    // Execute guards
-                    if (allGuards.length > 0) {
-                        const canActivate = await executeGuards(allGuards, executionContext);
-                        if (!canActivate) {
-                            throw new HttpException("Forbidden", 403, "Access denied");
-                        }
-                    }
-                    // Prepare handler with parameters and pipes
-                    const executeHandler = async () => {
-                        // Build arguments for the controller method
-                        const args = [];
-                        if (params.length === 0) {
-                            // No parameter decorators, pass full context
-                            args.push(ctx);
-                        }
-                        else {
-                            // Sort params by index
-                            params.sort((a, b) => a.index - b.index);
-                            for (const param of params) {
-                                let value;
-                                // Extract value based on type
-                                switch (param.type) {
-                                    case "body":
-                                        value = param.data ? ctx.body?.[param.data] : ctx.body;
-                                        break;
-                                    case "param":
-                                        value = param.data ? ctx.params?.[param.data] : ctx.params;
-                                        break;
-                                    case "query":
-                                        value = param.data ? ctx.query?.[param.data] : ctx.query;
-                                        break;
-                                    case "headers":
-                                        value = param.data
-                                            ? ctx.headers?.get?.(param.data) ||
-                                                ctx.request?.headers?.get?.(param.data)
-                                            : ctx.headers || ctx.request?.headers;
-                                        break;
-                                    case "request":
-                                        value = ctx.request || ctx;
-                                        break;
-                                    case "response":
-                                        value = ctx.set || ctx.response;
-                                        break;
-                                    case "context":
-                                        if (param.data) {
-                                            // Access nested property like "session.userId"
-                                            const keys = param.data.split(".");
-                                            value = keys.reduce((obj, key) => obj?.[key], ctx);
-                                        }
-                                        else {
-                                            value = ctx;
-                                        }
-                                        break;
-                                    case "user":
-                                        value = param.data ? ctx.user?.[param.data] : ctx.user;
-                                        break;
-                                    case "file":
-                                        value = ctx.body?.file || ctx.file;
-                                        break;
-                                    case "files":
-                                        value = ctx.body?.files || ctx.files;
-                                        break;
-                                }
-                                // Apply pipes if any
-                                if (param.pipes && param.pipes.length > 0) {
-                                    const metadata = {
-                                        type: param.type,
-                                        data: param.data,
-                                    };
-                                    value = await executePipes(param.pipes, value, metadata);
-                                }
-                                // Apply global/controller/method pipes
-                                if (allPipes.length > 0) {
-                                    const metadata = {
-                                        type: param.type,
-                                        data: param.data,
-                                    };
-                                    value = await executePipes(allPipes, value, metadata);
-                                }
-                                args[param.index] = value;
-                            }
-                        }
-                        // Call controller method
-                        return await instance[methodName].apply(instance, args);
-                    };
-                    // Execute interceptors
-                    let result;
-                    if (allInterceptors.length > 0) {
-                        result = await executeInterceptors(allInterceptors, executionContext, executeHandler);
-                    }
-                    else {
-                        result = await executeHandler();
-                    }
-                    // Handle redirect
-                    if (redirect) {
-                        ctx.set.redirect = redirect.url;
-                        ctx.set.status = redirect.statusCode;
-                        return;
-                    }
-                    // Set custom HTTP code
-                    if (httpCode) {
-                        ctx.set.status = httpCode;
-                    }
-                    // Set custom headers
-                    if (headers) {
-                        Object.entries(headers).forEach(([key, value]) => {
-                            ctx.set.headers[key] = value;
-                        });
-                    }
-                    return result;
-                }
-                catch (error) {
-                    console.log("🔴 ERROR CAUGHT IN FACTORY");
-                    console.log("allFilters.length:", allFilters.length);
-                    console.log("Error:", error?.message);
-                    // Execute exception filters
-                    if (allFilters.length > 0) {
-                        console.log("✅ Executing exception filters...");
-                        const executionContext = createExecutionContext(ctx, instance[methodName], ControllerClass);
-                        try {
-                            const result = await executeExceptionFilters(allFilters, error, executionContext);
-                            if (result) {
-                                if (result.statusCode) {
-                                    ctx.set.status = result.statusCode;
-                                }
-                                return result;
-                            }
-                        }
-                        catch (filterError) {
-                            // If filter doesn't handle it, continue to default error handling
-                            error = filterError;
-                        }
-                    }
-                    else {
-                        console.log("❌ No filters registered for this route");
-                    }
-                    // Default error handling
-                    if (error instanceof HttpException) {
-                        ctx.set.status = error.getStatus();
-                        return error.getResponse();
-                    }
-                    // Unknown error
-                    ctx.set.status = 500;
-                    return {
-                        statusCode: 500,
-                        message: error.message || "Internal server error",
-                        error: "Internal Server Error",
-                    };
-                }
-            };
+            // ⚡ ULTRA-OPTIMIZED HANDLER - Use specialized builder
+            // This eliminates nested async/await and IIFEs for maximum performance
+            const handler = buildUltraOptimizedHandler({
+                instance,
+                methodName,
+                ControllerClass,
+                params,
+                allGuards,
+                allInterceptors,
+                allPipes,
+                allFilters,
+                httpCode,
+                headers,
+                redirect,
+                routePath: route.path,
+                routeMethod: method.toUpperCase(),
+            });
             // Wrap handler with @Use() middleware if present
             // Combine controller and method middleware
             const allUses = [...controllerUses, ...methodUses];
             let finalHandler = handler;
             if (allUses.length > 0) {
-                console.log(`🔗 Building middleware chain for ${method} ${fullPath}:`);
-                console.log(`   Middleware count: ${allUses.length}`);
-                allUses.forEach((m, i) => console.log(`   [${i}] ${m.name || "anonymous"}`));
-                // Build middleware chain using reduce (O(n) complexity)
-                // Builds from right to left: handler <- middleware[n-1] <- ... <- middleware[0]
-                // Executes left to right: middleware[0] -> ... -> middleware[n-1] -> handler
-                finalHandler = allUses.reduceRight((next, middleware, index) => {
-                    return async (ctx) => {
-                        console.log(`▶️ Executing middleware [${index}]: ${middleware.name || "anonymous"}`);
-                        return await middleware(ctx, () => next(ctx));
-                    };
-                }, handler);
+                finalHandler = buildMiddlewareChain(handler, allUses);
             }
             // Register route with Elysia
             const elysiaOptions = {};
             if (routeOptions.body || bodySchema) {
-                elysiaOptions.body = routeOptions.body || bodySchema;
+                const schema = routeOptions.body || bodySchema;
+                elysiaOptions.body = schema;
+                // Register schema with custom error messages
+                const schemaKey = `${ControllerClass.name}.${methodName}.body`;
+                schemaRegistry.registerSchema(schemaKey, schema);
+                schemaRegistry.registerRoute(method, fullPath, schemaKey, "body");
             }
             if (routeOptions.query) {
                 elysiaOptions.query = routeOptions.query;
+                // Register query schema
+                const schemaKey = `${ControllerClass.name}.${methodName}.query`;
+                schemaRegistry.registerSchema(schemaKey, routeOptions.query);
+                schemaRegistry.registerRoute(method, fullPath, schemaKey, "query");
             }
             if (routeOptions.params) {
                 elysiaOptions.params = routeOptions.params;
+                // Register params schema
+                const schemaKey = `${ControllerClass.name}.${methodName}.params`;
+                schemaRegistry.registerSchema(schemaKey, routeOptions.params);
+                schemaRegistry.registerRoute(method, fullPath, schemaKey, "params");
             }
             if (routeOptions.headers) {
                 elysiaOptions.headers = routeOptions.headers;
@@ -487,6 +509,8 @@ export function createApp(options = {}) {
 export class WynkFactory {
     static create(options = {}) {
         const app = new WynkFramework(options);
+        // Don't re-register providers if they were already added in constructor
+        // The constructor already handles options.providers
         if (options.controllers) {
             app.registerControllers(...options.controllers);
         }

package/dist/filters/exception.filters.d.ts

@@ -0,0 +1,124 @@
+import { NotFoundException, WynkExceptionFilter } from "../decorators/exception.decorators";
+import { ExecutionContext } from "../decorators/guard.decorators";
+/**
+ * Database Exception Filter - Handles database errors ONLY (not HttpExceptions)
+ *
+ * This filter catches actual database errors (like unique constraint violations,
+ * foreign key errors, etc.) and converts them to user-friendly messages.
+ *
+ * It will NOT catch HttpException or its subclasses (ConflictException, etc.)
+ * that you throw manually - those will pass through to be handled correctly.
+ *
+ * @example
+ * // Use as global filter
+ * app.useGlobalFilters(new DatabaseExceptionFilter());
+ *
+ * // Use on specific controller
+ * @UseFilters(DatabaseExceptionFilter)
+ * @Controller('/users')
+ * export class UserController {
+ *   @Post()
+ *   async create(@Body() data: any) {
+ *     // If you throw manually, it passes through:
+ *     if (await this.userExists(data.email)) {
+ *       throw new ConflictException('User with this email already exists'); // ✅ Works correctly
+ *     }
+ *
+ *     // If database throws error, filter catches it:
+ *     return await this.db.insert(users).values(data); // ❌ DB unique constraint error → caught by filter
+ *   }
+ * }
+ *
+ * Handles these database error codes:
+ * - 23505: Unique constraint violation → 409 Conflict
+ * - 23503: Foreign key constraint violation → 400 Bad Request
+ * - 23502: Not null constraint violation → 400 Bad Request
+ */
+export declare class DatabaseExceptionFilter implements WynkExceptionFilter {
+    catch(exception: any, context: ExecutionContext): {
+        statusCode: number;
+        error: string;
+        message: string;
+        timestamp: string;
+        path: any;
+    };
+}
+/**
+ * Not Found Exception Filter - Handles 404 errors with smart detection
+ *
+ * This filter is SMART - it only handles NotFoundExceptionFilter if:
+ * 1. The exception is NotFoundException, AND
+ * 2. No response data has been set (empty, null, empty array, or empty object)
+ *
+ * This allows it to be used globally without breaking routes that return
+ * legitimate empty responses or have their own error handling.
+ *
+ * @example
+ * // ✅ Can be used globally - smart filtering
+ * app.useGlobalFilters(
+ *   new NotFoundExceptionFilter(),  // Safe to use globally now!
+ *   new GlobalExceptionFilter()
+ * );
+ *
+ */
+export declare class NotFoundExceptionFilter implements WynkExceptionFilter<NotFoundException> {
+    catch(exception: NotFoundException, context: ExecutionContext): {
+        statusCode: number;
+        error: string;
+        message: string;
+        timestamp: string;
+        path: any;
+        suggestion: string;
+    };
+    /**
+     * Check if response has meaningful data
+     * Returns false for: null, undefined, {}, [], ""
+     * Returns true for: anything else
+     */
+    private hasResponseData;
+}
+/**
+ * File Upload Exception Filter - Handles file upload errors
+ * @example
+ * @UseFilters(FileUploadExceptionFilter)
+ * @Post('/upload')
+ * async upload(@UploadedFile() file: any) {}
+ */
+export declare class FileUploadExceptionFilter implements WynkExceptionFilter {
+    catch(exception: any, context: ExecutionContext): {
+        statusCode: number;
+        error: string;
+        message: string;
+        timestamp: string;
+        path: any;
+    };
+}
+/**
+ * Global Exception Filter - Catches all unhandled exceptions
+ * @example
+ * app.useGlobalFilters(new GlobalExceptionFilter());
+ */
+export declare class GlobalExceptionFilter implements WynkExceptionFilter {
+    catch(exception: any, context: ExecutionContext): {
+        stack?: any;
+        statusCode: any;
+        error: any;
+        message: any;
+        timestamp: string;
+        path: any;
+    };
+}
+/**
+// ============================================================================
+// KEY TAKEAWAYS
+// ============================================================================
+//
+// 1. Order matters: Specific → General
+// 2. Filters can re-throw exceptions they don't handle
+// 3. HttpException and subclasses should pass through specialized filters
+// 4. Global filters catch everything not handled by controller/method filters
+// 5. Always have a GlobalExceptionFilter as the last filter (catch-all)
+//
+// ============================================================================
+*/
+//# sourceMappingURL=exception.filters.d.ts.map