@noony-serverless/core 0.4.0 → 0.4.2

package/README.md

@@ -432,11 +432,210 @@ EXPOSE 8080
 CMD ["npm", "start"]
 ```
 
+## Publishing to npm
+
+This package is published as `@noony-serverless/core` on npm. Follow these steps to publish a new version:
+
+### Prerequisites
+
+1. **npm Account**: You need an npm account. Create one at [npmjs.com/signup](https://www.npmjs.com/signup)
+2. **Organization Access**: You must have access to the `@noony-serverless` organization on npm
+   - If you own the organization, you're all set
+   - If not, you need to [create the organization](https://www.npmjs.com/org/create) first
+3. **Two-Factor Authentication**: Highly recommended for security
+
+### Publishing Steps
+
+#### 1. Login to npm
+
+```bash
+npm login
+```
+
+You'll be prompted for:
+
+- Username
+- Password
+- Email
+- One-time password (if 2FA is enabled)
+
+Verify you're logged in:
+
+```bash
+npm whoami
+```
+
+#### 2. Prepare the Package
+
+Ensure all changes are committed and tests pass:
+
+```bash
+# Run tests
+npm test
+
+# Run linter
+npm run lint
+
+# Build the package
+npm run build
+```
+
+#### 3. Update Version
+
+Update the version in `package.json` following [Semantic Versioning](https://semver.org/):
+
+```bash
+# For bug fixes (0.4.0 -> 0.4.1)
+npm version patch
+
+# For new features (0.4.0 -> 0.5.0)
+npm version minor
+
+# For breaking changes (0.4.0 -> 1.0.0)
+npm version major
+```
+
+This will:
+
+- Update `package.json` version
+- Create a git commit
+- Create a git tag
+
+#### 4. Publish to npm
+
+For scoped packages (like `@noony-serverless/core`), you must specify public access:
+
+```bash
+npm publish --access public
+```
+
+**For the first publish only**, you need the `--access public` flag. Subsequent publishes can use:
+
+```bash
+npm publish
+```
+
+#### 5. Push to Git
+
+Don't forget to push the version commit and tags:
+
+```bash
+git push && git push --tags
+```
+
+### Publishing Checklist
+
+Before publishing, verify:
+
+- [ ] All tests pass (`npm test`)
+- [ ] No linting errors (`npm run lint`)
+- [ ] Build succeeds (`npm run build`)
+- [ ] Version number updated in `package.json`
+- [ ] CHANGELOG.md updated (if applicable)
+- [ ] README.md is up to date
+- [ ] All changes committed to git
+- [ ] Logged into npm (`npm whoami`)
+
+### Troubleshooting
+
+#### Error: "Access token expired or revoked"
+
+**Solution**: Run `npm login` to re-authenticate
+
+#### Error: "404 Not Found - Not in this registry"
+
+**Solution**: For first publish of a scoped package, use:
+
+```bash
+npm publish --access public
+```
+
+#### Error: "You do not have permission to publish"
+
+**Solution**:
+
+- Verify you're logged in as the correct user
+- Check you have publish access to the `@noony-serverless` organization
+- Create the organization if it doesn't exist
+
+#### Error: "Cannot publish over existing version"
+
+**Solution**: Update the version number in `package.json` or use:
+
+```bash
+npm version patch  # or minor/major
+```
+
+#### Error: "403 Forbidden"
+
+**Solutions**:
+
+- Ensure you're logged in: `npm whoami`
+- Verify you own the package or have collaborator access
+- If this is a new scoped package, verify the organization exists
+
+### Automated Publishing with GitHub Actions
+
+For automated publishing, create `.github/workflows/publish.yml`:
+
+```yaml
+name: Publish to npm
+
+on:
+  release:
+    types: [created]
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/setup-node@v3
+        with:
+          node-version: '20'
+          registry-url: 'https://registry.npmjs.org'
+      - run: npm ci
+      - run: npm test
+      - run: npm run build
+      - run: npm publish --access public
+        env:
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
+```
+
+To use this:
+
+1. Create an npm access token at [npmjs.com/settings/tokens](https://www.npmjs.com/settings/tokens)
+2. Add it as a GitHub secret named `NPM_TOKEN`
+3. Create a GitHub release to trigger publishing
+
+### Version Management
+
+This package follows [Semantic Versioning](https://semver.org/):
+
+- **MAJOR** version (1.0.0 → 2.0.0): Breaking changes
+- **MINOR** version (1.0.0 → 1.1.0): New features, backwards compatible
+- **PATCH** version (1.0.0 → 1.0.1): Bug fixes, backwards compatible
+
+Current version: **0.4.0**
+
+### Package Distribution
+
+When published, the package includes only the `build/` directory contents:
+
+- `build/core/**/*.js` and `*.d.ts`
+- `build/middlewares/**/*.js` and `*.d.ts`
+- `build/utils/**/*.js` and `*.d.ts`
+- `build/index.js` and `index.d.ts`
+- `README.md`
+
+Source TypeScript files are not included in the npm package.
+
 ## Community & Support
 
 - 📖 [Documentation](https://github.com/noony-org/noony-serverless)
 - 🐛 [Issue Tracker](https://github.com/noony-org/noony-serverless/issues)
 - 💬 [Discussions](https://github.com/noony-org/noony-serverless/discussions)
+- 📦 [npm Package](https://www.npmjs.com/package/@noony-serverless/core)
 
 ## License
 

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.body);
-    },
-});
+const bodyValidatorMiddleware = (schema) => {
+    return {
+        before: async (context) => {
+            context.req.validatedBody = validateBody(schema, context);
+        },
+    };
+};
 exports.bodyValidatorMiddleware = bodyValidatorMiddleware;
 //# sourceMappingURL=bodyValidationMiddleware.js.map

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.0",
+  "version": "0.4.2",
   "description": "A Middy base framework compatible with Firebase and GCP Cloud Functions with TypeScript",
   "main": "build/index.js",
   "types": "build/index.d.ts",