wynkjs 1.0.0

package/dist/dto.d.ts

@@ -0,0 +1,83 @@
+/**
+ * DTO Utilities for WynkJS Framework
+ * Re-exports Elysia's TypeBox for DTO validation
+ */
+/**
+ * Export Elysia's TypeBox as DTO builder
+ * This provides runtime validation for request bodies, queries, params, etc.
+ *
+ * @example
+ * import { DTO } from '@wynkjs/framework';
+ *
+ * export const CreateUserDTO = DTO.Object({
+ *   name: DTO.String({ minLength: 2, maxLength: 50 }),
+ *   email: DTO.String({ format: 'email' }),
+ *   age: DTO.Optional(DTO.Number({ minimum: 18 })),
+ * });
+ *
+ * @Controller('/users')
+ * export class UserController {
+ *   @Post({ body: CreateUserDTO })
+ *   async create(@Body() data: any) {
+ *     // data is automatically validated against CreateUserDTO
+ *     return { created: data };
+ *   }
+ * }
+ */
+export declare const DTO: any;
+/**
+ * Common DTO patterns for quick use
+ */
+export declare const CommonDTO: {
+    /**
+     * Name validation (2-50 characters)
+     */
+    Name: (options?: {}) => import("@sinclair/typebox").TString;
+    /**
+     * Email validation
+     */
+    Email: (options?: {}) => import("@sinclair/typebox").TString;
+    /**
+     * Password validation (min 6 characters)
+     */
+    Password: (options?: {}) => import("@sinclair/typebox").TString;
+    /**
+     * UUID validation
+     */
+    UUID: (options?: {}) => import("@sinclair/typebox").TString;
+    /**
+     * URL validation
+     */
+    URL: (options?: {}) => import("@sinclair/typebox").TString;
+    /**
+     * Date string validation (ISO 8601)
+     */
+    DateString: (options?: {}) => import("@sinclair/typebox").TString;
+    /**
+     * Phone number (Indian format)
+     */
+    PhoneIN: (options?: {}) => import("@sinclair/typebox").TString;
+    /**
+     * Integer ID
+     */
+    ID: (options?: {}) => import("@sinclair/typebox").TNumber;
+    /**
+     * Pagination query
+     */
+    Pagination: () => import("@sinclair/typebox").TObject<{
+        page: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+        limit: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+    }>;
+    /**
+     * Sort query
+     */
+    Sort: (fields: string[]) => import("@sinclair/typebox").TObject<{
+        sortBy: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnion<import("@sinclair/typebox").TLiteral<string>[]>>;
+        sortOrder: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"asc">, import("@sinclair/typebox").TLiteral<"desc">]>>;
+    }>;
+};
+/**
+ * Export TypeBox types for TypeScript inference
+ */
+export type { TSchema, Static } from "elysia";
+//# sourceMappingURL=dto.d.ts.map

package/dist/dto.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dto.d.ts","sourceRoot":"","sources":["../core/dto.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAIH;;;;;;;;;;;;;;;;;;;;;GAqBG;AAMH,eAAO,MAAM,GAAG,EAAE,GAAO,CAAC;AAE1B;;GAEG;AACH,eAAO,MAAM,SAAS;IACpB;;OAEG;;IAGH;;OAEG;;IAGH;;OAEG;;IAGH;;OAEG;;IAGH;;OAEG;;IAGH;;OAEG;;IAGH;;OAEG;;IAQH;;OAEG;;IAGH;;OAEG;;;;;IAOH;;OAEG;mBACY,MAAM,EAAE;;;;CAKxB,CAAC;AAEF;;GAEG;AACH,YAAY,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC"}

package/dist/dto.js

