wynkjs 1.0.4 → 1.0.7

package/dist/global-prefix.d.ts

@@ -0,0 +1,49 @@
+import { Elysia } from "elysia";
+/**
+ * Global Prefix Module for WynkJS Framework
+ * Adds a prefix to all routes in the application
+ * Separated from factory.ts for better maintainability
+ */
+export interface GlobalPrefixOptions {
+    prefix: string;
+    exclude?: string[];
+}
+/**
+ * Apply global prefix to all routes
+ * @param app - Elysia instance
+ * @param prefix - Prefix string (e.g., '/api', '/v1')
+ * @param options - Additional options like route exclusions
+ * @returns Modified Elysia instance
+ */
+export declare function applyGlobalPrefix(app: Elysia, prefix: string | GlobalPrefixOptions): any;
+/**
+ * Normalize prefix path
+ * - Ensures it starts with /
+ * - Removes trailing /
+ * - Validates format
+ * @param prefix - Raw prefix string
+ * @returns Normalized prefix
+ */
+export declare function normalizePrefixPath(prefix: string): string;
+/**
+ * Check if a route should be excluded from global prefix
+ * @param path - Route path
+ * @param excludedRoutes - List of routes to exclude
+ * @returns true if route should be excluded
+ */
+export declare function isRouteExcluded(path: string, excludedRoutes: string[]): boolean;
+/**
+ * Apply global prefix to an existing Elysia app by wrapping it
+ * This is useful when you want to add prefix to already configured app
+ * @param app - Existing Elysia instance
+ * @param prefix - Prefix to apply
+ * @returns New Elysia instance with prefix
+ */
+export declare function wrapWithPrefix(app: Elysia, prefix: string | GlobalPrefixOptions): any;
+/**
+ * Validate global prefix configuration
+ * @param prefix - Prefix configuration
+ * @returns true if valid, throws error if invalid
+ */
+export declare function validateGlobalPrefix(prefix: string | GlobalPrefixOptions): boolean;
+//# sourceMappingURL=global-prefix.d.ts.map

package/dist/global-prefix.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"global-prefix.d.ts","sourceRoot":"","sources":["../core/global-prefix.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAEhC;;;;GAIG;AAEH,MAAM,WAAW,mBAAmB;IAClC,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;CACpB;AAED;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAC/B,GAAG,EAAE,MAAM,EACX,MAAM,EAAE,MAAM,GAAG,mBAAmB,GACnC,GAAG,CAkCL;AAED;;;;;;;GAOG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CA0B1D;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAC7B,IAAI,EAAE,MAAM,EACZ,cAAc,EAAE,MAAM,EAAE,GACvB,OAAO,CAuBT;AAED;;;;;;GAMG;AACH,wBAAgB,cAAc,CAC5B,GAAG,EAAE,MAAM,EACX,MAAM,EAAE,MAAM,GAAG,mBAAmB,GACnC,GAAG,CA0BL;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,CAClC,MAAM,EAAE,MAAM,GAAG,mBAAmB,GACnC,OAAO,CA2CT"}

package/dist/global-prefix.js

