wynkjs 1.0.4 → 1.0.7

package/dist/plugins/compression.js

@@ -0,0 +1,125 @@
+/**
+ * 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 function compression(options = {}) {
+    const config = {
+        threshold: options.threshold ?? 1024,
+        encodings: options.encodings ?? ["gzip", "br", "deflate"],
+        brotliOptions: options.brotliOptions ?? {},
+        zlibOptions: options.zlibOptions ?? {},
+    };
+    return (app) => {
+        return app.onAfterHandle(async function compressionHandler(context) {
+            const { response, request, set } = context;
+            // Skip if no response
+            if (!response)
+                return;
+            // Skip if already compressed
+            if (set.headers?.["content-encoding"])
+                return;
+            // Get client's accepted encodings
+            const acceptEncoding = (request.headers.get("accept-encoding") || "").toLowerCase();
+            // Find best compression match
+            let encoding = null;
+            for (const enc of config.encodings) {
+                if (acceptEncoding.includes(enc)) {
+                    encoding = enc;
+                    break;
+                }
+            }
+            if (!encoding)
+                return; // No supported encoding
+            // Convert response to buffer
+            let body;
+            if (Buffer.isBuffer(response)) {
+                body = response;
+            }
+            else if (typeof response === "string") {
+                body = Buffer.from(response);
+            }
+            else if (typeof response === "object") {
+                body = Buffer.from(JSON.stringify(response));
+                set.headers["content-type"] =
+                    set.headers["content-type"] || "application/json";
+            }
+            else {
+                body = Buffer.from(String(response));
+            }
+            // Check size threshold
+            if (body.length < config.threshold)
+                return;
+            // Compress
+            try {
+                const zlib = await import("node:zlib");
+                const { promisify } = await import("node:util");
+                let compressed;
+                switch (encoding) {
+                    case "br":
+                        compressed = await promisify(zlib.brotliCompress)(body, config.brotliOptions);
+                        break;
+                    case "gzip":
+                        compressed = await promisify(zlib.gzip)(body, config.zlibOptions);
+                        break;
+                    case "deflate":
+                        compressed = await promisify(zlib.deflate)(body, config.zlibOptions);
+                        break;
+                    default:
+                        return;
+                }
+                // Only use if smaller
+                if (compressed.length >= body.length)
+                    return;
+                // Set headers and return compressed body
+                set.headers["content-encoding"] = encoding;
+                set.headers["vary"] = "Accept-Encoding";
+                delete set.headers["content-length"]; // Let Elysia set this
+                return compressed;
+            }
+            catch (error) {
+                console.error("[Compression Error]:", error);
+                return; // Return original on error
+            }
+        });
+    };
+}

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

@@ -0,0 +1,51 @@
+/**
+ * ULTRA-OPTIMIZED Handler Builder for WynkJS
+ *
+ * KEY OPTIMIZATION: Eliminate nested async/await and IIFEs
+ *
+ * Performance findings:
+ * - Direct sync: 32ms per 1M calls
+ * - Single async: 42ms per 1M calls
+ * - Nested async + IIFE: 232ms per 1M calls (5.7x SLOWER!)
+ *
+ * Root cause: The current pattern creates an IIFE for every request:
+ *   return (async () => { try { ... } catch { ... } })();
+ *
+ * This creates massive overhead because:
+ * 1. Creates a new Promise on EVERY request
+ * 2. Wraps it in a try-catch block
+ * 3. Immediately invokes it (IIFE pattern)
+ * 4. Then awaits the result
+ *
+ * Solution: Build a SINGLE async function at registration time,
+ * not nested functions that get called on every request.
+ */
+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;
+    };
+    routePath: string;
+    routeMethod: string;
+}
+/**
+ * Ultra-optimized handler builder
+ * Builds a SINGLE async function, not nested closures
+ */
+export declare function buildUltraOptimizedHandler(options: HandlerBuildOptions): (ctx: any) => Promise<any>;
+/**
+ * Build middleware chain - same as before
+ */
+export declare function buildMiddlewareChain(handler: (ctx: any) => Promise<any>, middlewares: any[]): (ctx: any) => Promise<any>;
+//# sourceMappingURL=ultra-optimized-handler.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ultra-optimized-handler.d.ts","sourceRoot":"","sources":["../core/ultra-optimized-handler.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;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;IAC/C,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;CACrB;AAED;;;GAGG;AACH,wBAAgB,0BAA0B,CACxC,OAAO,EAAE,mBAAmB,GAC3B,CAAC,GAAG,EAAE,GAAG,KAAK,OAAO,CAAC,GAAG,CAAC,CAiU5B;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,CAU5B"}