@@ -0,0 +1,88 @@
+/**
+ * DTO Utilities for WynkJS Framework
+ * Re-exports Elysia's TypeBox for DTO validation
+ */
+import { t } from "elysia";
+/**
+ * Export Elysia's TypeBox as DTO builder
+ * This provides runtime validation for request bodies, queries, params, etc.
+ *
+ * @example
+ * import { DTO } from '@wynkjs/framework';
+ *
+ * export const CreateUserDTO = DTO.Object({
+ *   name: DTO.String({ minLength: 2, maxLength: 50 }),
+ *   email: DTO.String({ format: 'email' }),
+ *   age: DTO.Optional(DTO.Number({ minimum: 18 })),
+ * });
+ *
+ * @Controller('/users')
+ * export class UserController {
+ *   @Post({ body: CreateUserDTO })
+ *   async create(@Body() data: any) {
+ *     // data is automatically validated against CreateUserDTO
+ *     return { created: data };
+ *   }
+ * }
+ */
+// Note: Elysia's type builder exposes internal option types that TypeScript
+// cannot emit in d.ts files (TS4023). To keep declaration generation clean
+// while preserving runtime behavior, we export DTO with an `any` type.
+// Consumers still get runtime validation; for static typing, prefer using
+// `Static<TSchema>` from Elysia which we re-export below.
+export const DTO = t;
+/**
+ * Common DTO patterns for quick use
+ */
+export const CommonDTO = {
+    /**
+     * Name validation (2-50 characters)
+     */
+    Name: (options = {}) => t.String({ minLength: 2, maxLength: 50, ...options }),
+    /**
+     * Email validation
+     */
+    Email: (options = {}) => t.String({ format: "email", ...options }),
+    /**
+     * Password validation (min 6 characters)
+     */
+    Password: (options = {}) => t.String({ minLength: 6, ...options }),
+    /**
+     * UUID validation
+     */
+    UUID: (options = {}) => t.String({ format: "uuid", ...options }),
+    /**
+     * URL validation
+     */
+    URL: (options = {}) => t.String({ format: "uri", ...options }),
+    /**
+     * Date string validation (ISO 8601)
+     */
+    DateString: (options = {}) => t.String({ format: "date-time", ...options }),
+    /**
+     * Phone number (Indian format)
+     */
+    PhoneIN: (options = {}) => t.String({
+        pattern: "^[6-9]{1}[0-9]{9}$",
+        errorMessage: "Invalid mobile number",
+        ...options,
+    }),
+    /**
+     * Integer ID
+     */
+    ID: (options = {}) => t.Number({ minimum: 1, ...options }),
+    /**
+     * Pagination query
+     */
+    Pagination: () => t.Object({
+        page: t.Optional(t.Number({ minimum: 1, default: 1 })),
+        limit: t.Optional(t.Number({ minimum: 1, maximum: 100, default: 10 })),
+    }),
+    /**
+     * Sort query
+     */
+    Sort: (fields) => t.Object({
+        sortBy: t.Optional(t.Union(fields.map((f) => t.Literal(f)))),
+        sortOrder: t.Optional(t.Union([t.Literal("asc"), t.Literal("desc")])),
+    }),
+};

package/dist/factory.d.ts

@@ -0,0 +1,76 @@
+import { Elysia } from "elysia";
+import "reflect-metadata";
+/**
+ * Application Factory for WynkJS Framework
+ * Creates and configures Elysia app with all decorators support
+ */
+export interface ApplicationOptions {
+    cors?: boolean | any;
+    globalPrefix?: string;
+    logger?: boolean;
+}
+export declare class WynkFramework {
+    private app;
+    private controllers;
+    private globalGuards;
+    private globalInterceptors;
+    private globalPipes;
+    private globalFilters;
+    constructor(options?: ApplicationOptions);
+    /**
+     * Static convenience creator to align with documentation examples
+     */
+    static create(options?: ApplicationOptions & {
+        controllers?: any[];
+    }): WynkFramework;
+    /**
+     * Register controllers with the application
+     */
+    registerControllers(...controllers: any[]): this;
+    /**
+     * Register global guards
+     */
+    useGlobalGuards(...guards: any[]): this;
+    /**
+     * Register global interceptors
+     */
+    useGlobalInterceptors(...interceptors: any[]): this;
+    /**
+     * Register global pipes
+     */
+    useGlobalPipes(...pipes: any[]): this;
+    /**
+     * Register global exception filters
+     */
+    useGlobalFilters(...filters: any[]): this;
+    /**
+     * Build the application - register all routes
+     */
+    build(): Promise<Elysia>;
+    /**
+     * Start listening on a port
+     */
+    listen(port: number): Promise<void>;
+    /**
+     * Get the underlying Elysia instance
+     */
+    getApp(): Elysia;
+    /**
+     * Register a single controller
+     */
+    private registerController;
+}
+/**
+ * Factory function to create a new application
+ */
+export declare function createApp(options?: ApplicationOptions): WynkFramework;
+/**
+ * Alias for WynkFramework with static create method
+ */
+export declare class WynkFactory {
+    static create(options?: ApplicationOptions & {
+        controllers?: any[];
+    }): WynkFramework;
+}
+export { WynkFramework as ElysiaFramework };
+//# sourceMappingURL=factory.d.ts.map