@@ -0,0 +1,155 @@
+import { Elysia } from "elysia";
+/**
+ * Apply global prefix to all routes
+ * @param app - Elysia instance
+ * @param prefix - Prefix string (e.g., '/api', '/v1')
+ * @param options - Additional options like route exclusions
+ * @returns Modified Elysia instance
+ */
+export function applyGlobalPrefix(app, prefix) {
+    // Normalize prefix
+    let prefixStr;
+    let excludedRoutes = [];
+    if (typeof prefix === "string") {
+        prefixStr = prefix;
+    }
+    else {
+        prefixStr = prefix.prefix;
+        excludedRoutes = prefix.exclude || [];
+    }
+    // Validate and normalize prefix
+    prefixStr = normalizePrefixPath(prefixStr);
+    if (!prefixStr) {
+        console.warn("⚠️  Global prefix is empty after normalization. Skipping prefix setup.");
+        return app;
+    }
+    // Create a new Elysia instance with the prefix
+    const prefixedApp = new Elysia({ prefix: prefixStr });
+    // Note: Elysia's prefix option automatically applies to all routes
+    // registered on this instance. We'll return the prefixed instance.
+    console.log(`✅ Global prefix applied: ${prefixStr}`);
+    if (excludedRoutes.length > 0) {
+        console.log(`   Excluded routes: ${excludedRoutes.join(", ")}`);
+    }
+    return prefixedApp;
+}
+/**
+ * Normalize prefix path
+ * - Ensures it starts with /
+ * - Removes trailing /
+ * - Validates format
+ * @param prefix - Raw prefix string
+ * @returns Normalized prefix
+ */
+export function normalizePrefixPath(prefix) {
+    if (!prefix) {
+        return "";
+    }
+    let normalized = prefix.trim();
+    // Ensure starts with /
+    if (!normalized.startsWith("/")) {
+        normalized = "/" + normalized;
+    }
+    // Remove trailing /
+    if (normalized.endsWith("/") && normalized.length > 1) {
+        normalized = normalized.slice(0, -1);
+    }
+    // Validate format (no spaces, no special chars except /, -, _)
+    const validPattern = /^\/[\w\-\/]*$/;
+    if (!validPattern.test(normalized)) {
+        throw new Error(`Invalid global prefix format: "${prefix}". Only alphanumeric, hyphens, underscores, and forward slashes are allowed.`);
+    }
+    return normalized;
+}
+/**
+ * Check if a route should be excluded from global prefix
+ * @param path - Route path
+ * @param excludedRoutes - List of routes to exclude
+ * @returns true if route should be excluded
+ */
+export function isRouteExcluded(path, excludedRoutes) {
+    if (!excludedRoutes || excludedRoutes.length === 0) {
+        return false;
+    }
+    // Normalize the path
+    const normalizedPath = path.startsWith("/") ? path : "/" + path;
+    // Check for exact match or wildcard match
+    return excludedRoutes.some((excluded) => {
+        // Exact match
+        if (excluded === normalizedPath) {
+            return true;
+        }
+        // Wildcard match (e.g., '/health/*')
+        if (excluded.endsWith("/*")) {
+            const base = excluded.slice(0, -2);
+            return normalizedPath.startsWith(base);
+        }
+        return false;
+    });
+}
+/**
+ * Apply global prefix to an existing Elysia app by wrapping it
+ * This is useful when you want to add prefix to already configured app
+ * @param app - Existing Elysia instance
+ * @param prefix - Prefix to apply
+ * @returns New Elysia instance with prefix
+ */
+export function wrapWithPrefix(app, prefix) {
+    let prefixStr;
+    let excludedRoutes = [];
+    if (typeof prefix === "string") {
+        prefixStr = prefix;
+    }
+    else {
+        prefixStr = prefix.prefix;
+        excludedRoutes = prefix.exclude || [];
+    }
+    prefixStr = normalizePrefixPath(prefixStr);
+    // Create wrapper app with prefix
+    const wrapper = new Elysia();
+    // Mount the original app under the prefix
+    wrapper.use(new Elysia({
+        prefix: prefixStr,
+    }).use(app));
+    console.log(`✅ Wrapped existing app with prefix: ${prefixStr}`);
+    return wrapper;
+}
+/**
+ * Validate global prefix configuration
+ * @param prefix - Prefix configuration
+ * @returns true if valid, throws error if invalid
+ */
+export function validateGlobalPrefix(prefix) {
+    if (typeof prefix === "string") {
+        // Validate string prefix
+        if (prefix.length === 0) {
+            throw new Error("Global prefix cannot be an empty string");
+        }
+        normalizePrefixPath(prefix); // This will throw if invalid
+        return true;
+    }
+    if (typeof prefix === "object" && prefix !== null) {
+        // Validate object prefix
+        if (!prefix.prefix) {
+            throw new Error("GlobalPrefixOptions must have a 'prefix' property");
+        }
+        if (typeof prefix.prefix !== "string") {
+            throw new Error("Global prefix must be a string");
+        }
+        normalizePrefixPath(prefix.prefix); // This will throw if invalid
+        // Validate exclude array
+        if (prefix.exclude !== undefined) {
+            if (!Array.isArray(prefix.exclude)) {
+                throw new Error("GlobalPrefixOptions.exclude must be an array");
+            }
+            // Validate each excluded route
+            prefix.exclude.forEach((route) => {
+                if (typeof route !== "string") {
+                    throw new Error("All routes in GlobalPrefixOptions.exclude must be strings");
+                }
+            });
+        }
+        return true;
+    }
+    throw new Error("Global prefix must be string or GlobalPrefixOptions object");
+}

