@noony-serverless/core 0.1.0

package/build/core/core.js

@@ -0,0 +1,107 @@
+"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"));
+/**
+ * Framework-agnostic HTTP method enum
+ */
+var HttpMethod;
+(function (HttpMethod) {
+    HttpMethod["GET"] = "GET";
+    HttpMethod["POST"] = "POST";
+    HttpMethod["PUT"] = "PUT";
+    HttpMethod["DELETE"] = "DELETE";
+    HttpMethod["PATCH"] = "PATCH";
+    HttpMethod["OPTIONS"] = "OPTIONS";
+    HttpMethod["HEAD"] = "HEAD";
+})(HttpMethod || (exports.HttpMethod = HttpMethod = {}));
+/**
+ * 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;
+        },
+    };
+}
+/**
+ * Creates a context object for framework-agnostic handlers
+ */
+function createContext(req, res, options = {}) {
+    return {
+        req,
+        res,
+        container: options.container || typedi_1.default.of(),
+        error: options.error || null,
+        businessData: options.businessData || new Map(),
+        user: options.user,
+        startTime: options.startTime || Date.now(),
+        requestId: options.requestId || generateRequestId(),
+        timeoutSignal: options.timeoutSignal,
+        responseData: options.responseData,
+    };
+}
+//# sourceMappingURL=core.js.map

package/build/core/errors.d.ts

@@ -0,0 +1,25 @@
+export declare class HttpError extends Error {
+    status: number;
+    code?: string;
+    details?: unknown;
+    constructor(status: number, message: string, code?: string, details?: unknown);
+}
+export declare class ValidationError extends HttpError {
+    constructor(message: string, details?: unknown);
+}
+export declare class AuthenticationError extends HttpError {
+    constructor(message?: string);
+}
+export declare class BusinessError extends HttpError {
+    constructor(message: string, status?: number, details?: unknown);
+}
+export declare class SecurityError extends HttpError {
+    constructor(message?: string, details?: unknown);
+}
+export declare class TimeoutError extends HttpError {
+    constructor(message?: string, details?: unknown);
+}
+export declare class TooLargeError extends HttpError {
+    constructor(message?: string, details?: unknown);
+}
+//# sourceMappingURL=errors.d.ts.map

package/build/core/errors.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TooLargeError = exports.TimeoutError = exports.SecurityError = exports.BusinessError = exports.AuthenticationError = exports.ValidationError = exports.HttpError = void 0;
+class HttpError extends Error {
+    status;
+    code;
+    details;
+    constructor(status, message, code, details) {
+        super(message);
+        this.status = status;
+        this.code = code;
+        this.details = details;
+        this.name = 'HttpError';
+    }
+}
+exports.HttpError = HttpError;
+class ValidationError extends HttpError {
+    constructor(message, details) {
+        super(400, message, 'VALIDATION_ERROR', details);
+        this.name = 'ValidationError';
+    }
+}
+exports.ValidationError = ValidationError;
+class AuthenticationError extends HttpError {
+    constructor(message = 'Unauthorized') {
+        super(401, message, 'AUTHENTICATION_ERROR');
+        this.name = 'AuthenticationError';
+    }
+}
+exports.AuthenticationError = AuthenticationError;
+class BusinessError extends HttpError {
+    constructor(message, status = 500, details) {
+        super(status, message, 'BUSINESS_ERROR', details);
+        this.name = 'BusinessError';
+    }
+}
+exports.BusinessError = BusinessError;
+class SecurityError extends HttpError {
+    constructor(message = 'Security violation detected', details) {
+        super(403, message, 'SECURITY_ERROR', details);
+        this.name = 'SecurityError';
+    }
+}
+exports.SecurityError = SecurityError;
+class TimeoutError extends HttpError {
+    constructor(message = 'Request timeout', details) {
+        super(408, message, 'TIMEOUT_ERROR', details);
+        this.name = 'TimeoutError';
+    }
+}
+exports.TimeoutError = TimeoutError;
+class TooLargeError extends HttpError {
+    constructor(message = 'Request entity too large', details) {
+        super(413, message, 'TOO_LARGE_ERROR', details);
+        this.name = 'TooLargeError';
+    }
+}
+exports.TooLargeError = TooLargeError;
+//# sourceMappingURL=errors.js.map

package/build/core/handler.d.ts