package/dist/factory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"factory.d.ts","sourceRoot":"","sources":["../core/factory.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAChC,OAAO,kBAAkB,CAAC;AAc1B;;;GAGG;AAEH,MAAM,WAAW,kBAAkB;IACjC,IAAI,CAAC,EAAE,OAAO,GAAG,GAAG,CAAC;IACrB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB;AAED,qBAAa,aAAa;IACxB,OAAO,CAAC,GAAG,CAAS;IACpB,OAAO,CAAC,WAAW,CAAa;IAChC,OAAO,CAAC,YAAY,CAAa;IACjC,OAAO,CAAC,kBAAkB,CAAa;IACvC,OAAO,CAAC,WAAW,CAAa;IAChC,OAAO,CAAC,aAAa,CAAa;gBAEtB,OAAO,GAAE,kBAAuB;IAgB5C;;OAEG;IACH,MAAM,CAAC,MAAM,CACX,OAAO,GAAE,kBAAkB,GAAG;QAAE,WAAW,CAAC,EAAE,GAAG,EAAE,CAAA;KAAO,GACzD,aAAa;IAQhB;;OAEG;IACH,mBAAmB,CAAC,GAAG,WAAW,EAAE,GAAG,EAAE,GAAG,IAAI;IAKhD;;OAEG;IACH,eAAe,CAAC,GAAG,MAAM,EAAE,GAAG,EAAE,GAAG,IAAI;IAKvC;;OAEG;IACH,qBAAqB,CAAC,GAAG,YAAY,EAAE,GAAG,EAAE,GAAG,IAAI;IAKnD;;OAEG;IACH,cAAc,CAAC,GAAG,KAAK,EAAE,GAAG,EAAE,GAAG,IAAI;IAKrC;;OAEG;IACH,gBAAgB,CAAC,GAAG,OAAO,EAAE,GAAG,EAAE,GAAG,IAAI;IAKzC;;OAEG;IACG,KAAK,IAAI,OAAO,CAAC,MAAM,CAAC;IAkD9B;;OAEG;IACG,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAMzC;;OAEG;IACH,MAAM,IAAI,MAAM;IAIhB;;OAEG;YACW,kBAAkB;CAuVjC;AAED;;GAEG;AACH,wBAAgB,SAAS,CAAC,OAAO,GAAE,kBAAuB,GAAG,aAAa,CAEzE;AAED;;GAEG;AACH,qBAAa,WAAW;IACtB,MAAM,CAAC,MAAM,CACX,OAAO,GAAE,kBAAkB,GAAG;QAAE,WAAW,CAAC,EAAE,GAAG,EAAE,CAAA;KAAO,GACzD,aAAa;CASjB;AAGD,OAAO,EAAE,aAAa,IAAI,eAAe,EAAE,CAAC"}

package/dist/factory.js