package/dist/index.d.ts

@@ -23,6 +23,12 @@ export * from "./decorators/database.decorators";
 export * from "./dto";
 export { schemaRegistry } from "./schema-registry";
 export * from "./factory";
+export type { CorsOptions } from "./cors";
+export { setupCors, validateCorsOptions } from "./cors";
+export type { GlobalPrefixOptions } from "./global-prefix";
+export { applyGlobalPrefix, normalizePrefixPath, validateGlobalPrefix, wrapWithPrefix, } from "./global-prefix";
+export { compression } from "./plugins/compression";
+export type { CompressionOptions } from "./plugins/compression";
 export * from "./testing";
 /**
  * Framework version

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../core/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAIH,OAAO,kBAAkB,CAAC;AAI1B,OAAO,EACL,UAAU,EACV,MAAM,EACN,SAAS,EACT,cAAc,EACd,QAAQ,EACR,SAAS,GACV,MAAM,UAAU,CAAC;AAClB,YAAY,EAAE,mBAAmB,EAAE,MAAM,UAAU,CAAC;AAGpD,OAAO,EACL,UAAU,IAAI,UAAU,EACxB,MAAM,IAAI,MAAM,EAChB,SAAS,IAAI,SAAS,EACtB,cAAc,IAAI,cAAc,EAChC,QAAQ,IAAI,QAAQ,EACpB,SAAS,IAAI,SAAS,GACvB,MAAM,UAAU,CAAC;AAGlB,cAAc,8BAA8B,CAAC;AAG7C,cAAc,+BAA+B,CAAC;AAG9C,cAAc,+BAA+B,CAAC;AAG9C,cAAc,qCAAqC,CAAC;AACpD,cAAc,mCAAmC,CAAC;AAGlD,cAAc,8BAA8B,CAAC;AAC7C,cAAc,4BAA4B,CAAC;AAI3C,cAAc,mCAAmC,CAAC;AAClD,cAAc,mCAAmC,CAAC;AAClD,cAAc,6BAA6B,CAAC;AAI5C,cAAc,kCAAkC,CAAC;AASjD,cAAc,OAAO,CAAC;AAGtB,OAAO,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAGnD,cAAc,WAAW,CAAC;AAG1B,cAAc,WAAW,CAAC;AAE1B;;GAEG;AACH,eAAO,MAAM,OAAO,UAAU,CAAC;AAE/B;;GAEG;AACH,eAAO,MAAM,cAAc,qBAAqB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../core/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAIH,OAAO,kBAAkB,CAAC;AAI1B,OAAO,EACL,UAAU,EACV,MAAM,EACN,SAAS,EACT,cAAc,EACd,QAAQ,EACR,SAAS,GACV,MAAM,UAAU,CAAC;AAClB,YAAY,EAAE,mBAAmB,EAAE,MAAM,UAAU,CAAC;AAGpD,OAAO,EACL,UAAU,IAAI,UAAU,EACxB,MAAM,IAAI,MAAM,EAChB,SAAS,IAAI,SAAS,EACtB,cAAc,IAAI,cAAc,EAChC,QAAQ,IAAI,QAAQ,EACpB,SAAS,IAAI,SAAS,GACvB,MAAM,UAAU,CAAC;AAGlB,cAAc,8BAA8B,CAAC;AAG7C,cAAc,+BAA+B,CAAC;AAG9C,cAAc,+BAA+B,CAAC;AAG9C,cAAc,qCAAqC,CAAC;AACpD,cAAc,mCAAmC,CAAC;AAGlD,cAAc,8BAA8B,CAAC;AAC7C,cAAc,4BAA4B,CAAC;AAI3C,cAAc,mCAAmC,CAAC;AAClD,cAAc,mCAAmC,CAAC;AAClD,cAAc,6BAA6B,CAAC;AAI5C,cAAc,kCAAkC,CAAC;AASjD,cAAc,OAAO,CAAC;AAGtB,OAAO,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAGnD,cAAc,WAAW,CAAC;AAG1B,YAAY,EAAE,WAAW,EAAE,MAAM,QAAQ,CAAC;AAC1C,OAAO,EAAE,SAAS,EAAE,mBAAmB,EAAE,MAAM,QAAQ,CAAC;AAGxD,YAAY,EAAE,mBAAmB,EAAE,MAAM,iBAAiB,CAAC;AAC3D,OAAO,EACL,iBAAiB,EACjB,mBAAmB,EACnB,oBAAoB,EACpB,cAAc,GACf,MAAM,iBAAiB,CAAC;AAGzB,OAAO,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AACpD,YAAY,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAGhE,cAAc,WAAW,CAAC;AAE1B;;GAEG;AACH,eAAO,MAAM,OAAO,UAAU,CAAC;AAE/B;;GAEG;AACH,eAAO,MAAM,cAAc,qBAAqB,CAAC"}

package/dist/index.js

@@ -44,6 +44,10 @@ export * from "./dto";
 export { schemaRegistry } from "./schema-registry";
 // Application Factory
 export * from "./factory";
+export { setupCors, validateCorsOptions } from "./cors";
+export { applyGlobalPrefix, normalizePrefixPath, validateGlobalPrefix, wrapWithPrefix, } from "./global-prefix";
+// Plugins
+export { compression } from "./plugins/compression";
 // Testing Module
 export * from "./testing";
 /**

package/dist/interfaces/interceptor.interface.d.ts

@@ -0,0 +1,15 @@
+export interface InterceptorContext {
+    getRequest<T = any>(): T;
+    getResponse<T = any>(): T;
+    getContext<T = any>(): T;
+    getHandler(): Function;
+    getClass(): any;
+    request?: any;
+    body?: any;
+    params?: any;
+    query?: any;
+    headers?: any;
+    path?: string;
+    method?: string;
+}
+//# sourceMappingURL=interceptor.interface.d.ts.map

package/dist/interfaces/interceptor.interface.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"interceptor.interface.d.ts","sourceRoot":"","sources":["../../core/interfaces/interceptor.interface.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,kBAAkB;IACjC,UAAU,CAAC,CAAC,GAAG,GAAG,KAAK,CAAC,CAAC;IACzB,WAAW,CAAC,CAAC,GAAG,GAAG,KAAK,CAAC,CAAC;IAC1B,UAAU,CAAC,CAAC,GAAG,GAAG,KAAK,CAAC,CAAC;IACzB,UAAU,IAAI,QAAQ,CAAC;IACvB,QAAQ,IAAI,GAAG,CAAC;IAEhB,OAAO,CAAC,EAAE,GAAG,CAAC;IACd,IAAI,CAAC,EAAE,GAAG,CAAC;IACX,MAAM,CAAC,EAAE,GAAG,CAAC;IACb,KAAK,CAAC,EAAE,GAAG,CAAC;IACZ,OAAO,CAAC,EAAE,GAAG,CAAC;IAEd,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB"}

package/dist/interfaces/interceptor.interface.js

@@ -0,0 +1 @@
+export {};

package/dist/optimized-handler.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Optimized Handler Builder for WynkJS
+ * Builds route handlers conditionally - only adds overhead when features are actually used
+ */
+import { ParamMetadata } from "./decorators/param.decorators";
+export interface HandlerBuildOptions {
+    instance: any;
+    methodName: string;
+    ControllerClass: any;
+    params: ParamMetadata[];
+    allGuards: any[];
+    allInterceptors: any[];
+    allPipes: any[];
+    allFilters: any[];
+    httpCode?: number;
+    headers?: Record<string, string>;
+    redirect?: {
+        url: string;
+        statusCode: number;
+    };
+}
+/**
+ * Build optimized handler - only include overhead when features are used
+ * This eliminates conditional checks on every request for unused features
+ */
+export declare function buildOptimizedHandler(options: HandlerBuildOptions): (ctx: any) => Promise<any>;
+/**
+ * Build middleware chain - only if middleware exists
+ */
+export declare function buildMiddlewareChain(handler: (ctx: any) => Promise<any>, middlewares: any[]): (ctx: any) => Promise<any>;
+//# sourceMappingURL=optimized-handler.d.ts.map

