@noony-serverless/core 0.1.1 → 0.2.0

package/build/middlewares/responseWrapperMiddleware.d.ts

@@ -1,11 +1,180 @@
 import { BaseMiddleware } from '../core/handler';
 import { Context } from '../core/core';
+/**
+ * Middleware class that wraps response data in a standardized format.
+ * Automatically wraps the response with success flag, payload, and timestamp.
+ *
+ * @template T - The type of response data being wrapped
+ * @implements {BaseMiddleware}
+ *
+ * @example
+ * Basic response wrapping:
+ * ```typescript
+ * import { Handler, ResponseWrapperMiddleware, setResponseData } from '@noony-serverless/core';
+ *
+ * interface UserResponse {
+ *   id: string;
+ *   name: string;
+ *   email: string;
+ * }
+ *
+ * const getUserHandler = new Handler()
+ *   .use(new ResponseWrapperMiddleware<UserResponse>())
+ *   .handle(async (context) => {
+ *     const user = await getUser(context.params.id);
+ *     setResponseData(context, user);
+ *     // Response will be: { success: true, payload: user, timestamp: "..." }
+ *   });
+ * ```
+ *
+ * @example
+ * API response with metadata:
+ * ```typescript
+ * interface ApiResponse {
+ *   items: any[];
+ *   pagination: { page: number; total: number };
+ * }
+ *
+ * const listItemsHandler = new Handler()
+ *   .use(new ResponseWrapperMiddleware<ApiResponse>())
+ *   .handle(async (context) => {
+ *     const items = await getItems();
+ *     const response: ApiResponse = {
+ *       items,
+ *       pagination: { page: 1, total: items.length }
+ *     };
+ *     setResponseData(context, response);
+ *   });
+ * ```
+ *
+ * @example
+ * Combination with error handling:
+ * ```typescript
+ * const secureHandler = new Handler()
+ *   .use(new AuthenticationMiddleware())
+ *   .use(new ResponseWrapperMiddleware<any>())
+ *   .use(new ErrorHandlerMiddleware())
+ *   .handle(async (context) => {
+ *     const data = await getSecureData(context.user.id);
+ *     setResponseData(context, data);
+ *   });
+ * ```
+ */
 export declare class ResponseWrapperMiddleware<T> implements BaseMiddleware {
     after(context: Context): Promise<void>;
 }
+/**
+ * Factory function that creates a response wrapper middleware.
+ * Automatically wraps response data in a standardized format with success flag and timestamp.
+ *
+ * @template T - The type of response data being wrapped
+ * @returns BaseMiddleware object with response wrapping logic
+ *
+ * @example
+ * Simple API endpoint:
+ * ```typescript
+ * import { Handler, responseWrapperMiddleware, setResponseData } from '@noony-serverless/core';
+ *
+ * const healthCheckHandler = new Handler()
+ *   .use(responseWrapperMiddleware<{ status: string; uptime: number }>())
+ *   .handle(async (context) => {
+ *     setResponseData(context, {
+ *       status: 'healthy',
+ *       uptime: process.uptime()
+ *     });
+ *     // Response: { success: true, payload: { status: "healthy", uptime: 12345 }, timestamp: "..." }
+ *   });
+ * ```
+ *
+ * @example
+ * RESTful CRUD operations:
+ * ```typescript
+ * const createUserHandler = new Handler()
+ *   .use(bodyParser())
+ *   .use(responseWrapperMiddleware<{ id: string; message: string }>())
+ *   .handle(async (context) => {
+ *     const userData = context.req.parsedBody;
+ *     const newUser = await createUser(userData);
+ *     setResponseData(context, {
+ *       id: newUser.id,
+ *       message: 'User created successfully'
+ *     });
+ *   });
+ * ```
+ *
+ * @example
+ * Microservice communication:
+ * ```typescript
+ * const orderProcessingHandler = new Handler()
+ *   .use(authenticationMiddleware)
+ *   .use(responseWrapperMiddleware<{ orderId: string; status: string; estimatedDelivery: string }>())
+ *   .handle(async (context) => {
+ *     const order = await processOrder(context.req.parsedBody);
+ *     setResponseData(context, {
+ *       orderId: order.id,
+ *       status: order.status,
+ *       estimatedDelivery: order.estimatedDelivery
+ *     });
+ *   });
+ * ```
+ */
 export declare const responseWrapperMiddleware: <T>() => BaseMiddleware;
 /**
- * Helper function to set response data in context for later wrapping
+ * Helper function to set response data in context for later wrapping.
+ * This function should be used in handlers when using ResponseWrapperMiddleware.
+ *
+ * @template T - The type of data being set
+ * @param context - The request context
+ * @param data - The data to be included in the response payload
+ *
+ * @example
+ * Setting simple response data:
+ * ```typescript
+ * import { setResponseData } from '@noony-serverless/core';
+ *
+ * const handler = new Handler()
+ *   .use(responseWrapperMiddleware())
+ *   .handle(async (context) => {
+ *     const message = "Hello, World!";
+ *     setResponseData(context, { message, timestamp: new Date().toISOString() });
+ *   });
+ * ```
+ *
+ * @example
+ * Setting complex response data:
+ * ```typescript
+ * const dashboardHandler = new Handler()
+ *   .use(responseWrapperMiddleware())
+ *   .handle(async (context) => {
+ *     const stats = await getDashboardStats(context.user.id);
+ *     const notifications = await getNotifications(context.user.id);
+ *
+ *     setResponseData(context, {
+ *       user: context.user,
+ *       stats,
+ *       notifications,
+ *       lastLogin: new Date().toISOString()
+ *     });
+ *   });
+ * ```
+ *
+ * @example
+ * Conditional response data:
+ * ```typescript
+ * const userProfileHandler = new Handler()
+ *   .use(responseWrapperMiddleware())
+ *   .handle(async (context) => {
+ *     const userId = context.params.id;
+ *     const user = await getUser(userId);
+ *
+ *     if (user) {
+ *       setResponseData(context, { user, found: true });
+ *     } else {
+ *       context.res.status(404);
+ *       setResponseData(context, { message: 'User not found', found: false });
+ *     }
+ *   });
+ * ```
  */
 export declare function setResponseData<T>(context: Context, data: T): void;
 //# sourceMappingURL=responseWrapperMiddleware.d.ts.map