@@ -0,0 +1,410 @@
+import { Elysia } from "elysia";
+import "reflect-metadata";
+import { container } from "tsyringe";
+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";
+export class WynkFramework {
+    app;
+    controllers = [];
+    globalGuards = [];
+    globalInterceptors = [];
+    globalPipes = [];
+    globalFilters = [];
+    constructor(options = {}) {
+        this.app = new Elysia();
+        // Apply CORS if enabled
+        if (options.cors) {
+            // CORS configuration would go here
+        }
+        // Apply global prefix if specified
+        if (options.globalPrefix) {
+            // Global prefix handling
+        }
+        return this;
+    }
+    /**
+     * Static convenience creator to align with documentation examples
+     */
+    static create(options = {}) {
+        const app = new WynkFramework(options);
+        if (options.controllers && options.controllers.length) {
+            app.registerControllers(...options.controllers);
+        }
+        return app;
+    }
+    /**
+     * Register controllers with the application
+     */
+    registerControllers(...controllers) {
+        this.controllers.push(...controllers);
+        return this;
+    }
+    /**
+     * Register global guards
+     */
+    useGlobalGuards(...guards) {
+        this.globalGuards.push(...guards);
+        return this;
+    }
+    /**
+     * Register global interceptors
+     */
+    useGlobalInterceptors(...interceptors) {
+        this.globalInterceptors.push(...interceptors);
+        return this;
+    }
+    /**
+     * Register global pipes
+     */
+    useGlobalPipes(...pipes) {
+        this.globalPipes.push(...pipes);
+        return this;
+    }
+    /**
+     * Register global exception filters
+     */
+    useGlobalFilters(...filters) {
+        this.globalFilters.push(...filters);
+        return this;
+    }
+    /**
+     * Build the application - register all routes
+     */
+    async build() {
+        // Register global error handler if filters exist
+        if (this.globalFilters.length > 0) {
+            this.app.onError(async ({ error, set, request }) => {
+                console.log("🔴 ELYSIA ON_ERROR HOOK TRIGGERED");
+                console.log("Error:", error?.message || String(error));
+                console.log("Global filters:", this.globalFilters.length);
+                // Create a simple execution context
+                const executionContext = {
+                    getRequest: () => request,
+                    getResponse: () => set,
+                    getContext: () => ({ request, set }),
+                    getHandler: () => null,
+                    getClass: () => null,
+                };
+                try {
+                    const result = await executeExceptionFilters(this.globalFilters, error, executionContext);
+                    if (result) {
+                        if (result.statusCode) {
+                            set.status = result.statusCode;
+                        }
+                        return result;
+                    }
+                }
+                catch (filterError) {
+                    console.error("Filter error:", filterError);
+                }
+                // Fallback error handling
+                set.status = 500;
+                return {
+                    statusCode: 500,
+                    message: error?.message || "Internal server error",
+                    error: "Internal Server Error",
+                };
+            });
+        }
+        for (const ControllerClass of this.controllers) {
+            await this.registerController(ControllerClass);
+        }
+        return this.app;
+    }
+    /**
+     * Start listening on a port
+     */
+    async listen(port) {
+        await this.build();
+        this.app.listen(port);
+        console.log(`🚀 Application is running on http://localhost:${port}`);
+    }
+    /**
+     * Get the underlying Elysia instance
+     */
+    getApp() {
+        return this.app;
+    }
+    /**
+     * Register a single controller
+     */
+    async registerController(ControllerClass) {
+        // Use tsyringe container to resolve controller with all dependencies
+        const instance = container.resolve(ControllerClass);
+        const basePath = Reflect.getMetadata("basePath", ControllerClass) || "";
+        // Try reading from multiple locations
+        const routes1 = Reflect.getMetadata("routes", ControllerClass) || [];
+        const routes2 = Reflect.getMetadata("routes", ControllerClass.prototype) || [];
+        const routes3 = Reflect.getMetadata("controller:routes", instance) || [];
+        console.log(`🔍 Routes on ControllerClass: ${routes1.length}`);
+        console.log(`🔍 Routes on prototype: ${routes2.length}`);
+        console.log(`🔍 Routes on instance: ${routes3.length}`);
+        const routes = routes1.length > 0 ? routes1 : routes2.length > 0 ? routes2 : routes3;
+        console.log(`📦 Registering controller ${ControllerClass.name} with ${routes.length} routes`);
+        const controllerGuards = Reflect.getMetadata("guards", ControllerClass) || [];
+        const controllerInterceptors = Reflect.getMetadata("interceptors", ControllerClass) || [];
+        const controllerPipes = Reflect.getMetadata("pipes", ControllerClass) || [];
+        const controllerFilters = Reflect.getMetadata("filters", ControllerClass) || [];
+        // 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;
+            const method = route.method.toLowerCase();
+            const methodName = route.methodName;
+            // Get method-specific metadata
+            const methodGuards = Reflect.getMetadata("guards", instance, methodName) || [];
+            const methodInterceptors = Reflect.getMetadata("interceptors", instance, methodName) || [];
+            const methodPipes = Reflect.getMetadata("pipes", instance, methodName) || [];
+            const methodFilters = Reflect.getMetadata("filters", instance, methodName) || [];
+            // Get @Use() middleware for this method
+            const methodUses = Reflect.getMetadata("uses", instance, methodName) || [];
+            const params = Reflect.getMetadata("params", instance, methodName) || [];
+            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)
+            const allGuards = [
+                ...this.globalGuards,
+                ...controllerGuards,
+                ...methodGuards,
+            ];
+            const allInterceptors = [
+                ...this.globalInterceptors,
+                ...controllerInterceptors,
+                ...methodInterceptors,
+            ];
+            const allPipes = [
+                ...this.globalPipes,
+                ...controllerPipes,
+                ...methodPipes,
+            ];
+            const allFilters = [
+                ...this.globalFilters,
+                ...controllerFilters,
+                ...methodFilters,
+            ];
+            // Get route options (for body validation schema)
+            const routeOptions = route.options || {};
+            const bodySchema = Reflect.getMetadata("route:bodySchema", instance, methodName);
+            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",
+                    };
+                }
+            };
+            // 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);
+            }
+            // Register route with Elysia
+            const elysiaOptions = {};
+            if (routeOptions.body || bodySchema) {
+                elysiaOptions.body = routeOptions.body || bodySchema;
+            }
+            if (routeOptions.query) {
+                elysiaOptions.query = routeOptions.query;
+            }
+            if (routeOptions.params) {
+                elysiaOptions.params = routeOptions.params;
+            }
+            if (routeOptions.headers) {
+                elysiaOptions.headers = routeOptions.headers;
+            }
+            // Register with options if any validation schemas are present
+            if (Object.keys(elysiaOptions).length > 0) {
+                this.app[method](fullPath, finalHandler, elysiaOptions);
+            }
+            else {
+                this.app[method](fullPath, finalHandler);
+            }
+        }
+    }
+}
+/**
+ * Factory function to create a new application
+ */
+export function createApp(options = {}) {
+    return new WynkFramework(options);
+}
+/**
+ * Alias for WynkFramework with static create method
+ */
+export class WynkFactory {
+    static create(options = {}) {
+        const app = new WynkFramework(options);
+        if (options.controllers) {
+            app.registerControllers(...options.controllers);
+        }
+        return app;
+    }
+}
+// Export ElysiaFramework as alias for backwards compatibility
+export { WynkFramework as ElysiaFramework };