package/dist/optimized-handler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"optimized-handler.d.ts","sourceRoot":"","sources":["../core/optimized-handler.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAYH,OAAO,EAAE,aAAa,EAAE,MAAM,+BAA+B,CAAC;AAE9D,MAAM,WAAW,mBAAmB;IAClC,QAAQ,EAAE,GAAG,CAAC;IACd,UAAU,EAAE,MAAM,CAAC;IACnB,eAAe,EAAE,GAAG,CAAC;IACrB,MAAM,EAAE,aAAa,EAAE,CAAC;IACxB,SAAS,EAAE,GAAG,EAAE,CAAC;IACjB,eAAe,EAAE,GAAG,EAAE,CAAC;IACvB,QAAQ,EAAE,GAAG,EAAE,CAAC;IAChB,UAAU,EAAE,GAAG,EAAE,CAAC;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACjC,QAAQ,CAAC,EAAE;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAA;KAAE,CAAC;CAChD;AAED;;;GAGG;AACH,wBAAgB,qBAAqB,CACnC,OAAO,EAAE,mBAAmB,GAC3B,CAAC,GAAG,EAAE,GAAG,KAAK,OAAO,CAAC,GAAG,CAAC,CAyM5B;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAClC,OAAO,EAAE,CAAC,GAAG,EAAE,GAAG,KAAK,OAAO,CAAC,GAAG,CAAC,EACnC,WAAW,EAAE,GAAG,EAAE,GACjB,CAAC,GAAG,EAAE,GAAG,KAAK,OAAO,CAAC,GAAG,CAAC,CAW5B"}

