@xeno-js/vercel 0.0.0-stage → 1.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Xeno.JS
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,255 @@
-# Temporary Holding Version
+<div align="center">
+  <img src="logo/logo.png" alt="Xeno.JS Logo" width="140" />
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+  <h1>Xeno.JS Vercel</h1>
+  <p><strong>A Typescript application framework architecture for Node.js, designed for lower technical debt, and faster infrastructure migrations.</strong></p>
+  <p>Build long-lived applications with explicit dependency injection, DDD, CQRS, and transport-independent business logic.</p>
+
+  <p>
+    <a href="https://www.npmjs.com/package/@xeno-js/vercel"><img src="https://img.shields.io/npm/v/@xeno-js/vercel?style=flat-square" alt="NPM Version" /></a>
+    <a href="https://github.com/xeno-js/vercel"><img src="https://img.shields.io/badge/Powered%20by-Xeno-blueviolet?style=flat-square" alt="Powered by Xeno" /></a>
+    <a href="LICENSE"><img src="https://img.shields.io/badge/license-MIT-blue?style=flat-square" alt="License: MIT" /></a>
+    <a href="https://buymeacoffee.com/xenojs">
+      <img src="https://img.shields.io/badge/Buy%20Me%20A%20Coffee-Support-FFdd00?style=flat-square&logo=buy-me-a-coffee&logoColor=black" alt="Buy Me A Coffee" />
+    </a>
+  </p>
+</div>
+
+---
+
+`@xeno-js/vercel` provides native integration for deploying Xeno.JS Backend-for-Frontend (BFF) applications as Vercel Serverless Functions. It maps Vercel request/response lifecycles directly into the framework's transport-independent execution pipelines.
+
+## Installation
+
+```bash
+npm install @xeno-js/vercel
+```
+
+The package requires Node.js 20 or higher, `@xeno-js/core` as peer dependencies.
+
+---
+
+## 1. Setting Up the Application Bootstrap Container
+
+**Problem.** Serverless functions require cold-start optimization to avoid bootstrapping application modules on every single incoming HTTP request.
+
+**Principle.** Application container initialization must be lazy-loaded, cached as a singleton instance across function invocations, and cleanly decoupled from the serverless transport entry point.
+
+**Mechanism.** The `getApp` utility ensures the Xeno.JS application container is bootstrapped precisely once during the initial cold start and securely reused for subsequent warm requests.
+
+**Implementation:**
+
+```ts
+// _lib/app.ts
+import { Guards, IXenoApplication, Maybe } from '@xeno-js/core'
+import { MyRegistry } from './registry.js'
+import { bootstrap } from './bootstrap.js'
+
+let cachedApp: Maybe<IXenoApplication<MyRegistry>> = null
+
+export async function getApp() {
+  if (!Guards.isDefined(cachedApp)) {
+    cachedApp = await bootstrap()
+  }
+  return cachedApp
+}
+```
+
+**Behavior:** During the first execution, `bootstrap()` wires routes, middlewares, CQRS pipelines, and DI containers. Subsequent requests instantly resolve the cached application instance.
+
+**Boundary:** The application bootstrap handles infrastructure wiring and container configuration, remaining completely agnostic of the deployment host (Vercel, AWS, or bare-metal).
+
+---
+
+## 2. Registering Routes with `addRoutes`
+
+**Problem.** An application container requires an explicit route registry mapping HTTP verbs and paths to their corresponding handlers. Without route definitions, the internal `RouteMatcher` cannot resolve incoming endpoints, resulting in a `404 Not Found` response.
+
+**Principle.** Route registration must be explicitly defined using `addRoutes` during application building to bind endpoints to the dispatching pipeline.
+
+**Mechanism.** The `addRoutes` method registers route definitions into the `XenoAppBuilder`, initializing the route matcher index.
+
+**Implementation:**
+
+```ts
+// _lib/bootstrap.ts
+import { XenoAppBuilder } from '@xeno-js/core';
+import { routes } from './routes.js';
+import type { MyRegistry } from './registry.js';
+
+export async function bootstrap() {
+    const builder = new XenoAppBuilder<MyRegistry>()
+        .addRoutes(routes) // REQUIRED: Registers application routes
+        // ... other modules and configurations
+        
+    return await builder.build();
+}
+```
+
+**Behavior:** The router compiles patterns and methods during bootstrap so that incoming serverless requests can be efficiently matched and dispatched.
+
+**Boundary:** Route definitions handle URL matching and parameter extraction, delegating business logic to controllers and handlers.
+
+---
+
+## 3. Configuring the Vercel Catch-All Serverless Handler
+
+**Problem.** Vercel maps individual files inside an `api/` directory to distinct serverless endpoints, whereas modern BFFs typically rely on a unified internal router to handle complex nested sub-routes (e.g., `/api/v1/orders`).
+
+**Principle.** All serverless traffic must be routed to a single catch-all entrypoint function that delegates request processing to the framework's internal `RouteMatcher` and `HttpDispatcher`.
+
+**Mechanism.** The `XenoVercel.handle` utility adapts incoming `VercelRequest` and `VercelResponse` objects, executes the standard middleware chain, evaluates route policies, and formats the output response.
+
+**Implementation:**
+
+Assuming you place your serverless entry point inside a directory designated for deployment (for example, `api/index.ts` as an example directory layout), configure the handler as follows:
+
+```ts
+// api/index.ts (Catch-all serverless function entrypoint)
+import type { VercelRequest, VercelResponse } from '@vercel/node'
+import { ERROR_CODE_MESSAGES, ERROR_CODES, GuidHelper, STATUS_CODES } from "@xeno-js/core";
+import { XenoVercel } from "@xeno-js/vercel";
+import { getApp } from "./_lib/app.js";
+
+export default async function handler(req: VercelRequest, res: VercelResponse): Promise<VercelResponse> {
+    try {
+        return await XenoVercel.handle(req, res, getApp)
+    } catch (error) {
+        console.error('Fatal error in serverless runtime:', error)
+        const isDev = process.env.NODE_ENV === 'development'
+        const errorMessage = error instanceof Error ? error.message : 'Internal Server Error'
+        
+        return res.status(STATUS_CODES.INTERNAL_SERVER_ERROR).json({
+            success: false,
+            error: {
+                code: ERROR_CODES.SYSTEM_ERROR,
+                message: ERROR_CODE_MESSAGES[ERROR_CODES.SYSTEM_ERROR],
+                details: isDev ? errorMessage : undefined,
+                path: req.url,
+            },
+            correlationId: GuidHelper.generate(),
+            requestId: GuidHelper.generate(),
+            timestamp: new Date().toISOString(),
+        })
+    }
+}
+```
+
+**Behavior:** When an HTTP request hits `https://your-domain.com/api/v1/orders`, Vercel rewrites or routes the call to `api/index.ts`. `XenoVercel.handle` matches the route, executes CORS, rate-limiting, authentication, and validation middleware, and invokes the target controller.
+
+**Boundary:** The Vercel handler translates serverless transport boundaries into standard framework requests, keeping core controllers and use cases 100% portable.
+
+---
+
+## 4. Technical Documentation: Global Rate Limiting Error on Vercel / Reverse Proxy
+
+### 1. Problem Description
+
+During application execution (or during load testing with tools like k6), after a minimal number of requests (e.g., 10 requests), all users start receiving the following error:
+
+```json
+{
+  "success": false,
+  "error": {
+    "code": "TOO_MANY_REQUESTS",
+    "message": "errors.too_many_requests",
+    "details": "Rate limit exceeded.",
+    "path": "/api/v1/orders"
+  }
+}
+```
+
+The block occurs even when requests originate from different client IPs, different devices, or distinct users, rendering the service unusable for the entire global user base for the duration of the time window (`windowSeconds`).
+
+### 2. Root Cause
+
+In Xeno.JS, `RateLimitMiddleware` builds the counting cache key via `RateLimitKeyBuilder`:
+
+```text
+ratelimit:ip:<clientIp>:<resource>
+```
+
+Extracting `clientIp` is delegated to the `ClientIpResolver` service. In the Xeno.JS source code, the resolver operates as follows:
+
+```typescript
+export class ClientIpResolver implements IIPResolver {
+  constructor(private readonly _trustedProxies: string[] = []) {}
+
+  public resolve(req: XenoRequest, clientIp: Optional<string>): Optional<string> {
+    const socketIp = req.socket?.remoteAddress
+    if (!Guards.isDefined(socketIp))
+      return !Guards.isNullOrEmpty(clientIp) ? clientIp.split(',')[0].trim() : undefined
+    const isTrustedProxy = this._trustedProxies.includes(socketIp)
+    if (!isTrustedProxy) return socketIp
+    if (Guards.isDefined(clientIp)) return clientIp.split(',')[0].trim()
+    return socketIp
+  }
+}
+```
+
+#### Why does collective blocking happen?
+
+1. **TCP Connection on Serverless Platforms (Vercel):**  
+   When a user sends a request to an application deployed on Vercel, they do not establish a direct TCP connection with the Serverless Function; they connect first to Vercel's Edge/Reverse Proxy infrastructure.
+2. **Vercel Proxy to Container:**  
+   The Vercel proxy then connects to the serverless container. Consequently, `req.socket.remoteAddress` contains the internal IP address of Vercel's proxy, not the real visitor's IP.
+3. **Missing Trusted Proxies (`_trustedProxies` is empty):**  
+   For security reasons (preventing IP spoofing), `ClientIpResolver` refuses to read headers such as `X-Forwarded-For` or `X-Real-IP` unless `req.socket.remoteAddress` matches the list of trusted proxies (`_trustedProxies`). If `trustedProxies` is unconfigured, `_trustedProxies` defaults to an empty array `[]`.
+4. **Fallback to Socket IP:**  
+   Because `isTrustedProxy` evaluates to `false`, the resolver returns `socketIp` directly. This means every request—regardless of the user originating it—is labeled with the identical internal Vercel IP.
+5. **Bucket Saturation:**  
+   All users share the exact same cache key (e.g., `ratelimit:ip:10.x.x.x:/api/v1/orders`). As soon as the first 10 aggregate requests worldwide are executed, the counter exceeds the threshold (`maxRequests: 10`), triggering the middleware for anyone else sending a request within the next 60 seconds.
+
+### 3. Solution
+
+To ensure each user receives an isolated request budget, configure `MiddlewareModule` to:
+
+1. Recognize `x-forwarded-for` as the primary header for identifying the client.
+2. Trust Vercel's reverse proxy by enabling the wildcard (`['*']`).
+
+#### Bootstrap Configuration (`_lib/bootstrap.ts`)
+
+Inside the `.addMiddlewares()` configuration:
+
+```typescript
+.addMiddlewares((opts, config) => {
+    // 1. CORS Configuration
+    opts.cors = {
+        allowOrigins: [config.get('CLIENT_URL', '')!],
+        enablePreflight: true,
+        enabled: true
+    };
+
+    // 2. Instruct Xeno.JS to read the header injected by Vercel
+    opts.trustedIpHeader = 'x-forwarded-for';
+
+    // 3. Instruct the resolver to trust intermediate proxies
+    // Without this, x-forwarded-for would be discarded in favor of req.socket.remoteAddress
+    opts.trustedProxies = ['*'];
+
+    // 4. Rate Limiting configuration per individual user IP
+    opts.rateLimit = {
+        enabled: true,
+        maxRequests: 10,  // Maximum 10 requests per user/IP
+        windowSeconds: 60 // 60-second time window
+    };
+})
+```
+
+### 4. Why This Configuration Is Mandatory
+
+- **Cache Key Isolation:**  
+  With `trustedProxies = ['*']`, `ClientIpResolver` extracts the first IP from the list present in the `X-Forwarded-For` header (the actual public IP address of the client that initiated the request).
+- **Multi-User Operation:**  
+  The generated cache keys will be unique per client:
+  
+  - User A: `ratelimit:ip:93.45.12.1:/api/v1/orders` (10 requests available).
+  - User B: `ratelimit:ip:80.18.23.4:/api/v1/orders` (10 requests available).
+  
+  If User A exhausts their 10 requests and gets throttled with a `429 Too Many Requests`, User B can continue chatting freely without encountering any slowdowns or blocks.
+
+---
+
+## License
+
+Released under the [MIT License](LICENSE).