@@ -0,0 +1,72 @@
+import { Context, CustomRequest, CustomResponse, GenericRequest, GenericResponse } from './core';
+/**
+ * Interface representing a base structure for middleware with optional lifecycle methods.
+ *
+ * This interface is designed to provide hooks for execution during different
+ * stages of a middleware's lifecycle. It allows for defining logic to be
+ * 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.
+ */
+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>;
+}
+/**
+ * The Handler class is responsible for managing and executing middleware functions
+ * and a main handler function in a sequential and controlled manner.
+ *
+ * This class provides a mechanism for registering middlewares that can
+ * process a request/response flow either before the main handler (via `before`),
+ * after the main handler (via `after`), or handle errors (via `onError`).
+ *
+ * interface MessagePayload {
+ *   action: string;
+ *   data: Record<string, unknown>;
+ * }
+ *
+ * const handler = new Handler<MessagePayload>()
+ *   .use(errorHandler())
+ *   .use(bodyParser())
+ *   .handle(async (context) => {
+ *     const { req } = context;
+ *     // Handle the request
+ *   });
+ * @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> {
+    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>;
+    /**
+     * Performance optimization: Pre-compute middleware arrays to avoid runtime array operations
+     */
+    private precomputeMiddlewareArrays;
+    execute(req: CustomRequest<T>, res: CustomResponse): Promise<void>;
+    /**
+     * Execute before middlewares with optimized batching for independent middlewares
+     */
+    private executeBeforeMiddlewares;
+    /**
+     * Execute after middlewares using pre-computed reversed array
+     */
+    private executeAfterMiddlewares;
+    /**
+     * Execute error middlewares using pre-computed array
+     */
+    private executeErrorMiddlewares;
+    /**
+     * Framework-agnostic execute method that works with GenericRequest/GenericResponse
+     */
+    executeGeneric(req: GenericRequest<T>, res: GenericResponse): Promise<void>;
+}
+//# sourceMappingURL=handler.d.ts.map

package/build/core/handler.js

@@ -0,0 +1,151 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Handler = void 0;
+// 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.
+ *
+ * This class provides a mechanism for registering middlewares that can
+ * process a request/response flow either before the main handler (via `before`),
+ * after the main handler (via `after`), or handle errors (via `onError`).
+ *
+ * interface MessagePayload {
+ *   action: string;
+ *   data: Record<string, unknown>;
+ * }
+ *
+ * const handler = new Handler<MessagePayload>()
+ *   .use(errorHandler())
+ *   .use(bodyParser())
+ *   .handle(async (context) => {
+ *     const { req } = context;
+ *     // Handle the request
+ *   });
+ * @template T Type for the input request data.
+ * @template U Type for the additional context or response data.
+ */
+class Handler {
+    baseMiddlewares = [];
+    handler;
+    // Performance optimization: Pre-computed middleware arrays
+    reversedMiddlewares = [];
+    errorMiddlewares = [];
+    middlewaresPrecomputed = false;
+    static use(middleware) {
+        const handler = new Handler();
+        handler.baseMiddlewares.push(middleware);
+        return handler;
+    }
+    use(middleware) {
+        const handler = new Handler();
+        handler.baseMiddlewares = [
+            ...this.baseMiddlewares,
+            middleware,
+        ];
+        return handler;
+    }
+    handle(handler) {
+        this.handler = handler;
+        this.precomputeMiddlewareArrays();
+        return this;
+    }
+    /**
+     * Performance optimization: Pre-compute middleware arrays to avoid runtime array operations
+     */
+    precomputeMiddlewareArrays() {
+        if (this.middlewaresPrecomputed)
+            return;
+        // Pre-compute reversed array for after/error middlewares
+        this.reversedMiddlewares = [...this.baseMiddlewares].reverse();
+        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, {
+            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);
+        }
+    }
+    /**
+     * Execute before middlewares with optimized batching for independent middlewares
+     */
+    async executeBeforeMiddlewares(context) {
+        // For backward compatibility and simpler logic, execute all before middlewares in order
+        for (const middleware of this.baseMiddlewares) {
+            if (middleware.before) {
+                await middleware.before(context);
+            }
+        }
+    }
+    /**
+     * Execute after middlewares using pre-computed reversed array
+     */
+    async executeAfterMiddlewares(context) {
+        // For backward compatibility and simpler logic, execute all after middlewares in reverse order
+        for (const middleware of this.reversedMiddlewares) {
+            if (middleware.after) {
+                await middleware.after(context);
+            }
+        }
+    }
+    /**
+     * Execute error middlewares using pre-computed array
+     */
+    async executeErrorMiddlewares(error, context) {
+        for (const middleware of this.errorMiddlewares) {
+            if (middleware.onError) {
+                await middleware.onError(error, context);
+            }
+        }
+    }
+    /**
+     * Framework-agnostic execute method that works with GenericRequest/GenericResponse
+     */
+    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);
+        }
+    }
+}
+exports.Handler = Handler;
+//# sourceMappingURL=handler.js.map

package/build/core/index.d.ts

@@ -0,0 +1,8 @@
+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

@@ -0,0 +1,24 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+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 });
+__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/core/logger.d.ts