package/dist/optimized-handler.js

@@ -0,0 +1,180 @@
+/**
+ * Optimized Handler Builder for WynkJS
+ * Builds route handlers conditionally - only adds overhead when features are actually used
+ */
+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";
+/**
+ * Build optimized handler - only include overhead when features are used
+ * This eliminates conditional checks on every request for unused features
+ */
+export function buildOptimizedHandler(options) {
+    const { instance, methodName, ControllerClass, params, allGuards, allInterceptors, allPipes, allFilters, httpCode, headers, redirect, } = options;
+    // Pre-sort params once during registration (not on every request)
+    if (params.length > 0) {
+        params.sort((a, b) => a.index - b.index);
+    }
+    // Base parameter extractor and method executor
+    const extractParamsAndExecute = async (ctx) => {
+        if (params.length === 0) {
+            // No parameter decorators - pass full context
+            return await instance[methodName](ctx);
+        }
+        // Build arguments array
+        const args = new Array(params.length);
+        for (const param of params) {
+            let value;
+            // Extract value based on type (optimized switch)
+            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) {
+                        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 parameter-specific pipes
+            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;
+        }
+        return await instance[methodName].apply(instance, args);
+    };
+    // Build handler layers conditionally
+    let handler = extractParamsAndExecute;
+    // Wrap with interceptors (only if they exist)
+    if (allInterceptors.length > 0) {
+        const prevHandler = handler;
+        handler = async (ctx) => {
+            const executionContext = createExecutionContext(ctx, instance[methodName], ControllerClass);
+            return await executeInterceptors(allInterceptors, executionContext, () => prevHandler(ctx));
+        };
+    }
+    // Wrap with guards (only if they exist)
+    if (allGuards.length > 0) {
+        const prevHandler = handler;
+        handler = async (ctx) => {
+            const executionContext = createExecutionContext(ctx, instance[methodName], ControllerClass);
+            const canActivate = await executeGuards(allGuards, executionContext);
+            if (!canActivate) {
+                throw new HttpException("Forbidden", 403, "Access denied");
+            }
+            return await prevHandler(ctx);
+        };
+    }
+    // Final handler with response modifications
+    const finalHandler = async (ctx) => {
+        try {
+            const result = await handler(ctx);
+            // Handle redirect (if configured)
+            if (redirect) {
+                ctx.set.redirect = redirect.url;
+                ctx.set.status = redirect.statusCode;
+                return;
+            }
+            // Set custom HTTP code (if configured)
+            if (httpCode) {
+                ctx.set.status = httpCode;
+            }
+            // Set custom headers (if configured)
+            if (headers) {
+                Object.entries(headers).forEach(([key, value]) => {
+                    ctx.set.headers[key] = value;
+                });
+            }
+            return result;
+        }
+        catch (error) {
+            // Execute exception filters (only if they exist)
+            if (allFilters.length > 0) {
+                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) {
+                    error = filterError;
+                }
+            }
+            // Default error handling
+            if (error instanceof HttpException) {
+                ctx.set.status = error.getStatus();
+                return error.getResponse();
+            }
+            ctx.set.status = 500;
+            return {
+                statusCode: 500,
+                message: error.message || "Internal server error",
+                error: "Internal Server Error",
+            };
+        }
+    };
+    return finalHandler;
+}
+/**
+ * Build middleware chain - only if middleware exists
+ */
+export function buildMiddlewareChain(handler, middlewares) {
+    if (middlewares.length === 0) {
+        return handler;
+    }
+    // Build middleware chain (removed console.log for performance)
+    return middlewares.reduceRight((next, middleware) => {
+        return async (ctx) => {
+            return await middleware(ctx, () => next(ctx));
+        };
+    }, handler);
+}

