@noony-serverless/core 0.2.2 → 0.3.1

package/build/core/handler.js

@@ -1,12 +1,9 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Handler = void 0;
-// Container import for direct container creation (no pooling needed)
-const typedi_1 = __importDefault(require("typedi"));
+// Container import removed - now using containerPool for performance
 const core_1 = require("./core");
+const containerPool_1 = require("./containerPool");
 /**
  * The Handler class is responsible for managing and executing middleware functions
  * and a main handler function in a sequential and controlled manner.
@@ -15,8 +12,6 @@ const core_1 = require("./core");
  * process a request/response flow either before the main handler (via `before`),
  * after the main handler (via `after`), or handle errors (via `onError`).
  *
- * @example
- * ```typescript
  * interface MessagePayload {
  *   action: string;
  *   data: Record<string, unknown>;
@@ -27,10 +22,10 @@ const core_1 = require("./core");
  *   .use(bodyParser())
  *   .handle(async (context) => {
  *     const { req } = context;
- *     // Handle the request with type-safe access to req.validatedBody
+ *     // Handle the request
  *   });
- * ```
  * @template T Type for the input request data.
+ * @template U Type for the additional context or response data.
  */
 class Handler {
     baseMiddlewares = [];
@@ -45,9 +40,12 @@ class Handler {
         return handler;
     }
     use(middleware) {
-        // Simple middleware chaining without complex type transformations
-        this.baseMiddlewares.push(middleware);
-        return this;
+        const handler = new Handler();
+        handler.baseMiddlewares = [
+            ...this.baseMiddlewares,
+            middleware,
+        ];
+        return handler;
     }
     handle(handler) {
         this.handler = handler;
@@ -65,17 +63,12 @@ class Handler {
         this.errorMiddlewares = this.reversedMiddlewares.filter((m) => m.onError);
         this.middlewaresPrecomputed = true;
     }
-    /**
-     * Universal execute method that works with any HTTP framework
-     * Automatically detects and adapts GCP, Express, AWS Lambda, Fastify, etc.
-     */
-    async execute(nativeReq, nativeRes) {
-        // Smart universal adapter - convert any framework's request/response to Noony format
-        const req = this.adaptToNoonyRequest(nativeReq);
-        const res = this.adaptToNoonyResponse(nativeRes, nativeReq);
-        // Direct container creation - simpler and appropriate for serverless
-        const container = typedi_1.default.of();
-        const context = (0, core_1.createContext)(req, res, {
+    async execute(req, res) {
+        const genericReq = (0, core_1.adaptGCPRequest)(req);
+        const genericRes = (0, core_1.adaptGCPResponse)(res);
+        // Performance optimization: Use container pool instead of creating new containers
+        const container = containerPool_1.containerPool.acquire();
+        const context = (0, core_1.createContext)(genericReq, genericRes, {
             container,
         });
         try {
@@ -90,7 +83,10 @@ class Handler {
             // Execute error handlers using pre-computed array
             await this.executeErrorMiddlewares(error, context);
         }
-        // No cleanup needed - container will be garbage collected automatically
+        finally {
+            // Always return container to pool for reuse
+            containerPool_1.containerPool.release(container);
+        }
     }
     /**
      * Execute before middlewares with optimized batching for independent middlewares
@@ -125,115 +121,30 @@ class Handler {
         }
     }
     /**
-     * Universal request adapter - converts any framework's request to NoonyRequest
-     */
-    adaptToNoonyRequest(nativeReq) {
-        const req = nativeReq;
-        // Universal property mapping that works with any HTTP framework
-        return {
-            method: req.method || req.httpMethod || core_1.HttpMethod.GET,
-            url: req.url || req.originalUrl || req.path || '/',
-            path: req.path || req.resource,
-            headers: req.headers || {},
-            query: req.query || req.queryStringParameters || {},
-            params: req.params || req.pathParameters || {},
-            body: req.body,
-            rawBody: req.rawBody || req.body,
-            parsedBody: req.parsedBody,
-            validatedBody: req.validatedBody,
-            ip: req.ip || req.requestContext?.identity?.sourceIp,
-            userAgent: (typeof req.headers?.['user-agent'] === 'string'
-                ? req.headers['user-agent']
-                : Array.isArray(req.headers?.['user-agent'])
-                    ? req.headers['user-agent'][0]
-                    : undefined) || req.get?.('user-agent'),
-        };
-    }
-    /**
-     * Universal response adapter - converts any framework's response to NoonyResponse
-     */
-    adaptToNoonyResponse(nativeRes, nativeReq) {
-        const req = nativeReq;
-        // Detect AWS Lambda pattern (different from standard HTTP)
-        if (req?.requestContext && typeof nativeRes === 'function') {
-            return this.createAWSLambdaResponse(nativeRes);
-        }
-        // Standard HTTP response (GCP, Express, Fastify, etc.)
-        return this.createStandardHTTPResponse(nativeRes);
-    }
-    /**
-     * Create response adapter for AWS Lambda
-     */
-    createAWSLambdaResponse(lambdaCallback) {
-        let statusCode = 200;
-        const headers = {};
-        let body;
-        return {
-            status: (code) => {
-                statusCode = code;
-                return this.createAWSLambdaResponse(lambdaCallback);
-            },
-            json: (data) => {
-                body = JSON.stringify(data);
-                headers['Content-Type'] = 'application/json';
-                lambdaCallback(null, { statusCode, headers, body });
-            },
-            send: (data) => {
-                body = data;
-                lambdaCallback(null, { statusCode, headers, body });
-            },
-            header: (name, value) => {
-                headers[name] = value;
-                return this.createAWSLambdaResponse(lambdaCallback);
-            },
-            headers: (newHeaders) => {
-                Object.assign(headers, newHeaders);
-                return this.createAWSLambdaResponse(lambdaCallback);
-            },
-            end: () => lambdaCallback(null, { statusCode, headers, body }),
-            statusCode,
-            headersSent: false,
-        };
-    }
-    /**
-     * Create response adapter for standard HTTP frameworks (GCP, Express, Fastify)
-     */
-    createStandardHTTPResponse(nativeRes) {
-        const res = nativeRes;
-        return {
-            status: (code) => {
-                res.status(code);
-                return this.createStandardHTTPResponse(nativeRes);
-            },
-            json: (data) => res.json(data),
-            send: (data) => res.send(data),
-            header: (name, value) => {
-                res.header(name, value);
-                return this.createStandardHTTPResponse(nativeRes);
-            },
-            headers: (headers) => {
-                if (res.set) {
-                    res.set(headers); // Express style
-                }
-                else {
-                    Object.entries(headers).forEach(([k, v]) => res.header(k, v)); // GCP style
-                }
-                return this.createStandardHTTPResponse(nativeRes);
-            },
-            end: () => res.end(),
-            get statusCode() {
-                return res.statusCode;
-            },
-            get headersSent() {
-                return res.headersSent;
-            },
-        };
-    }
-    /**
-     * @deprecated Use execute() instead - automatically detects framework
+     * Framework-agnostic execute method that works with GenericRequest/GenericResponse
      */
     async executeGeneric(req, res) {
-        return this.execute(req, res);
+        // Performance optimization: Use container pool instead of creating new containers
+        const container = containerPool_1.containerPool.acquire();
+        const context = (0, core_1.createContext)(req, res, {
+            container,
+        });
+        try {
+            // Execute before middlewares with performance optimizations
+            await this.executeBeforeMiddlewares(context);
+            await this.handler(context);
+            // Execute after middlewares in reverse order using pre-computed array
+            await this.executeAfterMiddlewares(context);
+        }
+        catch (error) {
+            context.error = error;
+            // Execute error handlers using pre-computed array
+            await this.executeErrorMiddlewares(error, context);
+        }
+        finally {
+            // Always return container to pool for reuse
+            containerPool_1.containerPool.release(container);
+        }
     }
 }
 exports.Handler = Handler;

package/build/core/index.d.ts

@@ -2,6 +2,7 @@ export * from './core';
 export * from './errors';
 export * from './handler';
 export * from './logger';
+export * from './containerPool';
 export * from './performanceMonitor';
 export * from '../middlewares';
 //# sourceMappingURL=index.d.ts.map

package/build/core/index.js

@@ -18,6 +18,7 @@ __exportStar(require("./core"), exports);
 __exportStar(require("./errors"), exports);
 __exportStar(require("./handler"), exports);
 __exportStar(require("./logger"), exports);
+__exportStar(require("./containerPool"), exports);
 __exportStar(require("./performanceMonitor"), exports);
 __exportStar(require("../middlewares"), exports);
 //# sourceMappingURL=index.js.map

package/build/index.d.ts

@@ -1,3 +1,4 @@
 export * from './core';
 export * from './middlewares';
+export * from './utils';
 //# sourceMappingURL=index.d.ts.map

package/build/index.js

@@ -14,6 +14,10 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+// Core exports
 __exportStar(require("./core"), exports);
+// Middleware exports
 __exportStar(require("./middlewares"), exports);
+// Utility exports
+__exportStar(require("./utils"), exports);
 //# sourceMappingURL=index.js.map

package/build/middlewares/authenticationMiddleware.d.ts

@@ -209,7 +209,8 @@ export interface AuthenticationOptions {
  * Class-based authentication middleware with comprehensive security features.
  * Provides JWT validation, rate limiting, token blacklisting, and security logging.
  *
- * @template T - The type of user data returned by the token verification port
+ * @template TUser - The type of user data returned by the token verification port
+ * @template TBody - The type of the request body payload (preserves type chain)
  *
  * @example
  * Basic JWT authentication:
@@ -292,17 +293,18 @@ export interface AuthenticationOptions {
  * });
  * ```
  */
-export declare class AuthenticationMiddleware<T> implements BaseMiddleware {
+export declare class AuthenticationMiddleware<TUser = unknown, TBody = unknown> implements BaseMiddleware<TBody, TUser> {
     private tokenVerificationPort;
     private options;
-    constructor(tokenVerificationPort: CustomTokenVerificationPort<T>, options?: AuthenticationOptions);
-    before(context: Context): Promise<void>;
+    constructor(tokenVerificationPort: CustomTokenVerificationPort<TUser>, options?: AuthenticationOptions);
+    before(context: Context<TBody, TUser>): Promise<void>;
 }
 /**
  * Factory function that creates an authentication middleware with token verification.
  * Provides a functional approach for authentication setup.
  *
- * @template T - The type of user data returned by the token verification port
+ * @template TUser - The type of user data returned by the token verification port
+ * @template TBody - The type of the request body payload (preserves type chain)
  * @param tokenVerificationPort - The token verification implementation
  * @param options - Authentication configuration options
  * @returns A BaseMiddleware object with authentication logic
@@ -427,5 +429,5 @@ export declare class AuthenticationMiddleware<T> implements BaseMiddleware {
  * };
  * ```
  */
-export declare const verifyAuthTokenMiddleware: <T>(tokenVerificationPort: CustomTokenVerificationPort<T>, options?: AuthenticationOptions) => BaseMiddleware;
+export declare const verifyAuthTokenMiddleware: <TUser = unknown, TBody = unknown>(tokenVerificationPort: CustomTokenVerificationPort<TUser>, options?: AuthenticationOptions) => BaseMiddleware<TBody, TUser>;
 //# sourceMappingURL=authenticationMiddleware.d.ts.map

package/build/middlewares/authenticationMiddleware.js

@@ -173,7 +173,8 @@ async function verifyToken(tokenVerificationPort, context, options = {}) {
  * Class-based authentication middleware with comprehensive security features.
  * Provides JWT validation, rate limiting, token blacklisting, and security logging.
  *
- * @template T - The type of user data returned by the token verification port
+ * @template TUser - The type of user data returned by the token verification port
+ * @template TBody - The type of the request body payload (preserves type chain)
  *
  * @example
  * Basic JWT authentication:
@@ -272,7 +273,8 @@ exports.AuthenticationMiddleware = AuthenticationMiddleware;
  * Factory function that creates an authentication middleware with token verification.
  * Provides a functional approach for authentication setup.
  *
- * @template T - The type of user data returned by the token verification port
+ * @template TUser - The type of user data returned by the token verification port
+ * @template TBody - The type of the request body payload (preserves type chain)
  * @param tokenVerificationPort - The token verification implementation
  * @param options - Authentication configuration options
  * @returns A BaseMiddleware object with authentication logic

package/build/middlewares/bodyParserMiddleware.d.ts

@@ -8,7 +8,8 @@ import { BaseMiddleware, Context } from '../core';
  * - Base64 decoding for Pub/Sub messages
  * - Non-blocking parsing using setImmediate
  *
- * @template T - The expected type of the parsed body. Defaults to unknown if not specified.
+ * @template TBody - The expected type of the parsed body. Defaults to unknown if not specified.
+ * @template TUser - The type of the authenticated user (preserves type chain)
  * @implements {BaseMiddleware}
  *
  * @example
@@ -63,10 +64,10 @@ import { BaseMiddleware, Context } from '../core';
  *   });
  * ```
  */
-export declare class BodyParserMiddleware<T = unknown> implements BaseMiddleware {
+export declare class BodyParserMiddleware<TBody = unknown, TUser = unknown> implements BaseMiddleware<TBody, TUser> {
     private maxSize;
     constructor(maxSize?: number);
-    before(context: Context): Promise<void>;
+    before(context: Context<TBody, TUser>): Promise<void>;
 }
 /**
  * Enhanced middleware function for parsing the request body in specific HTTP methods.
@@ -76,7 +77,8 @@ export declare class BodyParserMiddleware<T = unknown> implements BaseMiddleware
  * - Async parsing for large payloads
  * - Size validation
  *
- * @template T - The expected type of the parsed request body.
+ * @template TBody - The expected type of the parsed request body.
+ * @template TUser - The type of the authenticated user (preserves type chain)
  * @param maxSize - Maximum allowed body size in bytes (default: 1MB)
  * @returns {BaseMiddleware} A middleware object containing a `before` hook.
  *
@@ -126,5 +128,5 @@ export declare class BodyParserMiddleware<T = unknown> implements BaseMiddleware
  *   });
  * ```
  */
-export declare const bodyParser: <T = unknown>(maxSize?: number) => BaseMiddleware;
+export declare const bodyParser: <TBody = unknown, TUser = unknown>(maxSize?: number) => BaseMiddleware<TBody, TUser>;
 //# sourceMappingURL=bodyParserMiddleware.d.ts.map

package/build/middlewares/bodyParserMiddleware.js

@@ -157,7 +157,8 @@ const parseBody = async (body) => {
  * - Base64 decoding for Pub/Sub messages
  * - Non-blocking parsing using setImmediate
  *
- * @template T - The expected type of the parsed body. Defaults to unknown if not specified.
+ * @template TBody - The expected type of the parsed body. Defaults to unknown if not specified.
+ * @template TUser - The type of the authenticated user (preserves type chain)
  * @implements {BaseMiddleware}
  *
  * @example
@@ -241,7 +242,8 @@ exports.BodyParserMiddleware = BodyParserMiddleware;
  * - Async parsing for large payloads
  * - Size validation
  *
- * @template T - The expected type of the parsed request body.
+ * @template TBody - The expected type of the parsed request body.
+ * @template TUser - The type of the authenticated user (preserves type chain)
  * @param maxSize - Maximum allowed body size in bytes (default: 1MB)
  * @returns {BaseMiddleware} A middleware object containing a `before` hook.
  *

package/build/middlewares/bodyValidationMiddleware.d.ts

@@ -23,21 +23,20 @@ import { z } from 'zod';
  *
  * type UserRequest = z.infer<typeof userSchema>;
  *
- * async function handleCreateUser(context: Context<UserRequest>) {
+ * async function handleCreateUser(context: Context<UserRequest, AuthenticatedUser>) {
  *   const user = context.req.validatedBody!; // Fully typed
- *   const authenticatedUser = context.user; // User type inferred from auth middleware
  *   return { success: true, user: { id: '123', ...user } };
  * }
  *
- * const createUserHandler = new Handler<UserRequest>()
- *   .use(new BodyValidationMiddleware<UserRequest>(userSchema))
+ * const createUserHandler = new Handler<UserRequest, AuthenticatedUser>()
+ *   .use(new BodyValidationMiddleware<UserRequest, AuthenticatedUser>(userSchema))
  *   .handle(handleCreateUser);
  * ```
  */
-export declare class BodyValidationMiddleware<T = unknown> implements BaseMiddleware<T> {
+export declare class BodyValidationMiddleware<T = unknown, U = unknown> implements BaseMiddleware<T, U> {
     private readonly schema;
     constructor(schema: z.ZodSchema<T>);
-    before(context: Context<T>): Promise<void>;
+    before(context: Context<T, U>): Promise<void>;
 }
 /**
  * Factory function that creates a body validation middleware with Zod schema validation.
@@ -60,19 +59,18 @@ export declare class BodyValidationMiddleware<T = unknown> implements BaseMiddle
  *
  * type LoginRequest = z.infer<typeof loginSchema>;
  *
- * async function handleLogin(context: Context<LoginRequest>) {
+ * async function handleLogin(context: Context<LoginRequest, AuthenticatedUser>) {
  *   const credentials = context.req.parsedBody as LoginRequest;
  *   const token = await authenticate(credentials.username, credentials.password);
- *   const authenticatedUser = context.user; // User type from auth middleware
  *   return { success: true, token };
  * }
  *
- * const loginHandler = new Handler<LoginRequest>()
- *   .use(bodyValidatorMiddleware<LoginRequest>(loginSchema))
+ * const loginHandler = new Handler<LoginRequest, AuthenticatedUser>()
+ *   .use(bodyValidatorMiddleware<LoginRequest, AuthenticatedUser>(loginSchema))
  *   .handle(handleLogin);
  * ```
  */
-export declare const bodyValidatorMiddleware: <T>(schema: z.ZodType<T>) => {
-    before: (context: Context<T>) => Promise<void>;
+export declare const bodyValidatorMiddleware: <T, U = unknown>(schema: z.ZodType<T>) => {
+    before: (context: Context<T, U>) => Promise<void>;
 };
 //# sourceMappingURL=bodyValidationMiddleware.d.ts.map

package/build/middlewares/bodyValidationMiddleware.js

@@ -36,14 +36,13 @@ const validateBody = async (schema, data) => {
  *
  * type UserRequest = z.infer<typeof userSchema>;
  *
- * async function handleCreateUser(context: Context<UserRequest>) {
+ * async function handleCreateUser(context: Context<UserRequest, AuthenticatedUser>) {
  *   const user = context.req.validatedBody!; // Fully typed
- *   const authenticatedUser = context.user; // User type inferred from auth middleware
  *   return { success: true, user: { id: '123', ...user } };
  * }
  *
- * const createUserHandler = new Handler<UserRequest>()
- *   .use(new BodyValidationMiddleware<UserRequest>(userSchema))
+ * const createUserHandler = new Handler<UserRequest, AuthenticatedUser>()
+ *   .use(new BodyValidationMiddleware<UserRequest, AuthenticatedUser>(userSchema))
  *   .handle(handleCreateUser);
  * ```
  */
@@ -78,19 +77,18 @@ exports.BodyValidationMiddleware = BodyValidationMiddleware;
  *
  * type LoginRequest = z.infer<typeof loginSchema>;
  *
- * async function handleLogin(context: Context<LoginRequest>) {
+ * async function handleLogin(context: Context<LoginRequest, AuthenticatedUser>) {
  *   const credentials = context.req.parsedBody as LoginRequest;
  *   const token = await authenticate(credentials.username, credentials.password);
- *   const authenticatedUser = context.user; // User type from auth middleware
  *   return { success: true, token };
  * }
  *
- * const loginHandler = new Handler<LoginRequest>()
- *   .use(bodyValidatorMiddleware<LoginRequest>(loginSchema))
+ * const loginHandler = new Handler<LoginRequest, AuthenticatedUser>()
+ *   .use(bodyValidatorMiddleware<LoginRequest, AuthenticatedUser>(loginSchema))
  *   .handle(handleLogin);
  * ```
  */
-// Simplified factory function for body validation middleware
+// Modified to fix type instantiation error
 const bodyValidatorMiddleware = (schema) => ({
     before: async (context) => {
         context.req.parsedBody = await validateBody(schema, context.req.body);

package/build/middlewares/errorHandlerMiddleware.d.ts

@@ -4,6 +4,9 @@ import { BaseMiddleware, Context } from '../core';
  * Implements the `BaseMiddleware` interface and provides an asynchronous
  * `onError` method that delegates error handling to the `handleError` function.
  *
+ * @template TBody - The type of the request body payload (preserves type chain)
+ * @template TUser - The type of the authenticated user (preserves type chain)
+ *
  * @remarks
  * This middleware should be registered to catch and process errors that occur
  * during request handling.
@@ -50,12 +53,14 @@ import { BaseMiddleware, Context } from '../core';
  * });
  * ```
  */
-export declare class ErrorHandlerMiddleware implements BaseMiddleware {
-    onError(error: Error, context: Context): Promise<void>;
+export declare class ErrorHandlerMiddleware<TBody = unknown, TUser = unknown> implements BaseMiddleware<TBody, TUser> {
+    onError(error: Error, context: Context<TBody, TUser>): Promise<void>;
 }
 /**
  * Creates an error handling middleware for processing errors in the application.
  *
+ * @template TBody - The type of the request body payload (preserves type chain)
+ * @template TUser - The type of the authenticated user (preserves type chain)
  * @returns {BaseMiddleware} An object implementing the `onError` method to handle errors.
  *
  * @remarks
@@ -96,5 +101,5 @@ export declare class ErrorHandlerMiddleware implements BaseMiddleware {
  *   });
  * ```
  */
-export declare const errorHandler: () => BaseMiddleware;
+export declare const errorHandler: <TBody = unknown, TUser = unknown>() => BaseMiddleware<TBody, TUser>;
 //# sourceMappingURL=errorHandlerMiddleware.d.ts.map

package/build/middlewares/errorHandlerMiddleware.js

@@ -9,6 +9,8 @@ const core_1 = require("../core");
  * - For `HttpError` instances, responds with the error message, and optionally details and code based on environment and error type.
  * - For other errors, responds with a generic message in production, and includes stack trace in development.
  *
+ * @template TBody - The type of the request body payload (preserves type chain)
+ * @template TUser - The type of the authenticated user (preserves type chain)
  * @param error - The error object thrown during request processing.
  * @param context - The request context containing request and response objects.
  * @returns A promise that resolves when the error response has been sent.
@@ -65,6 +67,9 @@ const handleError = async (error, context) => {
  * Implements the `BaseMiddleware` interface and provides an asynchronous
  * `onError` method that delegates error handling to the `handleError` function.
  *
+ * @template TBody - The type of the request body payload (preserves type chain)
+ * @template TUser - The type of the authenticated user (preserves type chain)
+ *
  * @remarks
  * This middleware should be registered to catch and process errors that occur
  * during request handling.
@@ -120,6 +125,8 @@ exports.ErrorHandlerMiddleware = ErrorHandlerMiddleware;
 /**
  * Creates an error handling middleware for processing errors in the application.
  *
+ * @template TBody - The type of the request body payload (preserves type chain)
+ * @template TUser - The type of the authenticated user (preserves type chain)
  * @returns {BaseMiddleware} An object implementing the `onError` method to handle errors.
  *
  * @remarks

package/build/middlewares/guards/RouteGuards.d.ts

@@ -42,8 +42,8 @@
  *       return { valid: false, error: error.message };
  *     }
  *   },
- *   extractUserId: (decoded: unknown) => (decoded as any).sub,
- *   isTokenExpired: (decoded: unknown) => (decoded as any).exp < Date.now() / 1000
+ *   extractUserId: (decoded: any) => decoded.sub,
+ *   isTokenExpired: (decoded: any) => decoded.exp < Date.now() / 1000
  * };
  *
  * // Configure guard system

package/build/middlewares/guards/RouteGuards.js

@@ -43,8 +43,8 @@
  *       return { valid: false, error: error.message };
  *     }
  *   },
- *   extractUserId: (decoded: unknown) => (decoded as any).sub,
- *   isTokenExpired: (decoded: unknown) => (decoded as any).exp < Date.now() / 1000
+ *   extractUserId: (decoded: any) => decoded.sub,
+ *   isTokenExpired: (decoded: any) => decoded.exp < Date.now() / 1000
  * };
  *
  * // Configure guard system

package/build/middlewares/guards/adapters/CustomTokenVerificationPortAdapter.d.ts

@@ -245,7 +245,7 @@ export declare class TokenVerificationAdapterFactory {
      * @param expirationField - Optional field name for expiration (e.g., 'expiresAt', 'exp')
      * @returns Configured adapter for API key tokens
      */
-    static forAPIKey<T extends Record<string, unknown>>(verificationPort: CustomTokenVerificationPort<T>, userIdField: keyof T, expirationField?: keyof T): CustomTokenVerificationPortAdapter<T>;
+    static forAPIKey<T extends Record<string, any>>(verificationPort: CustomTokenVerificationPort<T>, userIdField: keyof T, expirationField?: keyof T): CustomTokenVerificationPortAdapter<T>;
     /**
      * Create adapter for OAuth tokens with standard OAuth claims.
      *

package/build/middlewares/guards/guards/FastAuthGuard.d.ts

@@ -43,7 +43,7 @@ export interface AuthenticationResult {
     success: boolean;
     user?: UserContext;
     token?: {
-        decoded: unknown;
+        decoded: any;
         raw: string;
         expiresAt: string;
         issuer?: string;
@@ -63,7 +63,7 @@ export interface AuthGuardConfig {
     allowedIssuers?: string[];
     requireEmailVerification: boolean;
     allowInactiveUsers: boolean;
-    customValidation?: (token: unknown, user: UserContext) => Promise<boolean>;
+    customValidation?: (token: any, user: UserContext) => Promise<boolean>;
 }
 /**
  * Token validation service interface
@@ -74,17 +74,17 @@ export interface TokenValidator {
      */
     validateToken(token: string): Promise<{
         valid: boolean;
-        decoded?: unknown;
+        decoded?: any;
         error?: string;
     }>;
     /**
      * Extract user ID from decoded token
      */
-    extractUserId(decoded: unknown): string;
+    extractUserId(decoded: any): string;
     /**
      * Check if token is expired
      */
-    isTokenExpired(decoded: unknown): boolean;
+    isTokenExpired(decoded: any): boolean;
 }
 /**
  * Fast Authentication Guard Implementation

package/build/middlewares/guards/guards/PermissionGuardFactory.d.ts

@@ -162,8 +162,16 @@ export declare class PermissionGuardFactory {
     getStats(): {
         totalGuards: number;
         guardsByType: Record<string, number>;
-        individualGuardStats: Record<string, unknown>[];
-        aggregatedStats: Record<string, unknown>;
+        individualGuardStats: {
+            guardType: string;
+            checkCount: number;
+            successCount: number;
+            failureCount: number;
+            successRate: number;
+            averageProcessingTimeUs: number;
+            totalProcessingTimeUs: number;
+        }[];
+        aggregatedStats: any;
     };
     /**
      * Clear guard cache

package/build/middlewares/guards/guards/PermissionGuardFactory.js

@@ -388,7 +388,7 @@ let PermissionGuardFactory = class PermissionGuardFactory {
     createCompositeGuard(requirements, config = {}) {
         const fullConfig = {
             requireAuth: true,
-            permissions: requirements, // Store requirements as permissions for cache key
+            permissions: requirements, // Store requirements as permissions for cache key (complex composite type)
             cacheResults: true,
             auditTrail: false,
             ...config,

package/build/middlewares/guards/resolvers/ExpressionPermissionResolver.d.ts

@@ -118,7 +118,7 @@ export declare class ExpressionPermissionResolver extends PermissionResolver<Per
     /**
      * Check if this resolver can handle the given requirement type
      */
-    canHandle(requirement: unknown): requirement is PermissionExpression;
+    canHandle(requirement: any): requirement is PermissionExpression;
     /**
      * Normalize expression for consistent cache keys
      *