@noony-serverless/core 0.5.3 → 0.7.0

package/build/core/handler.d.ts

@@ -23,6 +23,30 @@ 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 Type-safe handler with explicit types
+ * interface LoginRequest {
+ *   email: string;
+ *   password: string;
+ * }
+ *
+ * interface AuthUser extends BaseAuthenticatedUser {
+ *   role: 'admin' | 'user';
+ * }
+ *
+ * const handler = new Handler<LoginRequest, AuthUser>()
+ *   .use(new ErrorHandlerMiddleware<LoginRequest, AuthUser>())
+ *   .use(new BodyValidationMiddleware<LoginRequest, AuthUser>(loginSchema))
+ *   .handle(loginController);  // ✅ No 'as any' needed
+ *
+ * @example Type inference with createTypedHandler
+ * async function loginController(context: Context<LoginRequest, AuthUser>) {
+ *   // controller logic
+ * }
+ *
+ * const handler = createTypedHandler(loginController)
+ *   .use(new ErrorHandlerMiddleware())  // Types inferred
+ *   .handle(loginController);  // ✅ No 'as any' needed
+ *
  * interface MessagePayload {
  *   action: string;
  *   data: Record<string, unknown>;
@@ -45,7 +69,7 @@ export declare class Handler<T = unknown, U = unknown> {
     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>;
+    use(middleware: BaseMiddleware<T, U>): Handler<T, U>;
     handle(handler: (context: Context<T, U>) => Promise<void | unknown>): Handler<T, U>;
     /**
      * Performance optimization: Pre-compute middleware arrays to avoid runtime array operations
@@ -69,4 +93,30 @@ export declare class Handler<T = unknown, U = unknown> {
      */
     executeGeneric(req: GenericRequest<T>, res: GenericResponse): Promise<void>;
 }
+/**
+ * Helper to infer types automatically from the controller function.
+ *
+ * This helper is a permanent feature that improves Developer Experience (DX).
+ * It eliminates the need to write explicit generic type parameters when they
+ * are already defined in the controller signature.
+ *
+ * @example
+ * // Controller with explicit types
+ * async function loginController(context: Context<LoginRequest, AuthUser>) {
+ *   const { email, password } = context.req.validatedBody!;
+ *   // ... authentication logic
+ * }
+ *
+ * // Helper infers LoginRequest and AuthUser automatically
+ * const handler = createTypedHandler(loginController)
+ *   .use(new ErrorHandlerMiddleware())  // Types inferred
+ *   .use(new BodyValidationMiddleware(loginSchema))
+ *   .handle(loginController);  // ✅ Types match perfectly, no 'as any' needed
+ *
+ * @template T - The request body type (inferred from controller's Context<T, U>)
+ * @template U - The user type (inferred from controller's Context<T, U>)
+ * @param controller - The controller function with explicit Context<T, U> types
+ * @returns A new Handler instance with types inferred from the controller
+ */
+export declare function createTypedHandler<T, U>(_controller: (context: Context<T, U>) => Promise<void | unknown>): Handler<T, U>;
 //# sourceMappingURL=handler.d.ts.map

package/build/core/handler.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Handler = void 0;
+exports.createTypedHandler = createTypedHandler;
 // Container import removed - now using containerPool for performance
 const core_1 = require("./core");
 const containerPool_1 = require("./containerPool");
@@ -12,6 +13,30 @@ 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 Type-safe handler with explicit types
+ * interface LoginRequest {
+ *   email: string;
+ *   password: string;
+ * }
+ *
+ * interface AuthUser extends BaseAuthenticatedUser {
+ *   role: 'admin' | 'user';
+ * }
+ *
+ * const handler = new Handler<LoginRequest, AuthUser>()
+ *   .use(new ErrorHandlerMiddleware<LoginRequest, AuthUser>())
+ *   .use(new BodyValidationMiddleware<LoginRequest, AuthUser>(loginSchema))
+ *   .handle(loginController);  // ✅ No 'as any' needed
+ *
+ * @example Type inference with createTypedHandler
+ * async function loginController(context: Context<LoginRequest, AuthUser>) {
+ *   // controller logic
+ * }
+ *
+ * const handler = createTypedHandler(loginController)
+ *   .use(new ErrorHandlerMiddleware())  // Types inferred
+ *   .handle(loginController);  // ✅ No 'as any' needed
+ *
  * interface MessagePayload {
  *   action: string;
  *   data: Record<string, unknown>;
@@ -40,12 +65,8 @@ class Handler {
         return handler;
     }
     use(middleware) {
-        const handler = new Handler();
-        handler.baseMiddlewares = [
-            ...this.baseMiddlewares,
-            middleware,
-        ];
-        return handler;
+        this.baseMiddlewares.push(middleware);
+        return this;
     }
     handle(handler) {
         this.handler = handler;
@@ -152,4 +173,32 @@ class Handler {
     }
 }
 exports.Handler = Handler;
+/**
+ * Helper to infer types automatically from the controller function.
+ *
+ * This helper is a permanent feature that improves Developer Experience (DX).
+ * It eliminates the need to write explicit generic type parameters when they
+ * are already defined in the controller signature.
+ *
+ * @example
+ * // Controller with explicit types
+ * async function loginController(context: Context<LoginRequest, AuthUser>) {
+ *   const { email, password } = context.req.validatedBody!;
+ *   // ... authentication logic
+ * }
+ *
+ * // Helper infers LoginRequest and AuthUser automatically
+ * const handler = createTypedHandler(loginController)
+ *   .use(new ErrorHandlerMiddleware())  // Types inferred
+ *   .use(new BodyValidationMiddleware(loginSchema))
+ *   .handle(loginController);  // ✅ Types match perfectly, no 'as any' needed
+ *
+ * @template T - The request body type (inferred from controller's Context<T, U>)
+ * @template U - The user type (inferred from controller's Context<T, U>)
+ * @param controller - The controller function with explicit Context<T, U> types
+ * @returns A new Handler instance with types inferred from the controller
+ */
+function createTypedHandler(_controller) {
+    return new Handler();
+}
 //# sourceMappingURL=handler.js.map

package/build/middlewares/errorHandlerMiddleware.js

@@ -128,8 +128,8 @@ const handleError = async (error, context, options) => {
     if (DEBUG_API_RESPONSE) {
         responsePayload.payload.debug = {
             originalError: error.message,
-            stack: error.stack,
-            errorType: error.constructor?.name,
+            stack: error.stack || 'No stack trace available',
+            errorType: error.constructor?.name || 'UnknownError',
         };
     }
     context.res.status(category.httpStatus).json(responsePayload);

package/build/middlewares/responseWrapperMiddleware.d.ts

@@ -9,10 +9,14 @@ import { Context } from '../core/core';
  * @template TUser - The type of the authenticated user (preserves type chain)
  * @implements {BaseMiddleware}
  *
+ * @remarks
+ * **Important:** Do not use the deprecated `setResponseData()` helper function.
+ * Simply return values from your handler - the Handler automatically sets context.responseData.
+ *
  * @example
  * Basic response wrapping:
  * ```typescript
- * import { Handler, ResponseWrapperMiddleware, setResponseData } from '@noony-serverless/core';
+ * import { Handler, ResponseWrapperMiddleware } from '@noony-serverless/core';
  *
  * interface UserResponse {
  *   id: string;
@@ -24,7 +28,7 @@ import { Context } from '../core/core';
  *   .use(new ResponseWrapperMiddleware<UserResponse>())
  *   .handle(async (context) => {
  *     const user = await getUser(context.params.id);
- *     setResponseData(context, user);
+ *     return user;  // Handler automatically sets context.responseData
  *     // Response will be: { success: true, payload: user, timestamp: "..." }
  *   });
  * ```
@@ -41,11 +45,10 @@ import { Context } from '../core/core';
  *   .use(new ResponseWrapperMiddleware<ApiResponse>())
  *   .handle(async (context) => {
  *     const items = await getItems();
- *     const response: ApiResponse = {
+ *     return {
  *       items,
  *       pagination: { page: 1, total: items.length }
  *     };
- *     setResponseData(context, response);
  *   });
  * ```
  *
@@ -58,7 +61,7 @@ import { Context } from '../core/core';
  *   .use(new ErrorHandlerMiddleware())
  *   .handle(async (context) => {
  *     const data = await getSecureData(context.user.id);
- *     setResponseData(context, data);
+ *     return data;
  *   });
  * ```
  */
@@ -76,18 +79,22 @@ export declare class ResponseWrapperMiddleware<T = unknown, TBody = unknown, TUs
  * @template TUser - The type of the authenticated user (preserves type chain)
  * @returns BaseMiddleware object with response wrapping logic
  *
+ * @remarks
+ * **Important:** Do not use the deprecated `setResponseData()` helper function.
+ * Simply return values from your handler - the Handler automatically sets context.responseData.
+ *
  * @example
  * Simple API endpoint:
  * ```typescript
- * import { Handler, responseWrapperMiddleware, setResponseData } from '@noony-serverless/core';
+ * import { Handler, responseWrapperMiddleware } from '@noony-serverless/core';
  *
  * const healthCheckHandler = new Handler()
  *   .use(responseWrapperMiddleware<{ status: string; uptime: number }>())
  *   .handle(async (context) => {
- *     setResponseData(context, {
+ *     return {
  *       status: 'healthy',
  *       uptime: process.uptime()
- *     });
+ *     };
  *     // Response: { success: true, payload: { status: "healthy", uptime: 12345 }, timestamp: "..." }
  *   });
  * ```
@@ -101,10 +108,10 @@ export declare class ResponseWrapperMiddleware<T = unknown, TBody = unknown, TUs
  *   .handle(async (context) => {
  *     const userData = context.req.parsedBody;
  *     const newUser = await createUser(userData);
- *     setResponseData(context, {
+ *     return {
  *       id: newUser.id,
  *       message: 'User created successfully'
- *     });
+ *     };
  *   });
  * ```
  *
@@ -116,73 +123,13 @@ export declare class ResponseWrapperMiddleware<T = unknown, TBody = unknown, TUs
  *   .use(responseWrapperMiddleware<{ orderId: string; status: string; estimatedDelivery: string }>())
  *   .handle(async (context) => {
  *     const order = await processOrder(context.req.parsedBody);
- *     setResponseData(context, {
+ *     return {
  *       orderId: order.id,
  *       status: order.status,
  *       estimatedDelivery: order.estimatedDelivery
- *     });
+ *     };
  *   });
  * ```
  */
 export declare const responseWrapperMiddleware: <T = unknown, TBody = unknown, TUser = unknown>(defaultStatusCode?: number) => BaseMiddleware<TBody, TUser>;
-/**
- * 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
- * @template TBody - The type of the request body payload (preserves type chain)
- * @template TUser - The type of the authenticated user (preserves type chain)
- * @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, TBody = unknown, TUser = unknown>(context: Context<TBody, TUser>, data: T): void;
 //# sourceMappingURL=responseWrapperMiddleware.d.ts.map

package/build/middlewares/responseWrapperMiddleware.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.responseWrapperMiddleware = exports.ResponseWrapperMiddleware = void 0;
-exports.setResponseData = setResponseData;
 const wrapResponse = (context, defaultStatusCode) => {
     if (!context.res.headersSent) {
         // Use defaultStatusCode if provided, otherwise use context.res.statusCode, finally default to 200
@@ -23,10 +22,14 @@ const wrapResponse = (context, defaultStatusCode) => {
  * @template TUser - The type of the authenticated user (preserves type chain)
  * @implements {BaseMiddleware}
  *
+ * @remarks
+ * **Important:** Do not use the deprecated `setResponseData()` helper function.
+ * Simply return values from your handler - the Handler automatically sets context.responseData.
+ *
  * @example
  * Basic response wrapping:
  * ```typescript
- * import { Handler, ResponseWrapperMiddleware, setResponseData } from '@noony-serverless/core';
+ * import { Handler, ResponseWrapperMiddleware } from '@noony-serverless/core';
  *
  * interface UserResponse {
  *   id: string;
@@ -38,7 +41,7 @@ const wrapResponse = (context, defaultStatusCode) => {
  *   .use(new ResponseWrapperMiddleware<UserResponse>())
  *   .handle(async (context) => {
  *     const user = await getUser(context.params.id);
- *     setResponseData(context, user);
+ *     return user;  // Handler automatically sets context.responseData
  *     // Response will be: { success: true, payload: user, timestamp: "..." }
  *   });
  * ```
@@ -55,11 +58,10 @@ const wrapResponse = (context, defaultStatusCode) => {
  *   .use(new ResponseWrapperMiddleware<ApiResponse>())
  *   .handle(async (context) => {
  *     const items = await getItems();
- *     const response: ApiResponse = {
+ *     return {
  *       items,
  *       pagination: { page: 1, total: items.length }
  *     };
- *     setResponseData(context, response);
  *   });
  * ```
  *
@@ -72,7 +74,7 @@ const wrapResponse = (context, defaultStatusCode) => {
  *   .use(new ErrorHandlerMiddleware())
  *   .handle(async (context) => {
  *     const data = await getSecureData(context.user.id);
- *     setResponseData(context, data);
+ *     return data;
  *   });
  * ```
  */
@@ -95,18 +97,22 @@ exports.ResponseWrapperMiddleware = ResponseWrapperMiddleware;
  * @template TUser - The type of the authenticated user (preserves type chain)
  * @returns BaseMiddleware object with response wrapping logic
  *
+ * @remarks
+ * **Important:** Do not use the deprecated `setResponseData()` helper function.
+ * Simply return values from your handler - the Handler automatically sets context.responseData.
+ *
  * @example
  * Simple API endpoint:
  * ```typescript
- * import { Handler, responseWrapperMiddleware, setResponseData } from '@noony-serverless/core';
+ * import { Handler, responseWrapperMiddleware } from '@noony-serverless/core';
  *
  * const healthCheckHandler = new Handler()
  *   .use(responseWrapperMiddleware<{ status: string; uptime: number }>())
  *   .handle(async (context) => {
- *     setResponseData(context, {
+ *     return {
  *       status: 'healthy',
  *       uptime: process.uptime()
- *     });
+ *     };
  *     // Response: { success: true, payload: { status: "healthy", uptime: 12345 }, timestamp: "..." }
  *   });
  * ```
@@ -120,10 +126,10 @@ exports.ResponseWrapperMiddleware = ResponseWrapperMiddleware;
  *   .handle(async (context) => {
  *     const userData = context.req.parsedBody;
  *     const newUser = await createUser(userData);
- *     setResponseData(context, {
+ *     return {
  *       id: newUser.id,
  *       message: 'User created successfully'
- *     });
+ *     };
  *   });
  * ```
  *
@@ -135,11 +141,11 @@ exports.ResponseWrapperMiddleware = ResponseWrapperMiddleware;
  *   .use(responseWrapperMiddleware<{ orderId: string; status: string; estimatedDelivery: string }>())
  *   .handle(async (context) => {
  *     const order = await processOrder(context.req.parsedBody);
- *     setResponseData(context, {
+ *     return {
  *       orderId: order.id,
  *       status: order.status,
  *       estimatedDelivery: order.estimatedDelivery
- *     });
+ *     };
  *   });
  * ```
  */
@@ -149,66 +155,4 @@ const responseWrapperMiddleware = (defaultStatusCode) => ({
     },
 });
 exports.responseWrapperMiddleware = responseWrapperMiddleware;
-/**
- * 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
- * @template TBody - The type of the request body payload (preserves type chain)
- * @template TUser - The type of the authenticated user (preserves type chain)
- * @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;
-}
 //# sourceMappingURL=responseWrapperMiddleware.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@noony-serverless/core",
-  "version": "0.5.3",
+  "version": "0.7.0",
   "description": "A Middy base framework compatible with Firebase and GCP Cloud Functions with TypeScript",
   "main": "build/index.js",
   "types": "build/index.d.ts",
@@ -41,49 +41,49 @@
     "format:check": "prettier --check \"src/**/*.{ts,js,json}\""
   },
   "dependencies": {
-    "@google-cloud/firestore": "^7.1.0",
+    "@google-cloud/firestore": "^8.2.0",
     "@google-cloud/functions-framework": "^5.0.0",
-    "@google-cloud/pubsub": "^4.1.0",
+    "@google-cloud/pubsub": "^5.2.2",
     "@types/jsonwebtoken": "^9.0.10",
     "axios": "^1.11.0",
-    "fastify": "^5.6.0",
-    "firebase-admin": "^13.5.0",
-    "firebase-functions": "^6.4.0",
-    "jsonwebtoken": "^9.0.2",
+    "fastify": "^5.7.1",
+    "firebase-admin": "^13.6.0",
+    "firebase-functions": "^6.6.0",
+    "jsonwebtoken": "^9.0.3",
     "reflect-metadata": "^0.2.2",
     "typedi": "^0.10.0",
-    "zod": "^4.1.5"
+    "zod": "^4.3.5"
   },
   "devDependencies": {
-    "@types/jest": "^29.5.11",
+    "@types/jest": "^29.5.14",
     "@types/module-alias": "^2.0.4",
-    "@types/node": "^20.10.5",
-    "@typescript-eslint/eslint-plugin": "^6.15.0",
-    "@typescript-eslint/parser": "^6.15.0",
+    "@types/node": "^20.19.30",
+    "@typescript-eslint/eslint-plugin": "^6.21.0",
+    "@typescript-eslint/parser": "^6.21.0",
     "concurrently": "^9.2.1",
-    "eslint": "^8.56.0",
-    "eslint-config-prettier": "^9.1.0",
-    "eslint-plugin-prettier": "^5.1.2",
-    "firebase-functions-test": "^3.1.0",
+    "eslint": "^8.57.1",
+    "eslint-config-prettier": "^9.1.2",
+    "eslint-plugin-prettier": "^5.5.5",
+    "firebase-functions-test": "^3.4.1",
     "jest": "^29.7.0",
     "module-alias": "^2.2.3",
-    "prettier": "^3.1.1",
-    "ts-jest": "^29.1.1",
-    "typescript": "^5.3.3"
+    "prettier": "^3.8.0",
+    "ts-jest": "^29.4.6",
+    "typescript": "^5.9.3"
   },
   "peerDependencies": {
     "@google-cloud/opentelemetry-cloud-trace-propagator": "^0.21.0",
     "@opentelemetry/api": "^1.9.0",
-    "@opentelemetry/auto-instrumentations-node": "^0.200.0",
-    "@opentelemetry/core": "^2.0.0",
-    "@opentelemetry/exporter-metrics-otlp-http": "^0.205.0",
-    "@opentelemetry/exporter-trace-otlp-http": "^0.205.0",
-    "@opentelemetry/instrumentation-http": "^0.200.0",
-    "@opentelemetry/resources": "^2.0.0",
-    "@opentelemetry/sdk-node": "^2.0.0",
-    "@opentelemetry/semantic-conventions": "^1.28.0",
-    "dd-trace": "^5.0.0",
-    "newrelic": "^12.0.0"
+    "@opentelemetry/auto-instrumentations-node": "^0.210.0",
+    "@opentelemetry/core": "^2.4.0",
+    "@opentelemetry/exporter-metrics-otlp-http": "^0.210.0",
+    "@opentelemetry/exporter-trace-otlp-http": "^0.210.0",
+    "@opentelemetry/instrumentation-http": "^0.210.0",
+    "@opentelemetry/resources": "^2.4.0",
+    "@opentelemetry/sdk-node": "^2.4.0",
+    "@opentelemetry/semantic-conventions": "^1.39.0",
+    "dd-trace": "^5.82.0",
+    "newrelic": "^13.10.0"
   },
   "peerDependenciesMeta": {
     "@google-cloud/opentelemetry-cloud-trace-propagator": {
@@ -124,12 +124,12 @@
     }
   },
   "private": false,
-  "overrides": {
-    "body-parser": "2.2.2"
-  },
   "optionalDependencies": {
     "@google-cloud/opentelemetry-cloud-trace-propagator": "^0.21.0"
   },
+  "overrides": {
+    "body-parser": "^2.2.2"
+  },
   "directories": {
     "doc": "docs",
     "example": "examples"