package/dist/pipes/validation.pipe.d.ts

@@ -15,9 +15,9 @@ export interface ArgumentMetadata {
     data?: string;
 }
 /**
- * Validation Error structure (Elysia format)
+ * Validation Error structure (WynkJS format)
  */
-export interface ElysiaValidationError {
+export interface WynkJSValidationError {
     type: "validation";
     on: "body" | "params" | "query" | "headers";
     property: string;
@@ -36,36 +36,36 @@ export interface ElysiaValidationError {
 }
 /**
  * Base Validation Pipe
- * Handles Elysia validation errors and formats them
+ * Handles WynkJS validation errors and formats them
  */
 export declare class ValidationPipe implements ValidationPipeTransform {
     protected options: {
-        exceptionFactory?: (errors: ElysiaValidationError) => any;
+        exceptionFactory?: (errors: WynkJSValidationError) => any;
         transform?: boolean;
         whitelist?: boolean;
     };
     constructor(options?: {
-        exceptionFactory?: (errors: ElysiaValidationError) => any;
+        exceptionFactory?: (errors: WynkJSValidationError) => any;
         transform?: boolean;
         whitelist?: boolean;
     });
     /**
-     * Transform method (not used for Elysia validation, but required by interface)
+     * Transform method (not used for WynkJS validation, but required by interface)
      */
     transform(value: any, metadata: ArgumentMetadata): any;
     /**
-     * Format Elysia validation error
+     * Format WynkJS validation error
      * This is called by the exception filter
      */
     formatError(exception: any): any;
     /**
-     * Parse Elysia validation error from exception
+     * Parse WynkJS validation error from exception
      */
-    protected parseValidationError(exception: any): ElysiaValidationError;
+    protected parseValidationError(exception: any): WynkJSValidationError;
     /**
      * Default error formatting with custom errorMessage support
      */
-    protected defaultFormatError(error: ElysiaValidationError, schemaKey?: string): any;
+    protected defaultFormatError(error: WynkJSValidationError, schemaKey?: string): any;
 }
 /**
  * Custom Format Error Pipe

package/dist/pipes/validation.pipe.js

@@ -2,7 +2,7 @@ import "reflect-metadata";
 import { schemaRegistry } from "../schema-registry";
 /**
  * Base Validation Pipe
- * Handles Elysia validation errors and formats them
+ * Handles WynkJS validation errors and formats them
  */
 export class ValidationPipe {
     options;
@@ -10,13 +10,13 @@ export class ValidationPipe {
         this.options = options || {};
     }
     /**
-     * Transform method (not used for Elysia validation, but required by interface)
+     * Transform method (not used for WynkJS validation, but required by interface)
      */
     transform(value, metadata) {
         return value;
     }
     /**
-     * Format Elysia validation error
+     * Format WynkJS validation error
      * This is called by the exception filter
      */
     formatError(exception) {
@@ -30,7 +30,7 @@ export class ValidationPipe {
         return this.defaultFormatError(validationError);
     }
     /**
-     * Parse Elysia validation error from exception
+     * Parse WynkJS validation error from exception
      */
     parseValidationError(exception) {
         let validationData;

package/dist/plugins/compression.d.ts

@@ -0,0 +1,75 @@
+/**
+ * Compression Plugin Options
+ */
+export interface CompressionOptions {
+    /**
+     * Minimum byte size for compression
+     * @default 1024
+     */
+    threshold?: number;
+    /**
+     * Preferred encoding order (first match will be used)
+     * @default ["br", "gzip", "deflate"]
+     */
+    encodings?: ("br" | "gzip" | "deflate")[];
+    /**
+     * Brotli compression options
+     */
+    brotliOptions?: {
+        params?: Record<number, number>;
+    };
+    /**
+     * Zlib (gzip/deflate) compression options
+     */
+    zlibOptions?: {
+        level?: number;
+        memLevel?: number;
+        strategy?: number;
+    };
+}
+/**
+ * Compression Plugin for WynkJS
+ *
+ * @example
+ * ```typescript
+ * import { WynkFactory } from "wynkjs";
+ * import { compression } from "wynkjs/plugins/compression";
+ *
+ * const app = WynkFactory.create({
+ *   controllers: [UserController],
+ * });
+ *
+ * // Add compression middleware
+ * app.use(compression({
+ *   threshold: 1024,
+ *   encodings: ["br", "gzip", "deflate"]
+ * }));
+ *
+ * await app.listen(3000);
+ * ```
+ */
+/**
+ * Compression Plugin for WynkJS
+ *
+ * Simple compression middleware using Elysia's onAfterHandle hook
+ * Supports Brotli, Gzip, and Deflate compression
+ *
+ * @example
+ * ```typescript
+ * import { WynkFactory, compression } from "wynkjs";
+ *
+ * const app = WynkFactory.create({
+ *   controllers: [UserController],
+ * });
+ *
+ * // Add compression middleware
+ * app.use(compression({
+ *   threshold: 1024,
+ *   encodings: ["gzip", "br"]
+ * }));
+ *
+ * await app.listen(3000);
+ * ```
+ */
+export declare function compression(options?: CompressionOptions): (app: any) => any;
+//# sourceMappingURL=compression.d.ts.map

package/dist/plugins/compression.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compression.d.ts","sourceRoot":"","sources":["../../core/plugins/compression.ts"],"names":[],"mappings":"AAEA;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC;;;OAGG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IAEnB;;;OAGG;IACH,SAAS,CAAC,EAAE,CAAC,IAAI,GAAG,MAAM,GAAG,SAAS,CAAC,EAAE,CAAC;IAE1C;;OAEG;IACH,aAAa,CAAC,EAAE;QACd,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;KACjC,CAAC;IAEF;;OAEG;IACH,WAAW,CAAC,EAAE;QACZ,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,QAAQ,CAAC,EAAE,MAAM,CAAC;QAClB,QAAQ,CAAC,EAAE,MAAM,CAAC;KACnB,CAAC;CACH;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,WAAW,CACzB,OAAO,GAAE,kBAAuB,GAC/B,CAAC,GAAG,EAAE,GAAG,KAAK,GAAG,CA4FnB"}