@noony-serverless/core 0.1.5 → 0.2.0

package/build/core/core.d.ts

@@ -1,4 +1,3 @@
-import { Request, Response } from '@google-cloud/functions-framework';
 import Container from 'typedi';
 /**
  * Framework-agnostic HTTP method enum
@@ -15,7 +14,7 @@ export declare enum HttpMethod {
 /**
  * Framework-agnostic request interface that can work with any HTTP framework
  */
-export interface GenericRequest<T = unknown> {
+export interface NoonyRequest<T = unknown> {
     method: HttpMethod | string;
     url: string;
     path?: string;
@@ -32,30 +31,20 @@ export interface GenericRequest<T = unknown> {
 /**
  * Framework-agnostic response interface that can work with any HTTP framework
  */
-export interface GenericResponse {
-    status(code: number): GenericResponse;
-    json(data: unknown): GenericResponse | void;
-    send(data: unknown): GenericResponse | void;
-    header(name: string, value: string): GenericResponse;
-    headers(headers: Record<string, string>): GenericResponse;
+export interface NoonyResponse {
+    status(code: number): NoonyResponse;
+    json(data: unknown): NoonyResponse | void;
+    send(data: unknown): NoonyResponse | void;
+    header(name: string, value: string): NoonyResponse;
+    headers(headers: Record<string, string>): NoonyResponse;
     end(): void;
     statusCode?: number;
     headersSent?: boolean;
 }
-/**
- * Legacy GCP Functions-specific request interface for backward compatibility
- * @deprecated Use GenericRequest instead
- */
-export interface CustomRequest<T = unknown> extends Request {
-    parsedBody?: T;
-    validatedBody?: T;
-}
-/**
- * Legacy GCP Functions-specific response interface for backward compatibility
- * @deprecated Use GenericResponse instead
- */
-export interface CustomResponse extends Response {
-}
+/** @deprecated Use NoonyRequest instead */
+export type GenericRequest<T = unknown> = NoonyRequest<T>;
+/** @deprecated Use NoonyResponse instead */
+export type GenericResponse = NoonyResponse;
 /**
  * Security configuration for request processing
  */
@@ -78,46 +67,25 @@ export interface HandlerOptions {
  * Represents the execution context for handling a request and response in an application.
  *
  * @template T Specifies the type of the custom request payload.
- * @template V Specifies the type of the user-related information.
  */
-export interface Context<T = unknown, V = unknown> {
-    readonly req: GenericRequest<T>;
-    readonly res: GenericResponse;
+export interface Context<T = unknown> {
+    readonly req: NoonyRequest<T>;
+    readonly res: NoonyResponse;
     container?: Container;
     error?: Error | null;
     readonly businessData: Map<string, unknown>;
-    user?: V;
+    user?: unknown;
     readonly startTime: number;
     readonly requestId: string;
     timeoutSignal?: AbortSignal;
     responseData?: unknown;
 }
-/**
- * Legacy context interface for backward compatibility
- * @deprecated Use Context with GenericRequest/GenericResponse instead
- */
-export interface LegacyContext<T = unknown, V = unknown> {
-    req: CustomRequest<T>;
-    res: CustomResponse;
-    container?: Container;
-    error?: Error | null;
-    businessData: Map<string, unknown>;
-    user?: V;
-}
 /**
  * Utility function to generate unique request IDs
  */
 export declare function generateRequestId(): string;
-/**
- * Adapter to convert GCP Functions Request to GenericRequest
- */
-export declare function adaptGCPRequest<T = unknown>(gcpRequest: Request): GenericRequest<T>;
-/**
- * Adapter to convert GCP Functions Response to GenericResponse
- */
-export declare function adaptGCPResponse(gcpResponse: Response): GenericResponse;
 /**
  * Creates a context object for framework-agnostic handlers
  */
-export declare function createContext<T = unknown, V = unknown>(req: GenericRequest<T>, res: GenericResponse, options?: Partial<Context<T, V>>): Context<T, V>;
+export declare function createContext<T = unknown>(req: NoonyRequest<T>, res: NoonyResponse, options?: Partial<Context<T>>): Context<T>;
 //# sourceMappingURL=core.d.ts.map

package/build/core/core.js

@@ -5,8 +5,6 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.HttpMethod = void 0;
 exports.generateRequestId = generateRequestId;
-exports.adaptGCPRequest = adaptGCPRequest;
-exports.adaptGCPResponse = adaptGCPResponse;
 exports.createContext = createContext;
 const typedi_1 = __importDefault(require("typedi"));
 /**
@@ -22,71 +20,14 @@ var HttpMethod;
     HttpMethod["OPTIONS"] = "OPTIONS";
     HttpMethod["HEAD"] = "HEAD";
 })(HttpMethod || (exports.HttpMethod = HttpMethod = {}));
+// Legacy context interface removed - use Context with NoonyRequest/NoonyResponse instead
 /**
  * Utility function to generate unique request IDs
  */
 function generateRequestId() {
     return `req_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
 }
-/**
- * Adapter to convert GCP Functions Request to GenericRequest
- */
-function adaptGCPRequest(gcpRequest) {
-    return {
-        method: gcpRequest.method || HttpMethod.GET,
-        url: gcpRequest.url || '/',
-        path: gcpRequest.path,
-        headers: gcpRequest.headers || {},
-        query: gcpRequest.query || {},
-        params: gcpRequest.params || {},
-        body: gcpRequest.body,
-        rawBody: gcpRequest.rawBody,
-        ip: gcpRequest.ip,
-        userAgent: gcpRequest.get?.('user-agent'),
-    };
-}
-/**
- * Adapter to convert GCP Functions Response to GenericResponse
- */
-function adaptGCPResponse(gcpResponse) {
-    let currentStatusCode = 200;
-    let isHeadersSent = false;
-    return {
-        status: (code) => {
-            currentStatusCode = code;
-            gcpResponse.status(code);
-            return adaptGCPResponse(gcpResponse);
-        },
-        json: (data) => {
-            isHeadersSent = true;
-            gcpResponse.json(data);
-        },
-        send: (data) => {
-            isHeadersSent = true;
-            gcpResponse.send(data);
-        },
-        header: (name, value) => {
-            gcpResponse.header(name, value);
-            return adaptGCPResponse(gcpResponse);
-        },
-        headers: (headers) => {
-            Object.entries(headers).forEach(([key, value]) => {
-                gcpResponse.header(key, value);
-            });
-            return adaptGCPResponse(gcpResponse);
-        },
-        end: () => {
-            isHeadersSent = true;
-            gcpResponse.end();
-        },
-        get statusCode() {
-            return gcpResponse.statusCode || currentStatusCode;
-        },
-        get headersSent() {
-            return gcpResponse.headersSent || isHeadersSent;
-        },
-    };
-}
+// Complex adapter functions removed - using smart universal adapter in Handler instead
 /**
  * Creates a context object for framework-agnostic handlers
  */

package/build/core/handler.d.ts

@@ -1,4 +1,4 @@
-import { Context, CustomRequest, CustomResponse, GenericRequest, GenericResponse } from './core';
+import { Context, NoonyRequest, NoonyResponse } from './core';
 /**
  * Interface representing a base structure for middleware with optional lifecycle methods.
  *
@@ -7,13 +7,12 @@ import { Context, CustomRequest, CustomResponse, GenericRequest, GenericResponse
  * executed before and after a process, as well as handling errors that
  * occur during the process.
  *
- * @template T - The type of the request or input context. Defaults to unknown.
- * @template U - The type of the response or output context. Defaults to unknown.
+ * @template T - The type of the request data. Defaults to unknown.
  */
-export interface BaseMiddleware<T = unknown, U = unknown> {
-    before?: (context: Context<T, U>) => Promise<void>;
-    after?: (context: Context<T, U>) => Promise<void>;
-    onError?: (error: Error, context: Context<T, U>) => Promise<void>;
+export interface BaseMiddleware<T = unknown> {
+    before?: (context: Context<T>) => Promise<void>;
+    after?: (context: Context<T>) => Promise<void>;
+    onError?: (error: Error, context: Context<T>) => Promise<void>;
 }
 /**
  * The Handler class is responsible for managing and executing middleware functions
@@ -23,6 +22,8 @@ export interface BaseMiddleware<T = unknown, U = unknown> {
  * 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>;
@@ -33,25 +34,29 @@ export interface BaseMiddleware<T = unknown, U = unknown> {
  *   .use(bodyParser())
  *   .handle(async (context) => {
  *     const { req } = context;
- *     // Handle the request
+ *     // Handle the request with type-safe access to req.validatedBody
  *   });
+ * ```
  * @template T Type for the input request data.
- * @template U Type for the additional context or response data.
  */
-export declare class Handler<T = unknown, U = unknown> {
+export declare class Handler<T = unknown> {
     private baseMiddlewares;
     private handler;
     private reversedMiddlewares;
     private errorMiddlewares;
     private middlewaresPrecomputed;
-    static use<T = unknown, U = unknown>(middleware: BaseMiddleware<T, U>): Handler<T, U>;
-    use<NewT = T, NewU = U>(middleware: BaseMiddleware<NewT, NewU>): Handler<NewT, NewU>;
-    handle(handler: (context: Context<T, U>) => Promise<void>): Handler<T, U>;
+    static use<T = unknown>(middleware: BaseMiddleware<T>): Handler<T>;
+    use(middleware: BaseMiddleware<T>): Handler<T>;
+    handle(handler: (context: Context<T>) => Promise<void>): Handler<T>;
     /**
      * Performance optimization: Pre-compute middleware arrays to avoid runtime array operations
      */
     private precomputeMiddlewareArrays;
-    execute(req: CustomRequest<T>, res: CustomResponse): Promise<void>;
+    /**
+     * Universal execute method that works with any HTTP framework
+     * Automatically detects and adapts GCP, Express, AWS Lambda, Fastify, etc.
+     */
+    execute(nativeReq: unknown, nativeRes: unknown): Promise<void>;
     /**
      * Execute before middlewares with optimized batching for independent middlewares
      */
@@ -65,8 +70,24 @@ export declare class Handler<T = unknown, U = unknown> {
      */
     private executeErrorMiddlewares;
     /**
-     * Framework-agnostic execute method that works with GenericRequest/GenericResponse
+     * Universal request adapter - converts any framework's request to NoonyRequest
+     */
+    private adaptToNoonyRequest;
+    /**
+     * Universal response adapter - converts any framework's response to NoonyResponse
+     */
+    private adaptToNoonyResponse;
+    /**
+     * Create response adapter for AWS Lambda
+     */
+    private createAWSLambdaResponse;
+    /**
+     * Create response adapter for standard HTTP frameworks (GCP, Express, Fastify)
+     */
+    private createStandardHTTPResponse;
+    /**
+     * @deprecated Use execute() instead - automatically detects framework
      */
-    executeGeneric(req: GenericRequest<T>, res: GenericResponse): Promise<void>;
+    executeGeneric(req: NoonyRequest<T>, res: NoonyResponse): Promise<void>;
 }
 //# sourceMappingURL=handler.d.ts.map

package/build/core/handler.js

@@ -1,9 +1,12 @@
 "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 removed - now using containerPool for performance
+// Container import for direct container creation (no pooling needed)
+const typedi_1 = __importDefault(require("typedi"));
 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.
@@ -12,6 +15,8 @@ const containerPool_1 = require("./containerPool");
  * 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>;
@@ -22,10 +27,10 @@ const containerPool_1 = require("./containerPool");
  *   .use(bodyParser())
  *   .handle(async (context) => {
  *     const { req } = context;
- *     // Handle the request
+ *     // Handle the request with type-safe access to req.validatedBody
  *   });
+ * ```
  * @template T Type for the input request data.
- * @template U Type for the additional context or response data.
  */
 class Handler {
     baseMiddlewares = [];
@@ -40,12 +45,9 @@ class Handler {
         return handler;
     }
     use(middleware) {
-        const handler = new Handler();
-        handler.baseMiddlewares = [
-            ...this.baseMiddlewares,
-            middleware,
-        ];
-        return handler;
+        // Simple middleware chaining without complex type transformations
+        this.baseMiddlewares.push(middleware);
+        return this;
     }
     handle(handler) {
         this.handler = handler;
@@ -63,12 +65,17 @@ class Handler {
         this.errorMiddlewares = this.reversedMiddlewares.filter((m) => m.onError);
         this.middlewaresPrecomputed = true;
     }
-    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, {
+    /**
+     * 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, {
             container,
         });
         try {
@@ -83,10 +90,7 @@ class Handler {
             // 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);
-        }
+        // No cleanup needed - container will be garbage collected automatically
     }
     /**
      * Execute before middlewares with optimized batching for independent middlewares
@@ -121,30 +125,115 @@ class Handler {
         }
     }
     /**
-     * Framework-agnostic execute method that works with GenericRequest/GenericResponse
+     * Universal request adapter - converts any framework's request to NoonyRequest
      */
-    async executeGeneric(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);
+    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
+     */
+    async executeGeneric(req, res) {
+        return this.execute(req, res);
     }
 }
 exports.Handler = Handler;

package/build/core/index.d.ts

@@ -2,7 +2,6 @@ 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,7 +18,6 @@ __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/middlewares/ConsolidatedValidationMiddleware.d.ts

@@ -0,0 +1,126 @@
+import { ZodSchema } from 'zod';
+import { BaseMiddleware, Context } from '../core';
+/**
+ * Configuration for body validation
+ */
+export interface BodyValidationConfig<T = unknown> {
+    schema?: ZodSchema<T>;
+    required?: boolean;
+    maxSize?: number;
+    allowEmpty?: boolean;
+    customValidator?: (body: unknown) => Promise<T> | T;
+}
+/**
+ * Configuration for header validation
+ */
+export interface HeaderValidationConfig {
+    required?: string[];
+    optional?: string[];
+    patterns?: Record<string, RegExp>;
+    customValidators?: Record<string, (value: string) => boolean>;
+    caseSensitive?: boolean;
+}
+/**
+ * Configuration for query parameter validation
+ */
+export interface QueryValidationConfig {
+    allowedParams?: string[];
+    requiredParams?: string[];
+    patterns?: Record<string, RegExp>;
+    maxParams?: number;
+    parseTypes?: Record<string, 'string' | 'number' | 'boolean' | 'array'>;
+}
+/**
+ * Complete configuration for ConsolidatedValidationMiddleware
+ */
+export interface ConsolidatedValidationMiddlewareConfig<T = unknown> {
+    body?: BodyValidationConfig<T>;
+    headers?: HeaderValidationConfig;
+    query?: QueryValidationConfig;
+    skipValidation?: (context: Context<T>) => boolean;
+}
+/**
+ * Consolidated ValidationMiddleware that combines body validation, header validation, and query parameter validation.
+ *
+ * This middleware replaces the need for separate:
+ * - BodyValidationMiddleware
+ * - ValidationMiddleware
+ * - HeaderVariablesMiddleware
+ *
+ * @example
+ * Complete validation setup:
+ * ```typescript
+ * const createUserSchema = z.object({
+ *   name: z.string().min(1).max(100),
+ *   email: z.string().email(),
+ *   age: z.number().min(18).max(120)
+ * });
+ *
+ * const handler = new Handler()
+ *   .use(new ConsolidatedValidationMiddleware({
+ *     body: {
+ *       schema: createUserSchema,
+ *       required: true,
+ *       maxSize: 1024 * 1024 // 1MB
+ *     },
+ *     headers: {
+ *       required: ['authorization', 'content-type'],
+ *       optional: ['x-trace-id', 'user-agent'],
+ *       patterns: {
+ *         'x-trace-id': /^[a-f0-9-]{36}$/
+ *       }
+ *     },
+ *     query: {
+ *       allowedParams: ['page', 'limit', 'sort'],
+ *       requiredParams: ['page'],
+ *       parseTypes: {
+ *         page: 'number',
+ *         limit: 'number'
+ *       }
+ *     }
+ *   }))
+ *   .handle(async (context) => {
+ *     // context.req.validatedBody is typed as z.infer<typeof createUserSchema>
+ *     const { name, email, age } = context.req.validatedBody!;
+ *     return { message: `Creating user ${name}` };
+ *   });
+ * ```
+ */
+export declare class ConsolidatedValidationMiddleware<T = unknown> implements BaseMiddleware<T> {
+    private config;
+    constructor(config?: ConsolidatedValidationMiddlewareConfig<T>);
+    before(context: Context<T>): Promise<void>;
+    private validateHeaders;
+    private validateQueryParameters;
+    private validateBody;
+    private normalizeHeaders;
+    private parseQueryParamType;
+    private isEmpty;
+    private getBodySize;
+}
+/**
+ * Factory functions for creating ConsolidatedValidationMiddleware with common configurations
+ */
+export declare const createConsolidatedValidationMiddleware: {
+    /**
+     * Body-only validation with Zod schema
+     */
+    bodyOnly: <T>(schema: ZodSchema<T>) => ConsolidatedValidationMiddleware<T>;
+    /**
+     * Headers-only validation
+     */
+    headersOnly: (required: string[], optional?: string[]) => ConsolidatedValidationMiddleware;
+    /**
+     * Query-only validation
+     */
+    queryOnly: (config: QueryValidationConfig) => ConsolidatedValidationMiddleware;
+    /**
+     * Complete validation setup
+     */
+    complete: <T>(config: ConsolidatedValidationMiddlewareConfig<T>) => ConsolidatedValidationMiddleware<T>;
+    /**
+     * API validation with common patterns
+     */
+    apiValidation: <T>(schema: ZodSchema<T>) => ConsolidatedValidationMiddleware<T>;
+};
+//# sourceMappingURL=ConsolidatedValidationMiddleware.d.ts.map