package/build/middlewares/responseWrapperMiddleware.js

@@ -13,12 +13,127 @@ const wrapResponse = (context) => {
         });
     }
 };
+/**
+ * Middleware class that wraps response data in a standardized format.
+ * Automatically wraps the response with success flag, payload, and timestamp.
+ *
+ * @template T - The type of response data being wrapped
+ * @implements {BaseMiddleware}
+ *
+ * @example
+ * Basic response wrapping:
+ * ```typescript
+ * import { Handler, ResponseWrapperMiddleware, setResponseData } from '@noony-serverless/core';
+ *
+ * interface UserResponse {
+ *   id: string;
+ *   name: string;
+ *   email: string;
+ * }
+ *
+ * const getUserHandler = new Handler()
+ *   .use(new ResponseWrapperMiddleware<UserResponse>())
+ *   .handle(async (context) => {
+ *     const user = await getUser(context.params.id);
+ *     setResponseData(context, user);
+ *     // Response will be: { success: true, payload: user, timestamp: "..." }
+ *   });
+ * ```
+ *
+ * @example
+ * API response with metadata:
+ * ```typescript
+ * interface ApiResponse {
+ *   items: any[];
+ *   pagination: { page: number; total: number };
+ * }
+ *
+ * const listItemsHandler = new Handler()
+ *   .use(new ResponseWrapperMiddleware<ApiResponse>())
+ *   .handle(async (context) => {
+ *     const items = await getItems();
+ *     const response: ApiResponse = {
+ *       items,
+ *       pagination: { page: 1, total: items.length }
+ *     };
+ *     setResponseData(context, response);
+ *   });
+ * ```
+ *
+ * @example
+ * Combination with error handling:
+ * ```typescript
+ * const secureHandler = new Handler()
+ *   .use(new AuthenticationMiddleware())
+ *   .use(new ResponseWrapperMiddleware<any>())
+ *   .use(new ErrorHandlerMiddleware())
+ *   .handle(async (context) => {
+ *     const data = await getSecureData(context.user.id);
+ *     setResponseData(context, data);
+ *   });
+ * ```
+ */
 class ResponseWrapperMiddleware {
     async after(context) {
         wrapResponse(context);
     }
 }
 exports.ResponseWrapperMiddleware = ResponseWrapperMiddleware;
