@noony-serverless/core 0.4.1 → 0.4.3

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/bodyValidationMiddleware.js

@@ -3,9 +3,26 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.bodyValidatorMiddleware = exports.BodyValidationMiddleware = void 0;
 const zod_1 = require("zod");
 const errors_1 = require("../core/errors");
-const validateBody = async (schema, data) => {
+const fastify_wrapper_1 = require("../utils/fastify-wrapper");
+// Reusable error objects for common cases (avoid allocations)
+const VALIDATION_ERROR_INVALID_JSON = new errors_1.ValidationError('Invalid JSON in request body', [
+    {
+        code: 'custom',
+        path: [],
+        message: 'Request body must be valid JSON',
+    },
+]);
+const VALIDATION_ERROR_MISSING_BODY = new errors_1.ValidationError('Request body is required', [
+    {
+        code: 'custom',
+        path: [],
+        message: 'Request body is missing or empty',
+    },
+]);
+// Use synchronous parse for better performance (Zod's parseAsync adds overhead)
+const validateWithZod = (schema, data) => {
     try {
-        return await schema.parseAsync(data);
+        return schema.parse(data);
     }
     catch (error) {
         if (error instanceof zod_1.z.ZodError) {
@@ -14,6 +31,36 @@ const validateBody = async (schema, data) => {
         throw error;
     }
 };
+/**
+ * Comprehensive body validation function that handles retrieval from multiple sources,
+ * JSON parsing, and Zod schema validation.
+ * @internal
+ */
+const validateBody = (schema, context) => {
+    // Try to get body from the original Fastify request via WeakMap
+    // This fixes the issue where req.body becomes undefined after Handler.executeGeneric copies properties
+    const originalReq = fastify_wrapper_1.requestBodyMap.get(context.req);
+    // Fast path: check most common case first (originalReq.body)
+    let bodyData = originalReq?.body;
+    if (!bodyData) {
+        bodyData =
+            context.req.validatedBody ?? context.req.parsedBody ?? context.req.body;
+    }
+    // If no parsed body found, try the raw body string (from Cloud Functions wrapper) and parse it
+    if (!bodyData && originalReq?.__rawBody) {
+        try {
+            bodyData = JSON.parse(originalReq.__rawBody);
+        }
+        catch {
+            throw VALIDATION_ERROR_INVALID_JSON;
+        }
+    }
+    if (!bodyData) {
+        throw VALIDATION_ERROR_MISSING_BODY;
+    }
+    // Validate with Zod schema
+    return validateWithZod(schema, bodyData);
+};
 /**
  * Body validation middleware using Zod schemas for runtime type checking.
  * Validates the parsed request body against a provided Zod schema and sets
@@ -52,7 +99,7 @@ class BodyValidationMiddleware {
         this.schema = schema;
     }
     async before(context) {
-        context.req.validatedBody = await validateBody(this.schema, context.req.parsedBody);
+        context.req.validatedBody = validateBody(this.schema, context);
     }
 }
 exports.BodyValidationMiddleware = BodyValidationMiddleware;
@@ -88,11 +135,12 @@ exports.BodyValidationMiddleware = BodyValidationMiddleware;
  *   .handle(handleLogin);
  * ```
  */
-// Modified to fix type instantiation error
-const bodyValidatorMiddleware = (schema) => ({
-    before: async (context) => {
-        context.req.parsedBody = await validateBody(schema, context.req.parsedBody);
-    },
-});
+const bodyValidatorMiddleware = (schema) => {
+    return {
+        before: async (context) => {
+            context.req.validatedBody = validateBody(schema, context);
+        },
+    };
+};
 exports.bodyValidatorMiddleware = bodyValidatorMiddleware;
 //# sourceMappingURL=bodyValidationMiddleware.js.map

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,74 +1,5 @@
 import type { FastifyRequest, FastifyReply } from 'fastify';
 import { Handler } from '../core/handler';
-/**
- * Create a Fastify route handler wrapper for a Noony handler
- *
- * Wraps a Noony handler into a Fastify route handler for use with Fastify server.
- * This pattern enables running Noony handlers with Fastify's high-performance HTTP framework.
- *
- * @param noonyHandler - The Noony handler to wrap (contains middleware chain and controller)
- * @param functionName - Name for error logging purposes
- * @param initializeDependencies - Async function that initializes dependencies (database, services, etc.)
- *                                  Uses singleton pattern to prevent re-initialization across requests
- * @returns Fastify route handler: `(req: FastifyRequest, reply: FastifyReply) => Promise<void>`
- *
- * @remarks
- * This wrapper ensures:
- * - Dependencies are initialized before handler execution (singleton pattern for efficiency)
- * - Noony handlers work seamlessly with Fastify routing
- * - Errors are caught and returned as proper HTTP responses
- * - Response is not sent twice (`reply.sent` check)
- * - `RESPONSE_SENT` errors are ignored (response already sent by middleware)
- * - Real errors return 500 with generic message for security
- *
- * @example
- * Creating Fastify app with multiple routes:
- * ```typescript
- * import Fastify from 'fastify';
- * import { createFastifyHandler } from '@noony-serverless/core';
- * import { loginHandler, getConfigHandler } from './handlers';
- *
- * // Initialize dependencies once per app startup
- * let initialized = false;
- * async function initializeDependencies(): Promise<void> {
- *   if (initialized) return;
- *   const db = await databaseService.connect();
- *   await initializeServices(db);
- *   initialized = true;
- * }
- *
- * const server = Fastify({ logger: true });
- *
- * // Helper shorthand
- * const adapt = (handler, name) => createFastifyHandler(handler, name, initializeDependencies);
- *
- * // Auth routes
- * server.post('/api/auth/login', adapt(loginHandler, 'login'));
- *
- * // Config routes
- * server.get('/api/config', adapt(getConfigHandler, 'getConfig'));
- *
- * // Start server
- * server.listen({ port: 3000 }, (err) => {
- *   if (err) throw err;
- *   console.log('Server running on port 3000');
- * });
- * ```
- *
- * @example
- * Fastify routing with path parameters:
- * ```typescript
- * const server = Fastify();
- *
- * // Routes with path parameters work seamlessly
- * server.get('/api/users/:userId', adapt(getUserHandler, 'getUser'));
- * server.patch('/api/config/sections/:sectionId', adapt(updateSectionHandler, 'updateSection'));
- *
- * // Path parameters available in Noony handler via context.req.params
- * ```
- *
- * @see {@link createHttpFunction} for Cloud Functions Framework integration (production deployment)
- * @see {@link wrapNoonyHandler} for Express integration
- */
+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 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,26 +1,45 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.requestBodyMap = void 0;
 exports.createFastifyHandler = createFastifyHandler;
 const logger_1 = require("../core/logger");
+// Global WeakMap to store the original Fastify request for each GenericRequest
+// This allows middlewares to access the original request and its body
+// even after the GenericRequest properties have been copied by Handler.executeGeneric
+exports.requestBodyMap = new WeakMap();
+// Pre-allocated empty objects to avoid allocations in hot path
+const EMPTY_QUERY = Object.freeze({});
+const EMPTY_PARAMS = Object.freeze({});
 /**
  * Adapt Fastify Request to GenericRequest for Noony handlers
  *
+ * IMPORTANT: Stores the original Fastify request in a WeakMap so middlewares
+ * can access the body even after properties are copied by Handler.executeGeneric
+ *
  * @internal
  */
 function adaptFastifyRequest(req) {
-    return {
+    // Fast path: use pre-allocated empty objects when no query/params
+    const query = req.query || EMPTY_QUERY;
+    const params = req.params || EMPTY_PARAMS;
+    // Inline path extraction to avoid optional chaining overhead
+    const routeUrl = req.routeOptions?.url;
+    const path = routeUrl || req.url;
+    const genericReq = {
         method: req.method,
         url: req.url,
-        path: req.routeOptions?.url || req.url,
+        path,
         headers: req.headers,
-        query: (req.query || {}),
-        params: (req.params || {}),
+        query: query,
+        params: params,
         body: req.body,
-        // Fastify already parses the body, so set parsedBody for BodyValidationMiddleware
         parsedBody: req.body,
         ip: req.ip,
         userAgent: req.headers['user-agent'],
     };
+    // Store the original Fastify request in the WeakMap for middleware access
+    exports.requestBodyMap.set(genericReq, req);
+    return genericReq;
 }
 /**
  * Adapt Fastify Reply to GenericResponse for Noony handlers
@@ -37,11 +56,17 @@ function adaptFastifyResponse(reply) {
             return response;
         },
         json(data) {
+            // Early return if already sent (avoid duplicate sends)
+            if (reply.sent)
+                return response;
             headersSent = true;
             reply.send(data);
             return response;
         },
         send(data) {
+            // Early return if already sent (avoid duplicate sends)
+            if (reply.sent)
+                return response;
             headersSent = true;
             reply.send(data);
             return response;
@@ -51,12 +76,16 @@ function adaptFastifyResponse(reply) {
             return response;
         },
         headers(headers) {
-            Object.entries(headers).forEach(([key, value]) => {
-                reply.header(key, value);
-            });
+            // Optimized header setting - direct iteration instead of Object.entries
+            for (const key in headers) {
+                reply.header(key, headers[key]);
+            }
             return response;
         },
         end() {
+            // Early return if already sent (avoid duplicate sends)
+            if (reply.sent)
+                return;
             headersSent = true;
             reply.send();
         },
@@ -139,7 +168,19 @@ function adaptFastifyResponse(reply) {
  * @see {@link createHttpFunction} for Cloud Functions Framework integration (production deployment)
  * @see {@link wrapNoonyHandler} for Express integration
  */
+// Pre-allocated error response object to avoid allocations
+const INTERNAL_ERROR_RESPONSE = Object.freeze({
+    success: false,
+    error: Object.freeze({
+        code: 'INTERNAL_SERVER_ERROR',
+        message: 'An unexpected error occurred',
+    }),
+});
+// Constant for performance-critical string comparison
+const RESPONSE_SENT_MESSAGE = 'RESPONSE_SENT';
 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) => {
         try {
             // Ensure dependencies are initialized
@@ -151,23 +192,18 @@ function createFastifyHandler(noonyHandler, functionName, initializeDependencies
             await noonyHandler.executeGeneric(genericReq, genericRes);
         }
         catch (error) {
-            // Ignore RESPONSE_SENT markers (response already sent by middleware)
-            if (error instanceof Error && error.message === 'RESPONSE_SENT') {
+            // Fast path: check RESPONSE_SENT first (most common error to ignore)
+            if (error instanceof Error && error.message === RESPONSE_SENT_MESSAGE) {
                 return;
             }
-            logger_1.logger.error(`${functionName} handler error`, {
+            // Log error with pre-allocated prefix
+            logger_1.logger.error(errorLogPrefix, {
                 error: error instanceof Error ? error.message : 'Unknown error',
                 stack: error instanceof Error ? error.stack : undefined,
             });
             // Graceful error handling - only send if response not already sent
             if (!reply.sent) {
-                reply.code(500).send({
-                    success: false,
-                    error: {
-                        code: 'INTERNAL_SERVER_ERROR',
-                        message: 'An unexpected error occurred',
-                    },
-                });
+                reply.code(500).send(INTERNAL_ERROR_RESPONSE);
             }
         }
     };

package/package.json

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