@noony-serverless/core 0.4.2 → 0.4.4

package/build/core/handler.d.ts

@@ -46,7 +46,7 @@ export declare class Handler<T = unknown, U = unknown> {
     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>;
+    handle(handler: (context: Context<T, U>) => Promise<void | unknown>): Handler<T, U>;
     /**
      * Performance optimization: Pre-compute middleware arrays to avoid runtime array operations
      */

package/build/core/handler.js

@@ -74,7 +74,12 @@ class Handler {
         try {
             // Execute before middlewares with performance optimizations
             await this.executeBeforeMiddlewares(context);
-            await this.handler(context);
+            // Capture return value from handler
+            const returnValue = await this.handler(context);
+            // If handler returns a value and responseData hasn't been set, use the return value
+            if (returnValue !== undefined && !context.responseData) {
+                context.responseData = returnValue;
+            }
             // Execute after middlewares in reverse order using pre-computed array
             await this.executeAfterMiddlewares(context);
         }
@@ -129,7 +134,12 @@ class Handler {
         try {
             // Execute before middlewares with performance optimizations
             await this.executeBeforeMiddlewares(context);
-            await this.handler(context);
+            // Capture return value from handler
+            const returnValue = await this.handler(context);
+            // If handler returns a value and responseData hasn't been set, use the return value
+            if (returnValue !== undefined && !context.responseData) {
+                context.responseData = returnValue;
+            }
             // Execute after middlewares in reverse order using pre-computed array
             await this.executeAfterMiddlewares(context);
         }

package/build/middlewares/responseWrapperMiddleware.d.ts

@@ -63,6 +63,8 @@ import { Context } from '../core/core';
  * ```
  */
 export declare class ResponseWrapperMiddleware<T = unknown, TBody = unknown, TUser = unknown> implements BaseMiddleware<TBody, TUser> {
+    private defaultStatusCode?;
+    constructor(defaultStatusCode?: number | undefined);
     after(context: Context<TBody, TUser>): Promise<void>;
 }
 /**
@@ -122,7 +124,7 @@ export declare class ResponseWrapperMiddleware<T = unknown, TBody = unknown, TUs
  *   });
  * ```
  */
-export declare const responseWrapperMiddleware: <T = unknown, TBody = unknown, TUser = unknown>() => BaseMiddleware<TBody, TUser>;
+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.

package/build/middlewares/responseWrapperMiddleware.js

@@ -2,9 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.responseWrapperMiddleware = exports.ResponseWrapperMiddleware = void 0;
 exports.setResponseData = setResponseData;
-const wrapResponse = (context) => {
+const wrapResponse = (context, defaultStatusCode) => {
     if (!context.res.headersSent) {
-        const statusCode = context.res.statusCode || 200;
+        // Use defaultStatusCode if provided, otherwise use context.res.statusCode, finally default to 200
+        const statusCode = defaultStatusCode || context.res.statusCode || 200;
         const body = context.responseData;
         context.res.status(statusCode).json({
             success: true,
@@ -76,8 +77,12 @@ const wrapResponse = (context) => {
  * ```
  */
 class ResponseWrapperMiddleware {
+    defaultStatusCode;
+    constructor(defaultStatusCode) {
+        this.defaultStatusCode = defaultStatusCode;
+    }
     async after(context) {
-        wrapResponse(context);
+        wrapResponse(context, this.defaultStatusCode);
     }
 }
 exports.ResponseWrapperMiddleware = ResponseWrapperMiddleware;
@@ -138,9 +143,9 @@ exports.ResponseWrapperMiddleware = ResponseWrapperMiddleware;
  *   });
  * ```
  */
-const responseWrapperMiddleware = () => ({
+const responseWrapperMiddleware = (defaultStatusCode) => ({
     after: async (context) => {
-        wrapResponse(context);
+        wrapResponse(context, defaultStatusCode);
     },
 });
 exports.responseWrapperMiddleware = responseWrapperMiddleware;

package/build/utils/fastify-wrapper.d.ts

@@ -1,5 +1,16 @@
 import type { FastifyRequest, FastifyReply } from 'fastify';
 import { Handler } from '../core/handler';
 export declare const requestBodyMap: WeakMap<any, FastifyRequest<import("fastify").RouteGenericInterface, import("fastify").RawServerDefault, import("http").IncomingMessage, import("fastify").FastifySchema, import("fastify").FastifyTypeProviderDefault, unknown, import("fastify").FastifyBaseLogger, import("fastify/types/type-provider").ResolveFastifyRequestType<import("fastify").FastifyTypeProviderDefault, import("fastify").FastifySchema, import("fastify").RouteGenericInterface>>>;
+export interface CloudFunctionRequest {
+    method?: string;
+    body?: unknown;
+    url?: string;
+    headers?: Record<string, string | string[] | undefined>;
+    __rawBody?: string;
+    rawBody?: string | Buffer;
+    readableEnded?: boolean;
+    complete?: boolean;
+}
+export declare function extractAndStoreRequestBody(req: CloudFunctionRequest): void;
 export declare function createFastifyHandler(noonyHandler: Handler<unknown>, functionName: string, initializeDependencies: () => Promise<void>): (req: FastifyRequest, reply: FastifyReply) => Promise<void>;
 //# sourceMappingURL=fastify-wrapper.d.ts.map

package/build/utils/fastify-wrapper.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.requestBodyMap = void 0;
+exports.extractAndStoreRequestBody = extractAndStoreRequestBody;
 exports.createFastifyHandler = createFastifyHandler;
 const logger_1 = require("../core/logger");
 // Global WeakMap to store the original Fastify request for each GenericRequest
@@ -178,10 +179,49 @@ const INTERNAL_ERROR_RESPONSE = Object.freeze({
 });
 // Constant for performance-critical string comparison
 const RESPONSE_SENT_MESSAGE = 'RESPONSE_SENT';
+// Helper: Extract and store request body for later use
+function extractAndStoreRequestBody(req) {
+    if (!['POST', 'PUT', 'PATCH'].includes(req.method || '')) {
+        return;
+    }
+    // Check if already has __rawBody from previous processing
+    if (req.__rawBody) {
+        return;
+    }
+    const body = req.body;
+    if (!body)
+        return;
+    // Use safe JSON stringify to handle circular references
+    try {
+        req.__rawBody = typeof body === 'string' ? body : JSON.stringify(body);
+    }
+    catch (error) {
+        // If circular reference or other serialization error, skip storing __rawBody
+        if (process.env.NODE_ENV === 'development') {
+            logger_1.logger.debug('[helper] Failed to stringify body, skipping __rawBody storage', {
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+        return;
+    }
+    if (process.env.NODE_ENV === 'development') {
+        logger_1.logger.debug('[helper] Extracted and stored __rawBody', {
+            bodyLength: req.__rawBody.length,
+            bodyType: typeof body,
+        });
+    }
+}
 function createFastifyHandler(noonyHandler, functionName, initializeDependencies) {
     // Pre-bind the error log prefix to avoid string concatenation in hot path
     const errorLogPrefix = `${functionName} handler error`;
     return async (req, reply) => {
+        const requestId = `${Date.now()}-${Math.random().toString(36).substring(2, 11)}`;
+        console.log(`[FASTIFY-WRAPPER] ${errorLogPrefix} called`, {
+            requestId,
+            url: req.url,
+            method: req.method,
+            timestamp: new Date().toISOString(),
+        });
         try {
             // Ensure dependencies are initialized
             await initializeDependencies();
@@ -190,6 +230,10 @@ function createFastifyHandler(noonyHandler, functionName, initializeDependencies
             const genericRes = adaptFastifyResponse(reply);
             // Execute Noony handler with adapted request/response
             await noonyHandler.executeGeneric(genericReq, genericRes);
+            console.log(`[FASTIFY-WRAPPER] ${errorLogPrefix} completed`, {
+                requestId,
+                timestamp: new Date().toISOString(),
+            });
         }
         catch (error) {
             // Fast path: check RESPONSE_SENT first (most common error to ignore)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@noony-serverless/core",
-  "version": "0.4.2",
+  "version": "0.4.4",
   "description": "A Middy base framework compatible with Firebase and GCP Cloud Functions with TypeScript",
   "main": "build/index.js",
   "types": "build/index.d.ts",