+/**
+ * Factory function that creates a response wrapper middleware.
+ * Automatically wraps response data in a standardized format with success flag and timestamp.
+ *
+ * @template T - The type of response data being wrapped
+ * @returns BaseMiddleware object with response wrapping logic
+ *
+ * @example
+ * Simple API endpoint:
+ * ```typescript
+ * import { Handler, responseWrapperMiddleware, setResponseData } from '@noony-serverless/core';
+ *
+ * const healthCheckHandler = new Handler()
+ *   .use(responseWrapperMiddleware<{ status: string; uptime: number }>())
+ *   .handle(async (context) => {
+ *     setResponseData(context, {
+ *       status: 'healthy',
+ *       uptime: process.uptime()
+ *     });
+ *     // Response: { success: true, payload: { status: "healthy", uptime: 12345 }, timestamp: "..." }
+ *   });
+ * ```
+ *
+ * @example
+ * RESTful CRUD operations:
+ * ```typescript
+ * const createUserHandler = new Handler()
+ *   .use(bodyParser())
+ *   .use(responseWrapperMiddleware<{ id: string; message: string }>())
+ *   .handle(async (context) => {
+ *     const userData = context.req.parsedBody;
+ *     const newUser = await createUser(userData);
+ *     setResponseData(context, {
+ *       id: newUser.id,
+ *       message: 'User created successfully'
+ *     });
+ *   });
+ * ```
+ *
+ * @example
+ * Microservice communication:
+ * ```typescript
+ * const orderProcessingHandler = new Handler()
+ *   .use(authenticationMiddleware)
+ *   .use(responseWrapperMiddleware<{ orderId: string; status: string; estimatedDelivery: string }>())
+ *   .handle(async (context) => {
+ *     const order = await processOrder(context.req.parsedBody);
+ *     setResponseData(context, {
+ *       orderId: order.id,
+ *       status: order.status,
+ *       estimatedDelivery: order.estimatedDelivery
+ *     });
+ *   });
+ * ```
+ */
 const responseWrapperMiddleware = () => ({
     after: async (context) => {
         wrapResponse(context);
@@ -26,7 +141,61 @@ const responseWrapperMiddleware = () => ({
 });
 exports.responseWrapperMiddleware = responseWrapperMiddleware;
 /**
- * Helper function to set response data in context for later wrapping
+ * Helper function to set response data in context for later wrapping.
+ * This function should be used in handlers when using ResponseWrapperMiddleware.
+ *
+ * @template T - The type of data being set
+ * @param context - The request context
+ * @param data - The data to be included in the response payload
+ *
+ * @example
+ * Setting simple response data:
+ * ```typescript
+ * import { setResponseData } from '@noony-serverless/core';
+ *
+ * const handler = new Handler()
+ *   .use(responseWrapperMiddleware())
+ *   .handle(async (context) => {
+ *     const message = "Hello, World!";
+ *     setResponseData(context, { message, timestamp: new Date().toISOString() });
+ *   });
+ * ```
+ *
+ * @example
+ * Setting complex response data:
+ * ```typescript
+ * const dashboardHandler = new Handler()
+ *   .use(responseWrapperMiddleware())
+ *   .handle(async (context) => {
+ *     const stats = await getDashboardStats(context.user.id);
+ *     const notifications = await getNotifications(context.user.id);
+ *
+ *     setResponseData(context, {
+ *       user: context.user,
+ *       stats,
+ *       notifications,
+ *       lastLogin: new Date().toISOString()
+ *     });
+ *   });
+ * ```
+ *
+ * @example
+ * Conditional response data:
+ * ```typescript
+ * const userProfileHandler = new Handler()
+ *   .use(responseWrapperMiddleware())
+ *   .handle(async (context) => {
+ *     const userId = context.params.id;
+ *     const user = await getUser(userId);
+ *
+ *     if (user) {
+ *       setResponseData(context, { user, found: true });
+ *     } else {
+ *       context.res.status(404);
+ *       setResponseData(context, { message: 'User not found', found: false });
+ *     }
+ *   });
+ * ```
  */
 function setResponseData(context, data) {
     context.responseData = data;

package/build/middlewares/securityAuditMiddleware.js

@@ -161,15 +161,15 @@ class SecurityAuditMiddleware {
     options;
     constructor(options = {}) {
         this.options = {
-            logRequests: false,
-            logResponses: false,
-            logBodies: false,
-            maxBodyLogSize: 1024,
+            logRequests: options.logRequests ?? false,
+            logResponses: options.logResponses ?? false,
+            logBodies: options.logBodies ?? false,
+            maxBodyLogSize: options.maxBodyLogSize ?? 1024,
             excludeHeaders: [
                 ...DEFAULT_EXCLUDE_HEADERS,
                 ...(options.excludeHeaders || []),
             ],
-            enableAnomalyDetection: true,
+            enableAnomalyDetection: options.enableAnomalyDetection ?? true,
             onSecurityEvent: options.onSecurityEvent,
             suspiciousPatterns: {
                 ...DEFAULT_SUSPICIOUS_PATTERNS,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@noony-serverless/core",
-  "version": "0.1.1",
+  "version": "0.2.0",
   "description": "A Middy base framework compatible with Firebase and GCP Cloud Functions with TypeScript",
   "main": "build/index.js",
   "types": "build/index.d.ts",
@@ -40,17 +40,19 @@
   },
   "dependencies": {
     "@google-cloud/firestore": "^7.1.0",
-    "@google-cloud/functions-framework": "^3.3.0",
+    "@google-cloud/functions-framework": "^4.0.0",
     "@google-cloud/pubsub": "^4.1.0",
-    "@types/jsonwebtoken": "^9.0.8",
-    "axios": "^1.7.9",
-    "fastify": "^5.3.3",
-    "firebase-admin": "^12.6.0",
-    "firebase-functions": "^6.3.1",
+    "@types/jsonwebtoken": "^9.0.10",
+    "@types/qs": "^6.14.0",
+    "axios": "^1.11.0",
+    "fastify": "^5.6.0",
+    "firebase-admin": "^13.5.0",
+    "firebase-functions": "^6.4.0",
     "jsonwebtoken": "^9.0.2",
+    "qs": "^6.14.0",
     "reflect-metadata": "^0.2.2",
     "typedi": "^0.10.0",
-    "zod": "^3.22.4"
+    "zod": "^4.1.5"
   },
   "devDependencies": {
     "@types/jest": "^29.5.11",
@@ -58,7 +60,7 @@
     "@types/node": "^20.10.5",
     "@typescript-eslint/eslint-plugin": "^6.15.0",
     "@typescript-eslint/parser": "^6.15.0",
-    "concurrently": "^8.2.2",
+    "concurrently": "^9.2.1",
     "eslint": "^8.56.0",
     "eslint-config-prettier": "^9.1.0",
     "eslint-plugin-prettier": "^5.1.2",

package/build/core/containerPool.d.ts

@@ -1,44 +0,0 @@
-import Container from 'typedi';
-/**
- * Performance optimization: Container Pool for reusing TypeDI containers
- * This reduces object creation overhead and improves memory efficiency
- */
-declare class ContainerPool {
-    private availableContainers;
-    private maxPoolSize;
-    private createdContainers;
-    constructor(maxPoolSize?: number);
-    /**
-     * Get a container from the pool or create a new one
-     */
-    acquire(): Container;
-    /**
-     * Return a container to the pool for reuse
-     */
-    release(container: Container): void;
-    /**
-     * Reset container state to prevent cross-request contamination
-     * Note: TypeDI containers are isolated by default, so we mainly need
-     * to clear any manually set values
-     */
-    private resetContainer;
-    /**
-     * Get pool statistics for monitoring
-     */
-    getStats(): {
-        available: number;
-        created: number;
-        maxSize: number;
-    };
-    /**
-     * Warm up the pool by pre-creating containers
-     */
-    warmUp(count?: number): void;
-    /**
-     * Clear all containers from the pool
-     */
-    clear(): void;
-}
-declare const containerPool: ContainerPool;
-export { ContainerPool, containerPool };
-//# sourceMappingURL=containerPool.d.ts.map

package/build/core/containerPool.js

@@ -1,103 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.containerPool = exports.ContainerPool = void 0;
-const typedi_1 = __importDefault(require("typedi"));
-/**
- * Performance optimization: Container Pool for reusing TypeDI containers
- * This reduces object creation overhead and improves memory efficiency
- */
-class ContainerPool {
-    availableContainers = [];
-    maxPoolSize = 10;
-    createdContainers = 0;
-    constructor(maxPoolSize = 10) {
-        this.maxPoolSize = maxPoolSize;
-    }
-    /**
-     * Get a container from the pool or create a new one
-     */
-    acquire() {
-        if (this.availableContainers.length > 0) {
-            return this.availableContainers.pop();
-        }
-        // Create new container if pool is empty and under limit
-        if (this.createdContainers < this.maxPoolSize) {
-            this.createdContainers++;
-            return typedi_1.default.of();
-        }
-        // If pool is at capacity, create a temporary container
-        // This should rarely happen in normal usage
-        return typedi_1.default.of();
-    }
-    /**
-     * Return a container to the pool for reuse
-     */
-    release(container) {
-        if (this.availableContainers.length < this.maxPoolSize) {
-            // Reset container state by removing all instances
-            // This prevents memory leaks and cross-request contamination
-            this.resetContainer(container);
-            this.availableContainers.push(container);
-        }
-        // If pool is full, let the container be garbage collected
-    }
-    /**
-     * Reset container state to prevent cross-request contamination
-     * Note: TypeDI containers are isolated by default, so we mainly need
-     * to clear any manually set values
-     */
-    resetContainer(_container) {
-        try {
-            // For TypeDI containers created with Container.of(), each container
-            // is already isolated. We just need to ensure no memory leaks.
-            // The container will be garbage collected when released from pool
-            // if it contains too much data
-            // TypeDI containers are self-contained and don't need explicit reset
-            // This is a placeholder for future enhancements if needed
-        }
-        catch (error) {
-            // If any issues occur, don't add back to pool
-            console.warn('Failed to reset container, discarding:', error);
-        }
-    }
-    /**
-     * Get pool statistics for monitoring
-     */
-    getStats() {
-        return {
-            available: this.availableContainers.length,
-            created: this.createdContainers,
-            maxSize: this.maxPoolSize,
-        };
-    }
-    /**
-     * Warm up the pool by pre-creating containers
-     */
-    warmUp(count = 5) {
-        const warmUpCount = Math.min(count, this.maxPoolSize);
-        for (let i = 0; i < warmUpCount; i++) {
-            if (this.createdContainers < this.maxPoolSize) {
-                const container = typedi_1.default.of();
-                this.createdContainers++;
-                this.availableContainers.push(container);
-            }
-        }
-    }
-    /**
-     * Clear all containers from the pool
-     */
-    clear() {
-        this.availableContainers = [];
-        this.createdContainers = 0;
-    }
-}
-exports.ContainerPool = ContainerPool;
-// Global container pool instance
-const containerPool = new ContainerPool(15); // Slightly higher limit for serverless
-exports.containerPool = containerPool;
-// Warm up the pool for better cold start performance
-containerPool.warmUp(3);
-//# sourceMappingURL=containerPool.js.map

package/build/middlewares/validationMiddleware.d.ts

@@ -1,9 +0,0 @@
-import { BaseMiddleware, Context } from '../core';
-import { z } from 'zod';
-export declare class ValidationMiddleware implements BaseMiddleware {
-    private readonly schema;
-    constructor(schema: z.ZodSchema);
-    before(context: Context): Promise<void>;
-}
-export declare const validationMiddleware: (schema: z.ZodSchema) => BaseMiddleware;
-//# sourceMappingURL=validationMiddleware.d.ts.map

package/build/middlewares/validationMiddleware.js

@@ -1,40 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.validationMiddleware = exports.ValidationMiddleware = void 0;
-const core_1 = require("../core");
-const zod_1 = require("zod");
-const validate = async (schema, context) => {
-    try {
-        const data = context.req.method === 'GET' ? context.req.query : context.req.parsedBody;
-        const validated = await schema.parseAsync(data);
-        if (context.req.method === 'GET') {
-            context.req.query = validated;
-        }
-        else {
-            context.req.validatedBody = validated;
-        }
-    }
-    catch (error) {
-        if (error instanceof zod_1.z.ZodError) {
-            throw new core_1.ValidationError('Validation error', JSON.stringify(error.errors));
-        }
-        throw error;
-    }
-};
-class ValidationMiddleware {
-    schema;
-    constructor(schema) {
-        this.schema = schema;
-    }
-    async before(context) {
-        await validate(this.schema, context);
-    }
-}
-exports.ValidationMiddleware = ValidationMiddleware;
-const validationMiddleware = (schema) => ({
-    before: async (context) => {
-        await validate(schema, context);
-    },
-});
-exports.validationMiddleware = validationMiddleware;
-//# sourceMappingURL=validationMiddleware.js.map