@noony-serverless/core 0.1.5 → 0.2.1

package/README.md

@@ -9,7 +9,7 @@ A powerful and flexible serverless middleware framework for Google Cloud Functio
 The `Handler` class manages the middleware execution pipeline with `before`, `after`, and `onError` lifecycle hooks:
 
 ```typescript
-const handler = new Handler<RequestType, UserType>()
+const handler = new Handler<RequestType>()
   .use(errorHandler())
   .use(bodyParser())
   .use(bodyValidator(schema))
@@ -23,7 +23,7 @@ const handler = new Handler<RequestType, UserType>()
 The context system provides full TypeScript support with generic typing:
 
 ```typescript
-interface Context<T = unknown, U = unknown> {
+interface Context<T = unknown> {
   req: CustomRequest<T>;     // Request with parsedBody and validatedBody
   res: CustomResponse;       // Response object
   container?: Container;     // TypeDI dependency injection
@@ -72,7 +72,7 @@ const userSchema = z.object({
 type UserRequest = z.infer<typeof userSchema>;
 
 // Create handler with full type safety
-const createUserHandler = new Handler<UserRequest, unknown>()
+const createUserHandler = new Handler<UserRequest>()
   .use(new ErrorHandlerMiddleware())
   .use(new BodyValidationMiddleware(userSchema))
   .use(new ResponseWrapperMiddleware())
@@ -117,7 +117,7 @@ const messageSchema = z.object({
 type PubSubMessage = z.infer<typeof messageSchema>;
 
 // Create Pub/Sub handler
-const pubsubHandler = new Handler<PubSubMessage, unknown>()
+const pubsubHandler = new Handler<PubSubMessage>()
   .use(new ErrorHandlerMiddleware())
   .use(new BodyParserMiddleware()) // Decodes base64 Pub/Sub messages
   .use(new BodyValidationMiddleware(messageSchema))
@@ -296,7 +296,7 @@ app.post('/users', async (req, res) => {
 ### 1. Middleware Order
 
 ```typescript
-const handler = new Handler<RequestType, UserType>()
+const handler = new Handler<RequestType>()
   .use(new ErrorHandlerMiddleware())        // Always first
   .use(new HeaderVariablesMiddleware(...))  // Required headers
   .use(new AuthenticationMiddleware(...))   // Authentication
@@ -324,7 +324,7 @@ interface UserContext {
 }
 
 // Use throughout the handler
-const handler = new Handler<UserRequest, UserContext>();
+const handler = new Handler<UserRequest>();
 ```
 
 ### 3. Error Handling
@@ -361,7 +361,7 @@ import {
 } from '@noony/serverless';
 
 // No type casting needed with proper generics
-const handler = new Handler<UserRequest, UserContext>()
+const handler = new Handler<UserRequest>()
   .handle(async (context) => {
     // TypeScript knows validatedBody is UserRequest
     const { name, email } = context.req.validatedBody!;

package/build/core/core.d.ts

@@ -1,5 +1,4 @@
-import { Request, Response } from '@google-cloud/functions-framework';
-import Container from 'typedi';
+import { ContainerInstance } 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;
-    container?: Container;
+export interface Context<T = unknown> {
+    readonly req: NoonyRequest<T>;
+    readonly res: NoonyResponse;
+    container?: ContainerInstance;
     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

@@ -1,14 +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.HttpMethod = void 0;
 exports.generateRequestId = generateRequestId;
-exports.adaptGCPRequest = adaptGCPRequest;
-exports.adaptGCPResponse = adaptGCPResponse;
 exports.createContext = createContext;
-const typedi_1 = __importDefault(require("typedi"));
+const typedi_1 = require("typedi");
 /**
  * Framework-agnostic HTTP method enum
  */
@@ -22,71 +17,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;
-        },
-    };
+    return `req_${Date.now()}_${Math.random().toString(36).substring(2, 11)}`;
 }
+// Complex adapter functions removed - using smart universal adapter in Handler instead
 /**
  * Creates a context object for framework-agnostic handlers
  */
@@ -94,7 +32,7 @@ function createContext(req, res, options = {}) {
     return {
         req,
         res,
-        container: options.container || typedi_1.default.of(),
+        container: options.container || typedi_1.Container.of(),
         error: options.error || null,
         businessData: options.businessData || new Map(),
         user: options.user,

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