@@ -0,0 +1,42 @@
+export interface LogOptions {
+    structuredData?: boolean;
+    [key: string]: boolean | string | number | object | undefined;
+}
+declare class Logger {
+    private logDataPool;
+    private isDebugEnabled;
+    private timestampCache;
+    private lastTimestamp;
+    constructor();
+    /**
+     * Performance optimized timestamp generation with caching
+     * Cache timestamps for up to 1 second to reduce Date object creation
+     */
+    private getTimestamp;
+    /**
+     * Optimized log method with object pooling and lazy evaluation
+     */
+    private log;
+    /**
+     * Performance optimized logging methods with level checks
+     */
+    info(message: string, options?: LogOptions): void;
+    error(message: string, options?: LogOptions): void;
+    warn(message: string, options?: LogOptions): void;
+    debug(message: string, options?: LogOptions): void;
+    /**
+     * Performance monitoring method for internal framework use
+     */
+    logPerformance(operation: string, duration: number, metadata?: Record<string, unknown>): void;
+    /**
+     * Get logger statistics for monitoring
+     */
+    getStats(): {
+        poolSize: number;
+        maxPoolSize: number;
+        debugEnabled: boolean;
+    };
+}
+export declare const logger: Logger;
+export { Logger };
+//# sourceMappingURL=logger.d.ts.map

package/build/core/logger.js

@@ -0,0 +1,135 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Logger = exports.logger = void 0;
+// Performance optimization: Object pool for log data to reduce GC pressure
+class LogDataPool {
+    pool = [];
+    maxPoolSize = 50;
+    acquire() {
+        return (this.pool.pop() || {
+            timestamp: '',
+            level: 'info',
+            message: '',
+        });
+    }
+    release(logData) {
+        if (this.pool.length < this.maxPoolSize) {
+            // Reset object properties
+            logData.timestamp = '';
+            logData.level = 'info';
+            logData.message = '';
+            // Remove any additional properties
+            const keys = Object.keys(logData);
+            for (let i = 3; i < keys.length; i++) {
+                delete logData[keys[i]];
+            }
+            this.pool.push(logData);
+        }
+    }
+}
+// Performance optimization: Dynamic method references for testing compatibility
+const getLogMethod = (level) => {
+    switch (level) {
+        case 'error':
+            return console.error;
+        case 'warn':
+            return console.warn;
+        case 'debug':
+            return console.debug;
+        default:
+            return console.log;
+    }
+};
+class Logger {
+    logDataPool = new LogDataPool();
+    isDebugEnabled;
+    timestampCache = '';
+    lastTimestamp = 0;
+    constructor() {
+        // Performance optimization: Cache debug mode check
+        this.isDebugEnabled =
+            process.env.NODE_ENV === 'development' ||
+                process.env.DEBUG === 'true' ||
+                process.env.LOG_LEVEL === 'debug';
+    }
+    /**
+     * Performance optimized timestamp generation with caching
+     * Cache timestamps for up to 1 second to reduce Date object creation
+     */
+    getTimestamp() {
+        const now = Date.now();
+        // Cache timestamp for 1 second to reduce object creation
+        if (now - this.lastTimestamp > 1000) {
+            this.timestampCache = new Date(now).toISOString();
+            this.lastTimestamp = now;
+        }
+        return this.timestampCache;
+    }
+    /**
+     * Optimized log method with object pooling and lazy evaluation
+     */
+    log(level, message, options) {
+        // Performance optimization: Early return for debug logs in production
+        if (level === 'debug' && !this.isDebugEnabled) {
+            return;
+        }
+        const logData = this.logDataPool.acquire();
+        // Performance optimization: Lazy timestamp generation
+        logData.timestamp = this.getTimestamp();
+        logData.level = level;
+        logData.message = message;
+        // Add options if provided
+        if (options) {
+            Object.assign(logData, options);
+        }
+        // Use dynamic method reference for testing compatibility
+        const logMethod = getLogMethod(level);
+        // For testing: create a copy of the data to avoid pool interference
+        const logDataCopy = { ...logData };
+        logMethod(logDataCopy);
+        // Always return object to pool
+        this.logDataPool.release(logData);
+    }
+    /**
+     * Performance optimized logging methods with level checks
+     */
+    info(message, options) {
+        this.log('info', message, options);
+    }
+    error(message, options) {
+        this.log('error', message, options);
+    }
+    warn(message, options) {
+        this.log('warn', message, options);
+    }
+    debug(message, options) {
+        // Performance optimization: Early return for debug in production
+        if (!this.isDebugEnabled)
+            return;
+        this.log('debug', message, options);
+    }
+    /**
+     * Performance monitoring method for internal framework use
+     */
+    logPerformance(operation, duration, metadata) {
+        if (this.isDebugEnabled) {
+            this.debug(`Performance: ${operation}`, {
+                duration: `${duration}ms`,
+                ...metadata,
+            });
+        }
+    }
+    /**
+     * Get logger statistics for monitoring
+     */
+    getStats() {
+        return {
+            poolSize: this.logDataPool['pool'].length,
+            maxPoolSize: this.logDataPool['maxPoolSize'],
+            debugEnabled: this.isDebugEnabled,
+        };
+    }
+}
+exports.Logger = Logger;
+exports.logger = new Logger();
+//# sourceMappingURL=logger.js.map