package/dist/index.cjs

@@ -0,0 +1,95 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  XenoVercel: () => XenoVercel
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/infrastructure/vercel.handler.ts
+var import_core = require("@xeno-js/core");
+var XenoVercel = class {
+  static async handle(req, res, getApp) {
+    try {
+      const app = await getApp();
+      const { routeMatcher, httpAdapter, httpDispatcher } = app.getServices();
+      const url = req.url ?? "/";
+      const method = req.method ?? "GET";
+      const matchedRoute = routeMatcher.match(url, method);
+      if (!import_core.Guards.isDefined(matchedRoute)) {
+        return res.status(import_core.STATUS_CODES.NOT_FOUND).json({
+          success: false,
+          error: {
+            code: import_core.ERROR_CODES.NOT_FOUND,
+            message: `Route ${method} ${url} not found`,
+            path: url
+          }
+        });
+      }
+      const normalizedHeaders = import_core.HttpHelper.normalizeHeaders(req.headers);
+      const xenoreq = {
+        url,
+        headers: new Headers(normalizedHeaders),
+        signal: req.signal,
+        socket: req.socket,
+        body: req.body,
+        query: req.query,
+        method,
+        path: new URL(url, "http://localhost").pathname
+      };
+      const extendedRequest = httpAdapter.adapt(xenoreq);
+      const routeResult = await matchedRoute.handler({
+        req: extendedRequest,
+        handle: (token, input) => httpDispatcher.handle(extendedRequest, token, input)
+      });
+      if (import_core.Guards.isDefined(routeResult)) {
+        if (import_core.Guards.isDefined(routeResult.headers)) {
+          const responseHeaders = new Headers(routeResult.headers);
+          responseHeaders.forEach((value, key) => {
+            res.setHeader(key, value);
+          });
+        }
+        return res.status(routeResult.status).json(routeResult.data);
+      }
+      return res.status(import_core.STATUS_CODES.NO_CONTENT).end();
+    } catch (error) {
+      console.error("Errore fatale nell'handler Vercel di Xeno:", error);
+      const isDev = process.env.NODE_ENV === "development";
+      const errorMessage = error instanceof Error ? error.message : "Internal Server Error";
+      return res.status(import_core.STATUS_CODES.INTERNAL_SERVER_ERROR).json({
+        success: false,
+        error: {
+          code: import_core.ERROR_CODES.SYSTEM_ERROR,
+          message: import_core.ERROR_CODE_MESSAGES[import_core.ERROR_CODES.SYSTEM_ERROR],
+          details: isDev ? errorMessage : void 0
+        },
+        correlationId: import_core.GuidHelper.generate(),
+        requestId: import_core.GuidHelper.generate(),
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+    }
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  XenoVercel
+});
+//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts","../src/infrastructure/vercel.handler.ts"],"sourcesContent":["export { XenoVercel } from './infrastructure/vercel.handler'","import type { VercelRequest, VercelResponse } from '@vercel/node'\r\nimport type { Dictionary, IXenoApplication, XenoIncomingRequest, XenoRegistry } from '@xeno-js/core'\r\nimport { ERROR_CODE_MESSAGES, ERROR_CODES, Guards, GuidHelper, HttpHelper, STATUS_CODES } from '@xeno-js/core'\r\n\r\nexport class XenoVercel {\r\n    public static async handle<TRegistry extends XenoRegistry = XenoRegistry>(\r\n        req: VercelRequest,\r\n        res: VercelResponse,\r\n        getApp: () => Promise<IXenoApplication<TRegistry>>\r\n    ): Promise<VercelResponse> {\r\n        try {\r\n            const app = await getApp()\r\n            const { routeMatcher, httpAdapter, httpDispatcher } = app.getServices()\r\n\r\n            const url = req.url ?? '/'\r\n            const method = req.method ?? 'GET'\r\n\r\n            const matchedRoute = routeMatcher.match(url, method)\r\n\r\n            if (!Guards.isDefined(matchedRoute)) {\r\n                return res.status(STATUS_CODES.NOT_FOUND).json({\r\n                    success: false,\r\n                    error: {\r\n                        code: ERROR_CODES.NOT_FOUND,\r\n                        message: `Route ${method} ${url} not found`,\r\n                        path: url\r\n                    }\r\n                })\r\n            }\r\n\r\n            const normalizedHeaders = HttpHelper.normalizeHeaders(req.headers)\r\n            const xenoreq: XenoIncomingRequest = {\r\n                url,\r\n                headers: new Headers(normalizedHeaders as Dictionary<string>),\r\n                signal: req.signal,\r\n                socket: req.socket,\r\n                body: req.body,\r\n                query: req.query as Dictionary<string>,\r\n                method,\r\n                path: new URL(url, 'http://localhost').pathname\r\n            }\r\n\r\n            const extendedRequest = httpAdapter.adapt(xenoreq)\r\n\r\n            const routeResult = await matchedRoute.handler({\r\n                req: extendedRequest,\r\n                handle: (token, input) => httpDispatcher.handle(extendedRequest, token, input),\r\n            })\r\n\r\n            if (Guards.isDefined(routeResult)) {\r\n                if (Guards.isDefined(routeResult.headers)) {\r\n                    const responseHeaders = new Headers(routeResult.headers as Dictionary<string>)\r\n                    responseHeaders.forEach((value, key) => {\r\n                        res.setHeader(key, value)\r\n                    })\r\n                }\r\n                return res.status(routeResult.status).json(routeResult.data)\r\n            }\r\n\r\n            return res.status(STATUS_CODES.NO_CONTENT).end()\r\n\r\n        } catch (error) {\r\n            console.error('Errore fatale nell\\'handler Vercel di Xeno:', error)\r\n            const isDev = process.env.NODE_ENV === 'development'\r\n            const errorMessage = error instanceof Error ? error.message : 'Internal Server Error'\r\n\r\n            return res.status(STATUS_CODES.INTERNAL_SERVER_ERROR).json({\r\n                success: false,\r\n                error: {\r\n                    code: ERROR_CODES.SYSTEM_ERROR,\r\n                    message: ERROR_CODE_MESSAGES[ERROR_CODES.SYSTEM_ERROR],\r\n                    details: isDev ? errorMessage : undefined,\r\n                },\r\n                correlationId: GuidHelper.generate(),\r\n                requestId: GuidHelper.generate(),\r\n                timestamp: new Date().toISOString(),\r\n            })\r\n        }\r\n    }\r\n}"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACEA,kBAA+F;AAExF,IAAM,aAAN,MAAiB;AAAA,EACpB,aAAoB,OAChB,KACA,KACA,QACuB;AACvB,QAAI;AACA,YAAM,MAAM,MAAM,OAAO;AACzB,YAAM,EAAE,cAAc,aAAa,eAAe,IAAI,IAAI,YAAY;AAEtE,YAAM,MAAM,IAAI,OAAO;AACvB,YAAM,SAAS,IAAI,UAAU;AAE7B,YAAM,eAAe,aAAa,MAAM,KAAK,MAAM;AAEnD,UAAI,CAAC,mBAAO,UAAU,YAAY,GAAG;AACjC,eAAO,IAAI,OAAO,yBAAa,SAAS,EAAE,KAAK;AAAA,UAC3C,SAAS;AAAA,UACT,OAAO;AAAA,YACH,MAAM,wBAAY;AAAA,YAClB,SAAS,SAAS,MAAM,IAAI,GAAG;AAAA,YAC/B,MAAM;AAAA,UACV;AAAA,QACJ,CAAC;AAAA,MACL;AAEA,YAAM,oBAAoB,uBAAW,iBAAiB,IAAI,OAAO;AACjE,YAAM,UAA+B;AAAA,QACjC;AAAA,QACA,SAAS,IAAI,QAAQ,iBAAuC;AAAA,QAC5D,QAAQ,IAAI;AAAA,QACZ,QAAQ,IAAI;AAAA,QACZ,MAAM,IAAI;AAAA,QACV,OAAO,IAAI;AAAA,QACX;AAAA,QACA,MAAM,IAAI,IAAI,KAAK,kBAAkB,EAAE;AAAA,MAC3C;AAEA,YAAM,kBAAkB,YAAY,MAAM,OAAO;AAEjD,YAAM,cAAc,MAAM,aAAa,QAAQ;AAAA,QAC3C,KAAK;AAAA,QACL,QAAQ,CAAC,OAAO,UAAU,eAAe,OAAO,iBAAiB,OAAO,KAAK;AAAA,MACjF,CAAC;AAED,UAAI,mBAAO,UAAU,WAAW,GAAG;AAC/B,YAAI,mBAAO,UAAU,YAAY,OAAO,GAAG;AACvC,gBAAM,kBAAkB,IAAI,QAAQ,YAAY,OAA6B;AAC7E,0BAAgB,QAAQ,CAAC,OAAO,QAAQ;AACpC,gBAAI,UAAU,KAAK,KAAK;AAAA,UAC5B,CAAC;AAAA,QACL;AACA,eAAO,IAAI,OAAO,YAAY,MAAM,EAAE,KAAK,YAAY,IAAI;AAAA,MAC/D;AAEA,aAAO,IAAI,OAAO,yBAAa,UAAU,EAAE,IAAI;AAAA,IAEnD,SAAS,OAAO;AACZ,cAAQ,MAAM,8CAA+C,KAAK;AAClE,YAAM,QAAQ,QAAQ,IAAI,aAAa;AACvC,YAAM,eAAe,iBAAiB,QAAQ,MAAM,UAAU;AAE9D,aAAO,IAAI,OAAO,yBAAa,qBAAqB,EAAE,KAAK;AAAA,QACvD,SAAS;AAAA,QACT,OAAO;AAAA,UACH,MAAM,wBAAY;AAAA,UAClB,SAAS,gCAAoB,wBAAY,YAAY;AAAA,UACrD,SAAS,QAAQ,eAAe;AAAA,QACpC;AAAA,QACA,eAAe,uBAAW,SAAS;AAAA,QACnC,WAAW,uBAAW,SAAS;AAAA,QAC/B,YAAW,oBAAI,KAAK,GAAE,YAAY;AAAA,MACtC,CAAC;AAAA,IACL;AAAA,EACJ;AACJ;","names":[]}

package/dist/index.d.cts

@@ -0,0 +1,8 @@
+import { VercelRequest, VercelResponse } from '@vercel/node';
+import { XenoRegistry, IXenoApplication } from '@xeno-js/core';
+
+declare class XenoVercel {
+    static handle<TRegistry extends XenoRegistry = XenoRegistry>(req: VercelRequest, res: VercelResponse, getApp: () => Promise<IXenoApplication<TRegistry>>): Promise<VercelResponse>;
+}
+
+export { XenoVercel };

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+import { VercelRequest, VercelResponse } from '@vercel/node';
+import { XenoRegistry, IXenoApplication } from '@xeno-js/core';
+
+declare class XenoVercel {
+    static handle<TRegistry extends XenoRegistry = XenoRegistry>(req: VercelRequest, res: VercelResponse, getApp: () => Promise<IXenoApplication<TRegistry>>): Promise<VercelResponse>;
+}
+
+export { XenoVercel };

package/dist/index.js

@@ -0,0 +1,68 @@
+// src/infrastructure/vercel.handler.ts
+import { ERROR_CODE_MESSAGES, ERROR_CODES, Guards, GuidHelper, HttpHelper, STATUS_CODES } from "@xeno-js/core";
+var XenoVercel = class {
+  static async handle(req, res, getApp) {
+    try {
+      const app = await getApp();
+      const { routeMatcher, httpAdapter, httpDispatcher } = app.getServices();
+      const url = req.url ?? "/";
+      const method = req.method ?? "GET";
+      const matchedRoute = routeMatcher.match(url, method);
+      if (!Guards.isDefined(matchedRoute)) {
+        return res.status(STATUS_CODES.NOT_FOUND).json({
+          success: false,
+          error: {
+            code: ERROR_CODES.NOT_FOUND,
+            message: `Route ${method} ${url} not found`,
+            path: url
+          }
+        });
+      }
+      const normalizedHeaders = HttpHelper.normalizeHeaders(req.headers);
+      const xenoreq = {
+        url,
+        headers: new Headers(normalizedHeaders),
+        signal: req.signal,
+        socket: req.socket,
+        body: req.body,
+        query: req.query,
+        method,
+        path: new URL(url, "http://localhost").pathname
+      };
+      const extendedRequest = httpAdapter.adapt(xenoreq);
+      const routeResult = await matchedRoute.handler({
+        req: extendedRequest,
+        handle: (token, input) => httpDispatcher.handle(extendedRequest, token, input)
+      });
+      if (Guards.isDefined(routeResult)) {
+        if (Guards.isDefined(routeResult.headers)) {
+          const responseHeaders = new Headers(routeResult.headers);
+          responseHeaders.forEach((value, key) => {
+            res.setHeader(key, value);
+          });
+        }
+        return res.status(routeResult.status).json(routeResult.data);
+      }
+      return res.status(STATUS_CODES.NO_CONTENT).end();
+    } catch (error) {
+      console.error("Errore fatale nell'handler Vercel di Xeno:", error);
+      const isDev = process.env.NODE_ENV === "development";
+      const errorMessage = error instanceof Error ? error.message : "Internal Server Error";
+      return res.status(STATUS_CODES.INTERNAL_SERVER_ERROR).json({
+        success: false,
+        error: {
+          code: ERROR_CODES.SYSTEM_ERROR,
+          message: ERROR_CODE_MESSAGES[ERROR_CODES.SYSTEM_ERROR],
+          details: isDev ? errorMessage : void 0
+        },
+        correlationId: GuidHelper.generate(),
+        requestId: GuidHelper.generate(),
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+    }
+  }
+};
+export {
+  XenoVercel
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/infrastructure/vercel.handler.ts"],"sourcesContent":["import type { VercelRequest, VercelResponse } from '@vercel/node'\r\nimport type { Dictionary, IXenoApplication, XenoIncomingRequest, XenoRegistry } from '@xeno-js/core'\r\nimport { ERROR_CODE_MESSAGES, ERROR_CODES, Guards, GuidHelper, HttpHelper, STATUS_CODES } from '@xeno-js/core'\r\n\r\nexport class XenoVercel {\r\n    public static async handle<TRegistry extends XenoRegistry = XenoRegistry>(\r\n        req: VercelRequest,\r\n        res: VercelResponse,\r\n        getApp: () => Promise<IXenoApplication<TRegistry>>\r\n    ): Promise<VercelResponse> {\r\n        try {\r\n            const app = await getApp()\r\n            const { routeMatcher, httpAdapter, httpDispatcher } = app.getServices()\r\n\r\n            const url = req.url ?? '/'\r\n            const method = req.method ?? 'GET'\r\n\r\n            const matchedRoute = routeMatcher.match(url, method)\r\n\r\n            if (!Guards.isDefined(matchedRoute)) {\r\n                return res.status(STATUS_CODES.NOT_FOUND).json({\r\n                    success: false,\r\n                    error: {\r\n                        code: ERROR_CODES.NOT_FOUND,\r\n                        message: `Route ${method} ${url} not found`,\r\n                        path: url\r\n                    }\r\n                })\r\n            }\r\n\r\n            const normalizedHeaders = HttpHelper.normalizeHeaders(req.headers)\r\n            const xenoreq: XenoIncomingRequest = {\r\n                url,\r\n                headers: new Headers(normalizedHeaders as Dictionary<string>),\r\n                signal: req.signal,\r\n                socket: req.socket,\r\n                body: req.body,\r\n                query: req.query as Dictionary<string>,\r\n                method,\r\n                path: new URL(url, 'http://localhost').pathname\r\n            }\r\n\r\n            const extendedRequest = httpAdapter.adapt(xenoreq)\r\n\r\n            const routeResult = await matchedRoute.handler({\r\n                req: extendedRequest,\r\n                handle: (token, input) => httpDispatcher.handle(extendedRequest, token, input),\r\n            })\r\n\r\n            if (Guards.isDefined(routeResult)) {\r\n                if (Guards.isDefined(routeResult.headers)) {\r\n                    const responseHeaders = new Headers(routeResult.headers as Dictionary<string>)\r\n                    responseHeaders.forEach((value, key) => {\r\n                        res.setHeader(key, value)\r\n                    })\r\n                }\r\n                return res.status(routeResult.status).json(routeResult.data)\r\n            }\r\n\r\n            return res.status(STATUS_CODES.NO_CONTENT).end()\r\n\r\n        } catch (error) {\r\n            console.error('Errore fatale nell\\'handler Vercel di Xeno:', error)\r\n            const isDev = process.env.NODE_ENV === 'development'\r\n            const errorMessage = error instanceof Error ? error.message : 'Internal Server Error'\r\n\r\n            return res.status(STATUS_CODES.INTERNAL_SERVER_ERROR).json({\r\n                success: false,\r\n                error: {\r\n                    code: ERROR_CODES.SYSTEM_ERROR,\r\n                    message: ERROR_CODE_MESSAGES[ERROR_CODES.SYSTEM_ERROR],\r\n                    details: isDev ? errorMessage : undefined,\r\n                },\r\n                correlationId: GuidHelper.generate(),\r\n                requestId: GuidHelper.generate(),\r\n                timestamp: new Date().toISOString(),\r\n            })\r\n        }\r\n    }\r\n}"],"mappings":";AAEA,SAAS,qBAAqB,aAAa,QAAQ,YAAY,YAAY,oBAAoB;AAExF,IAAM,aAAN,MAAiB;AAAA,EACpB,aAAoB,OAChB,KACA,KACA,QACuB;AACvB,QAAI;AACA,YAAM,MAAM,MAAM,OAAO;AACzB,YAAM,EAAE,cAAc,aAAa,eAAe,IAAI,IAAI,YAAY;AAEtE,YAAM,MAAM,IAAI,OAAO;AACvB,YAAM,SAAS,IAAI,UAAU;AAE7B,YAAM,eAAe,aAAa,MAAM,KAAK,MAAM;AAEnD,UAAI,CAAC,OAAO,UAAU,YAAY,GAAG;AACjC,eAAO,IAAI,OAAO,aAAa,SAAS,EAAE,KAAK;AAAA,UAC3C,SAAS;AAAA,UACT,OAAO;AAAA,YACH,MAAM,YAAY;AAAA,YAClB,SAAS,SAAS,MAAM,IAAI,GAAG;AAAA,YAC/B,MAAM;AAAA,UACV;AAAA,QACJ,CAAC;AAAA,MACL;AAEA,YAAM,oBAAoB,WAAW,iBAAiB,IAAI,OAAO;AACjE,YAAM,UAA+B;AAAA,QACjC;AAAA,QACA,SAAS,IAAI,QAAQ,iBAAuC;AAAA,QAC5D,QAAQ,IAAI;AAAA,QACZ,QAAQ,IAAI;AAAA,QACZ,MAAM,IAAI;AAAA,QACV,OAAO,IAAI;AAAA,QACX;AAAA,QACA,MAAM,IAAI,IAAI,KAAK,kBAAkB,EAAE;AAAA,MAC3C;AAEA,YAAM,kBAAkB,YAAY,MAAM,OAAO;AAEjD,YAAM,cAAc,MAAM,aAAa,QAAQ;AAAA,QAC3C,KAAK;AAAA,QACL,QAAQ,CAAC,OAAO,UAAU,eAAe,OAAO,iBAAiB,OAAO,KAAK;AAAA,MACjF,CAAC;AAED,UAAI,OAAO,UAAU,WAAW,GAAG;AAC/B,YAAI,OAAO,UAAU,YAAY,OAAO,GAAG;AACvC,gBAAM,kBAAkB,IAAI,QAAQ,YAAY,OAA6B;AAC7E,0BAAgB,QAAQ,CAAC,OAAO,QAAQ;AACpC,gBAAI,UAAU,KAAK,KAAK;AAAA,UAC5B,CAAC;AAAA,QACL;AACA,eAAO,IAAI,OAAO,YAAY,MAAM,EAAE,KAAK,YAAY,IAAI;AAAA,MAC/D;AAEA,aAAO,IAAI,OAAO,aAAa,UAAU,EAAE,IAAI;AAAA,IAEnD,SAAS,OAAO;AACZ,cAAQ,MAAM,8CAA+C,KAAK;AAClE,YAAM,QAAQ,QAAQ,IAAI,aAAa;AACvC,YAAM,eAAe,iBAAiB,QAAQ,MAAM,UAAU;AAE9D,aAAO,IAAI,OAAO,aAAa,qBAAqB,EAAE,KAAK;AAAA,QACvD,SAAS;AAAA,QACT,OAAO;AAAA,UACH,MAAM,YAAY;AAAA,UAClB,SAAS,oBAAoB,YAAY,YAAY;AAAA,UACrD,SAAS,QAAQ,eAAe;AAAA,QACpC;AAAA,QACA,eAAe,WAAW,SAAS;AAAA,QACnC,WAAW,WAAW,SAAS;AAAA,QAC/B,YAAW,oBAAI,KAAK,GAAE,YAAY;AAAA,MACtC,CAAC;AAAA,IACL;AAAA,EACJ;AACJ;","names":[]}

package/package.json

@@ -1,6 +1,108 @@
 {
   "name": "@xeno-js/vercel",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "1.0.1",
+  "description": "Vercel Serverless Functions and Edge runtime integration for Xeno.js applications, enabling seamless BFF deployments.",
+  "keywords": [
+    "xeno",
+    "xeno-js",
+    "xeno.js",
+    "vercel",
+    "vercel serverless",
+    "vercel functions",
+    "serverless functions",
+    "serverless typescript",
+    "edge runtime",
+    "bff",
+    "backend for frontend",
+    "cloud deployment",
+    "typescript",
+    "typescript backend",
+    "nodejs",
+    "node.js",
+    "dependency injection",
+    "clean architecture",
+    "hexagonal architecture"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/xeno-js/vercel.git"
+  },
+  "bugs": {
+    "url": "https://github.com/xeno-js/vercel/issues"
+  },
+  "homepage": "https://www.xeno-js.it",
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "scripts": {
+    "build": "tsup",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "lint": "eslint --config eslint.config.mjs \"src/**/*.ts\" --max-warnings=0",
+    "lint:fix": "eslint --config eslint.config.mjs \"src/**/*.ts\" --fix --max-warnings=0",
+    "lint-staged": "lint-staged",
+    "commitlint": "commitlint",
+    "format": "prettier --write .",
+    "format:check": "prettier --check .",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage",
+    "check": "npm run typecheck && npm run lint:fix && npm run test",
+    "verify:commit": "npm run lint-staged && npm run test",
+    "verify:push": "npm run check",
+    "prepare": "husky",
+    "changelog": "npx conventional-changelog -p angular -i CHANGELOG.md -s -r 0",
+    "prepublishOnly": "npm run check && npm run build",
+    "release:patch": "npm version patch && npm run changelog && npm run prepublishOnly && npm publish",
+    "release:minor": "npm version minor && npm run changelog && npm run prepublishOnly && npm publish",
+    "release:major": "npm version major && npm run changelog && npm run prepublishOnly && npm publish"
+  },
+  "author": "Xeno",
+  "license": "MIT",
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "peerDependencies": {
+    "@xeno-js/core": "^4.1.1"
+  },
+  "devDependencies": {
+    "@commitlint/cli": "^21.2.3",
+    "@commitlint/config-conventional": "^21.2.3",
+    "@eslint/js": "^9.39.5",
+    "@types/pg": "^8.23.1",
+    "@vitest/coverage-v8": "^5.0.1",
+    "@xeno-js/core": "^4.1.1",
+    "conventional-changelog": "^8.1.3",
+    "conventional-changelog-angular": "^9.4.0",
+    "conventional-changelog-cli": "^5.0.0",
+    "conventional-changelog-writer": "^9.2.1",
+    "eslint": "^9.39.5",
+    "eslint-config-prettier": "^10.1.8",
+    "eslint-plugin-simple-import-sort": "^14.0.0",
+    "husky": "^9.1.7",
+    "lint-staged": "^17.5.1",
+    "prettier": "^3.9.9",
+    "tsc-alias": "^1.9.5",
+    "tsup": "^8.5.1",
+    "typescript": "^5.8.0",
+    "typescript-eslint": "^8.36.0",
+    "vitest": "^5.0.1"
+  },
+  "dependencies": {
+    "@vercel/node": "^30.0.0"
+  }
+}