package/dist/ultra-optimized-handler.js

@@ -0,0 +1,302 @@
+/**
+ * ULTRA-OPTIMIZED Handler Builder for WynkJS
+ *
+ * KEY OPTIMIZATION: Eliminate nested async/await and IIFEs
+ *
+ * Performance findings:
+ * - Direct sync: 32ms per 1M calls
+ * - Single async: 42ms per 1M calls
+ * - Nested async + IIFE: 232ms per 1M calls (5.7x SLOWER!)
+ *
+ * Root cause: The current pattern creates an IIFE for every request:
+ *   return (async () => { try { ... } catch { ... } })();
+ *
+ * This creates massive overhead because:
+ * 1. Creates a new Promise on EVERY request
+ * 2. Wraps it in a try-catch block
+ * 3. Immediately invokes it (IIFE pattern)
+ * 4. Then awaits the result
+ *
+ * Solution: Build a SINGLE async function at registration time,
+ * not nested functions that get called on every request.
+ */
+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";
+/**
+ * Ultra-optimized handler builder
+ * Builds a SINGLE async function, not nested closures
+ */
+export function buildUltraOptimizedHandler(options) {
+    const { instance, methodName, ControllerClass, params, allGuards, allInterceptors, allPipes, allFilters, httpCode, headers, redirect, routePath, routeMethod, } = options;
+    // Pre-sort params once during registration
+    if (params.length > 0) {
+        params.sort((a, b) => a.index - b.index);
+    }
+    // Determine which features are actually used
+    const hasGuards = allGuards.length > 0;
+    const hasInterceptors = allInterceptors.length > 0;
+    const hasPipes = allPipes.length > 0;
+    const hasFilters = allFilters.length > 0;
+    const hasParams = params.length > 0;
+    const hasResponseModifiers = !!(httpCode || headers || redirect);
+    // Build specialized handler based on what's actually needed
+    // This eliminates ALL conditional checks at runtime
+    // CASE 1: Absolute minimal - no features at all (like /health endpoint)
+    if (!hasGuards &&
+        !hasInterceptors &&
+        !hasPipes &&
+        !hasFilters &&
+        !hasParams &&
+        !hasResponseModifiers) {
+        // Direct call - zero overhead!
+        return async (ctx) => {
+            return await instance[methodName](ctx);
+        };
+    }
+    // CASE 2: Has params but no other features
+    if (!hasGuards &&
+        !hasInterceptors &&
+        !hasFilters &&
+        !hasResponseModifiers &&
+        hasParams) {
+        return async (ctx) => {
+            const args = new Array(params.length);
+            for (const param of params) {
+                let value;
+                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 pipes if any
+                if (hasPipes) {
+                    const metadata = {
+                        type: param.type,
+                        data: param.data,
+                    };
+                    value = await executePipes(allPipes, value, metadata);
+                }
+                if (param.pipes && param.pipes.length > 0) {
+                    const metadata = {
+                        type: param.type,
+                        data: param.data,
+                    };
+                    value = await executePipes(param.pipes, value, metadata);
+                }
+                args[param.index] = value;
+            }
+            return await instance[methodName].apply(instance, args);
+        };
+    }
+    // CASE 3: Full-featured handler (has guards/interceptors/filters)
+    // This is where we MUST use try-catch, but still avoid nested async
+    return async (ctx) => {
+        try {
+            // Guards
+            if (hasGuards) {
+                const executionContext = createExecutionContext(ctx, instance[methodName], ControllerClass);
+                // Add route metadata
+                executionContext.path = routePath;
+                executionContext.method = routeMethod;
+                executionContext.request = ctx.request || ctx;
+                executionContext.body = ctx.body;
+                executionContext.params = ctx.params;
+                executionContext.query = ctx.query;
+                executionContext.headers = ctx.headers || ctx.request?.headers;
+                const canActivate = await executeGuards(allGuards, executionContext);
+                if (!canActivate) {
+                    throw new HttpException("Forbidden", 403, "Access denied");
+                }
+            }
+            // Prepare the actual handler execution
+            const executeMethod = async () => {
+                if (!hasParams) {
+                    return await instance[methodName](ctx);
+                }
+                const args = new Array(params.length);
+                for (const param of params) {
+                    let value;
+                    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;
+                    }
+                    if (hasPipes) {
+                        const metadata = {
+                            type: param.type,
+                            data: param.data,
+                        };
+                        value = await executePipes(allPipes, value, metadata);
+                    }
+                    if (param.pipes && param.pipes.length > 0) {
+                        const metadata = {
+                            type: param.type,
+                            data: param.data,
+                        };
+                        value = await executePipes(param.pipes, value, metadata);
+                    }
+                    args[param.index] = value;
+                }
+                return await instance[methodName].apply(instance, args);
+            };
+            // Interceptors
+            let result;
+            if (hasInterceptors) {
+                const executionContext = createExecutionContext(ctx, instance[methodName], ControllerClass);
+                // Add route metadata
+                executionContext.path = routePath;
+                executionContext.method = routeMethod;
+                executionContext.request = ctx.request || ctx;
+                executionContext.body = ctx.body;
+                executionContext.params = ctx.params;
+                executionContext.query = ctx.query;
+                executionContext.headers = ctx.headers || ctx.request?.headers;
+                result = await executeInterceptors(allInterceptors, executionContext, executeMethod);
+            }
+            else {
+                result = await executeMethod();
+            }
+            // Response modifiers
+            if (hasResponseModifiers) {
+                if (redirect) {
+                    ctx.set.redirect = redirect.url;
+                    ctx.set.status = redirect.statusCode;
+                    return;
+                }
+                if (httpCode) {
+                    ctx.set.status = httpCode;
+                }
+                if (headers) {
+                    Object.entries(headers).forEach(([key, value]) => {
+                        ctx.set.headers[key] = value;
+                    });
+                }
+            }
+            return result;
+        }
+        catch (error) {
+            // Exception filters (only if configured)
+            if (hasFilters) {
+                const executionContext = createExecutionContext(ctx, instance[methodName], ControllerClass);
+                // Add route metadata
+                executionContext.path = routePath;
+                executionContext.method = routeMethod;
+                executionContext.request = ctx.request || ctx;
+                executionContext.body = ctx.body;
+                executionContext.params = ctx.params;
+                executionContext.query = ctx.query;
+                executionContext.headers = ctx.headers || ctx.request?.headers;
+                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",
+            };
+        }
+    };
+}
+/**
+ * Build middleware chain - same as before
+ */
+export function buildMiddlewareChain(handler, middlewares) {
+    if (middlewares.length === 0) {
+        return handler;
+    }
+    return middlewares.reduceRight((next, middleware) => {
+        return async (ctx) => {
+            return await middleware(ctx, () => next(ctx));
+        };
+    }, handler);
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "wynkjs",
-  "version": "1.0.4",
-  "description": "A high-performance TypeScript framework built on Elysia for Bun with elegant decorator-based architecture - 10x faster than Express/NestJS",
+  "version": "1.0.7",
+  "description": "A high-performance TypeScript framework built on Elysia for Bun with elegant decorator-based architecture, built-in compression, and plugin system - 10x faster than Express/NestJS",
   "main": "dist/index.js",
   "module": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -27,7 +27,12 @@
     "dependency-injection",
     "rest-api",
     "backend",
-    "server"
+    "server",
+    "compression",
+    "gzip",
+    "brotli",
+    "plugins",
+    "middleware"
   ],
   "author": "Alam Jamal alamjamal88@gmail.com",
   "license": "MIT",
@@ -42,15 +47,14 @@
   "scripts": {
     "build": "tsc",
     "prepublishOnly": "npm run build",
-    "test": "bun test"
-  },
-  "peerDependencies": {
-    "elysia": "^1.0.0",
-    "reflect-metadata": "^0.2.2"
+    "test": "bun test",
+    "test:all": "bun test tests/",
+    "test:core": "bash tests/test-core.sh",
+    "test:watch": "bun test tests/ --watch",
+    "test:coverage": "bun test tests/ --coverage"
   },
+  "peerDependencies": {},
   "devDependencies": {
-    "elysia": "^1.0.0",
-    "reflect-metadata": "^0.2.2",
     "@types/bun": "latest",
     "typescript": "^5.0.0"
   },
@@ -69,6 +73,9 @@
     "LICENSE"
   ],
   "dependencies": {
+    "elysia": "^1.0.0",
+    "reflect-metadata": "^0.2.2",
+    "@elysiajs/cors": "^1.4.0",
     "tsyringe": "^4.10.0"
   }
 }