@vercube/serverless 0.0.22 → 0.0.24

package/README.md

@@ -3,10 +3,10 @@
   <br>
   <br>
 
-  # @vercube/serverless
-  
-  Serverless deployment adapters for Vercube applications
-  
+# @vercube/serverless
+
+Serverless deployment adapters for Vercube applications
+
   <a href="https://www.npmjs.com/package/@vercube/serverless">
     <img src="https://img.shields.io/npm/v/%40vercube%2Fserverless?style=for-the-badge&logo=npm&color=%23767eff" alt="npm"/>
   </a>
@@ -16,6 +16,9 @@
   <a href="https://github.com/vercube/vercube/blob/main/LICENSE" target="_blank">
     <img src="https://img.shields.io/npm/l/%40vercube%2Fserverless?style=for-the-badge&color=%23767eff" alt="License"/>
   </a>
+  <a href="https://codecov.io/gh/vercube/vercube" target="_blank">
+    <img src="https://img.shields.io/codecov/c/github/vercube/vercube?style=for-the-badge&color=%23767eff" alt="Coverage"/>
+  </a>
   <br/>
   <br/>
 </div>
@@ -31,10 +34,11 @@ The `@vercube/serverless` module provides unified, provider-agnostic adapters fo
 ### ✅ Key Features
 
 - **AWS Lambda Integration** - Full support for API Gateway v1 and v2
+- **Azure Functions Integration** - Complete support for Azure Functions HTTP triggers
 - **Zero Configuration** - Works out-of-the-box with existing Vercube apps
 - **Type Safety** - Complete TypeScript support with proper type definitions
 - **Binary Support** - Automatic handling of binary content with base64 encoding
-- **Cookie Support** - Proper cookie handling for both API Gateway versions
+- **Cookie Support** - Proper cookie handling for both API Gateway versions and Azure Functions
 - **Error Handling** - Robust error handling and validation
 - **Performance Optimized** - Efficient request/response conversion
 
@@ -63,6 +67,30 @@ const app = createApp();
 export const handler = toServerlessHandler(app);
 ```
 
+### Azure Functions Integration
+
+Deploy your Vercube application to Azure Functions:
+
+```ts
+// httpTrigger.ts
+import { createApp } from '@vercube/core';
+import { toServerlessHandler } from '@vercube/serverless/azure-functions';
+import { app, HttpRequest, HttpResponseInit, InvocationContext } from '@azure/functions';
+
+const vercubeApp = createApp();
+const handler = toServerlessHandler(vercubeApp);
+
+export async function httpTrigger(request: HttpRequest, context: InvocationContext): Promise<HttpResponseInit> {
+  return await handler(request);
+}
+
+app.http('httpTrigger', {
+  methods: ['GET', 'POST', 'PUT', 'DELETE', 'PATCH', 'HEAD', 'OPTIONS'],
+  authLevel: 'anonymous',
+  handler: httpTrigger,
+});
+```
+
 ### Serverless Framework Configuration
 
 ```yaml
@@ -98,6 +126,16 @@ Full support for AWS Lambda with API Gateway integration:
 - **Cookies** - Proper cookie handling for both API Gateway versions
 - **Headers** - Complete header conversion and processing
 
+### Azure Functions
+
+Complete support for Azure Functions HTTP triggers:
+
+- **HTTP Triggers** - Full compatibility with Azure Functions HTTP triggers
+- **Request/Response Conversion** - Seamless conversion between Azure Functions and web standards
+- **Cookie Support** - Proper handling of Set-Cookie headers and cookie parsing
+- **Headers** - Complete header conversion and processing
+- **Streaming Support** - Efficient handling of request/response bodies with AsyncIterableIterator
+
 ---
 
 ## 📋 API Reference
@@ -107,13 +145,17 @@ Full support for AWS Lambda with API Gateway integration:
 Converts a Vercube App instance into a serverless handler function.
 
 **Parameters:**
+
 - `app` - The Vercube App instance that will handle requests
 
 **Returns:**
+
 - An async function that accepts serverless events and returns platform-specific responses
 
-**Example:**
+**Examples:**
+
 ```ts
+// AWS Lambda
 import { createApp } from '@vercube/core';
 import { toServerlessHandler } from '@vercube/serverless/aws-lambda';
 
@@ -121,6 +163,15 @@ const app = createApp();
 export const handler = toServerlessHandler(app);
 ```
 
+```ts
+// Azure Functions
+import { createApp } from '@vercube/core';
+import { toServerlessHandler } from '@vercube/serverless/azure-functions';
+
+const app = createApp();
+export const handler = toServerlessHandler(app);
+```
+
 ---
 
 ## 🔄 Request/Response Conversion
@@ -128,16 +179,18 @@ export const handler = toServerlessHandler(app);
 The serverless adapters handle automatic conversion between platform-specific events and standard web requests:
 
 ### Request Conversion
+
 - **HTTP Method** - Extracted from event properties
 - **URL Construction** - Built from path, query parameters, and headers
 - **Headers** - Converted to standard Headers object
 - **Body** - Properly decoded and converted to Request body
 
 ### Response Conversion
+
 - **Status Code** - Mapped from Response status
 - **Headers** - Converted to platform-specific format
-- **Body** - Encoded appropriately (text vs binary)
-- **Cookies** - Handled for both API Gateway versions
+- **Body** - Encoded appropriately (text vs binary for AWS, AsyncIterableIterator for Azure)
+- **Cookies** - Handled for both API Gateway versions and Azure Functions
 
 ---
 
@@ -146,7 +199,8 @@ The serverless adapters handle automatic conversion between platform-specific ev
 - **Streaming Support** - Efficient handling of large request/response bodies
 - **Memory Optimization** - Minimal memory footprint for serverless environments
 - **Cold Start Optimization** - Fast initialization and request processing
-- **Binary Content** - Optimized base64 encoding for binary responses
+- **Binary Content** - Optimized base64 encoding for binary responses (AWS Lambda)
+- **AsyncIterableIterator** - Efficient streaming for Azure Functions responses
 
 ---
 
@@ -160,8 +214,8 @@ import { toServerlessHandler } from '@vercube/serverless/aws-lambda';
 
 const app = createApp({
   logger: {
-    level: 'debug'
-  }
+    level: 'debug',
+  },
 });
 
 export const handler = toServerlessHandler(app);
@@ -180,13 +234,13 @@ Explore guides, API references, and best practices to master Vercube serverless
 
 This module is inspired by:
 
-* [Nitro AWS Lambda Preset](https://nitro.build/presets/aws-lambda)
-* [Hono AWS Lambda Adapter](https://hono.dev/guides/aws-lambda)
-* [Vercel Serverless Functions](https://vercel.com/docs/functions)
+- [Nitro AWS Lambda Preset](https://nitro.build/presets/aws-lambda)
+- [Hono AWS Lambda Adapter](https://hono.dev/guides/aws-lambda)
+- [Vercel Serverless Functions](https://vercel.com/docs/functions)
+- [hono-azurefunc-adapter](https://github.com/Marplex/hono-azurefunc-adapter)
 
 ---
 
 ## 🪪 License
 
 [MIT License](https://github.com/vercube/vercube/blob/main/LICENSE)
-

package/dist/Adapters/aws-lambda/index.d.mts

@@ -1,4 +1,4 @@
-import { ServerlessHandler } from "../../ServerlessTypes-lXnSKHNA.mjs";
+import { ServerlessHandler } from "../../ServerlessTypes-WMcCL6v7.mjs";
 import { App } from "@vercube/core";
 import { APIGatewayProxyEvent, APIGatewayProxyEventV2 } from "aws-lambda";
 

package/dist/Adapters/aws-lambda/index.mjs

@@ -1,15 +1,52 @@
+import { getHeaderValue, toBuffer } from "../../streams-jCOA2riB.mjs";
 import { stringifyQuery } from "ufo";
 
-//#region src/Adapters/aws-lambda/Utils/Request.ts
+//#region src/Utils/content-type.ts
+const DEFAULT_CONTENT_TYPE$1 = "";
+const TEXT_CONTENT_TYPE_PATTERNS = [
+	/^text\//,
+	/^application\/(json|javascript|xml|xml\+text|x-www-form-urlencoded)$/,
+	/^application\/.*\+json$/,
+	/^application\/.*\+xml$/,
+	/utf-?8/
+];
+/**
+* Determines if a content type should be treated as text content.
+*
+* This function uses a set of patterns to identify text-based content types:
+* - Content types starting with "text/" (e.g., text/plain, text/html)
+* - JavaScript, JSON, or XML content types
+* - Content types containing UTF-8 encoding specification
+*
+* The function performs case-insensitive matching to handle various content type
+* formats and specifications.
+*
+* @param contentType - The content type string to evaluate (e.g., "text/plain", "application/json")
+* @returns True if the content type should be treated as text, false otherwise
+*/
+function isTextType(contentType = DEFAULT_CONTENT_TYPE$1) {
+	if (!contentType) return false;
+	return TEXT_CONTENT_TYPE_PATTERNS.some((pattern) => pattern.test(contentType));
+}
+
+//#endregion
+//#region src/Utils/constants.ts
 const DEFAULT_METHOD = "GET";
 const DEFAULT_HOSTNAME = ".";
 const HTTP_PROTOCOL = "http";
 const HTTPS_PROTOCOL = "https";
+const DEFAULT_BODY = "";
+const DEFAULT_CONTENT_TYPE = "";
+const UTF8_ENCODING = "utf8";
+const BASE64_ENCODING = "base64";
 const HEADER_KEYS = {
 	HOST: ["host", "Host"],
 	X_FORWARDED_PROTO: ["X-Forwarded-Proto", "x-forwarded-proto"],
 	COOKIE: "cookie"
 };
+
+//#endregion
+//#region src/Adapters/aws-lambda/Utils/Request.ts
 /**
 * Type guard to check if an event is APIGatewayProxyEventV2
 */
@@ -23,23 +60,12 @@ function isV1Event(event) {
 	return "httpMethod" in event;
 }
 /**
-* Safely gets a header value with case-insensitive fallback
-*/
-function getHeaderValue(headers, keys) {
-	if (!headers) return void 0;
-	for (const key of keys) {
-		const value = headers[key];
-		if (value !== void 0) return value;
-	}
-	return void 0;
-}
-/**
 * Extracts the HTTP method from an API Gateway event.
-* 
+*
 * Handles both v1 and v2 event formats:
 * - v1: Uses `httpMethod` property
 * - v2: Uses `requestContext.http.method` property
-* 
+*
 * @param event - The AWS API Gateway event object (v1 or v2 format)
 * @returns The HTTP method as a string, defaults to 'GET' if not found
 */
@@ -50,13 +76,13 @@ function getEventMethod(event) {
 }
 /**
 * Constructs a complete URL from an API Gateway event.
-* 
+*
 * Builds the URL by combining:
 * - Protocol (http/https based on X-Forwarded-Proto header)
 * - Hostname (from headers or requestContext)
 * - Path (from event path properties)
 * - Query string (from query parameters)
-* 
+*
 * @param event - The AWS API Gateway event object (v1 or v2 format)
 * @returns A complete URL object
 */
@@ -88,16 +114,15 @@ function getEventPath(event) {
 * Determines the protocol from the event headers
 */
 function getEventProtocol(event) {
-	const forwardedProto = getHeaderValue(event.headers, HEADER_KEYS.X_FORWARDED_PROTO);
-	return forwardedProto === HTTP_PROTOCOL ? HTTP_PROTOCOL : HTTPS_PROTOCOL;
+	return getHeaderValue(event.headers, HEADER_KEYS.X_FORWARDED_PROTO) === HTTP_PROTOCOL ? HTTP_PROTOCOL : HTTPS_PROTOCOL;
 }
 /**
 * Extracts and formats query parameters from an API Gateway event.
-* 
+*
 * Handles both v1 and v2 event formats:
 * - v2: Uses `rawQueryString` if available
 * - v1: Combines `queryStringParameters` and `multiValueQueryStringParameters`
-* 
+*
 * @param event - The AWS API Gateway event object (v1 or v2 format)
 * @returns A formatted query string (without the leading '?')
 */
@@ -113,11 +138,11 @@ function getEventQuery(event) {
 }
 /**
 * Converts API Gateway event headers to a standard Headers object.
-* 
+*
 * Processes all headers from the event and handles cookies specially:
 * - Sets all event headers in the Headers object
 * - Appends cookies from the event's cookies array (v2 format)
-* 
+*
 * @param event - The AWS API Gateway event object (v1 or v2 format)
 * @returns A Headers object with all event headers and cookies
 */
@@ -133,17 +158,17 @@ function getEventHeaders(event) {
 }
 /**
 * Extracts the request body from an API Gateway event.
-* 
+*
 * Handles different body formats:
 * - Returns undefined if no body is present
 * - Decodes base64-encoded bodies when `isBase64Encoded` is true
 * - Returns the raw body string for regular requests
-* 
+*
 * @param event - The AWS API Gateway event object (v1 or v2 format)
 * @returns The request body as BodyInit (string, Buffer, or undefined)
 */
 function getEventBody(event) {
-	if (!event.body || event.body === null) return void 0;
+	if (!event.body || event.body === null) return;
 	if (event.isBase64Encoded) try {
 		return Buffer.from(event.body, "base64");
 	} catch {
@@ -153,13 +178,13 @@ function getEventBody(event) {
 }
 /**
 * Converts an AWS API Gateway event to a standard Request object.
-* 
+*
 * This function handles both APIGatewayProxyEvent (v1) and APIGatewayProxyEventV2 (v2) formats,
 * extracting the HTTP method, URL, headers, and body to create a web-standard Request object.
-* 
+*
 * This file is highly inspired by the `awsRequest` from `nitro`
 * @see https://github.com/nitrojs/nitro/blob/v3/src/presets/aws-lambda/runtime/_utils.ts
-* 
+*
 * @param event - The AWS API Gateway event object (v1 or v2 format)
 * @returns A new Request object with the extracted event data
 * @throws {Error} If the event is invalid or missing required properties
@@ -179,29 +204,18 @@ function convertEventToRequest(event) {
 
 //#endregion
 //#region src/Adapters/aws-lambda/Utils/Response.ts
-const DEFAULT_BODY = "";
-const DEFAULT_CONTENT_TYPE = "";
-const UTF8_ENCODING = "utf8";
-const BASE64_ENCODING = "base64";
-const TEXT_CONTENT_TYPE_PATTERNS = [
-	/^text\//,
-	/^application\/(json|javascript|xml|xml\+text|x-www-form-urlencoded)$/,
-	/^application\/.*\+json$/,
-	/^application\/.*\+xml$/,
-	/utf-?8/
-];
 /**
 * Converts a standard web Response object to AWS API Gateway compatible response format.
-* 
+*
 * This function transforms the Response headers and cookies into the format expected by
 * AWS API Gateway proxy integrations. It handles both v1 and v2 API Gateway formats:
 * - v1: Uses `multiValueHeaders` for cookies
 * - v2: Uses `cookies` array for cookies
-* 
+*
 * The function processes all response headers, converting them to the appropriate format
 * for AWS Lambda integration. Headers with multiple values are joined with commas,
 * and cookies are handled specially for both API Gateway versions.
-* 
+*
 * @param response - The standard web Response object to convert
 * @returns An object containing headers and cookies in AWS API Gateway format
 * @throws {Error} If the response object is invalid or headers cannot be processed
@@ -224,21 +238,21 @@ function convertResponseToAWSResponse(response) {
 }
 /**
 * Converts a Response body to AWS API Gateway compatible format with proper encoding.
-* 
+*
 * AWS Lambda proxy integrations require special handling for binary content:
 * - Text content types are returned as UTF-8 strings
 * - Binary content types are base64 encoded with the `isBase64Encoded` flag set
-* 
+*
 * This function determines the appropriate encoding based on the response's content-type
 * header and converts the body accordingly. It supports both text and binary content
 * types, ensuring compatibility with API Gateway's payload encoding requirements.
-* 
+*
 * Binary media types should be configured as * in API Gateway settings.
 * @see https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-payload-encodings.html
-* 
+*
 * This function is heavily inspired by the `awsResponseBody` from `nitro`
 * @see https://github.com/nitrojs/nitro/blob/v3/src/presets/aws-lambda/runtime/_utils.ts
-* 
+*
 * @param response - The standard web Response object containing the body to convert
 * @returns A promise that resolves to an object with the encoded body and encoding flag
 * @throws {Error} If the response body cannot be read or converted
@@ -259,80 +273,30 @@ async function convertBodyToAWSResponse(response) {
 		throw new Error(`Failed to convert response body: ${errorMessage}`);
 	}
 }
-/**
-* Determines if a content type should be treated as text content.
-* 
-* This function uses a set of patterns to identify text-based content types:
-* - Content types starting with "text/" (e.g., text/plain, text/html)
-* - JavaScript, JSON, or XML content types
-* - Content types containing UTF-8 encoding specification
-* 
-* The function performs case-insensitive matching to handle various content type
-* formats and specifications.
-* 
-* @param contentType - The content type string to evaluate (e.g., "text/plain", "application/json")
-* @returns True if the content type should be treated as text, false otherwise
-*/
-function isTextType(contentType = DEFAULT_CONTENT_TYPE) {
-	if (!contentType) return false;
-	return TEXT_CONTENT_TYPE_PATTERNS.some((pattern) => pattern.test(contentType));
-}
-/**
-* Converts a ReadableStream to a Buffer using Web Streams API.
-* 
-* This function reads all chunks from a ReadableStream and concatenates them
-* into a single Buffer. It uses the modern Web Streams API with WritableStream
-* to efficiently process the stream data without blocking.
-* 
-* The function handles stream errors gracefully and provides proper cleanup
-* of stream resources. It's designed to work with Response.body streams
-* from fetch API responses.
-* 
-* @param data - The ReadableStream to convert to a Buffer
-* @returns A promise that resolves to a Buffer containing all stream data
-* @throws {Error} If the stream cannot be read or an error occurs during processing
-*/
-function toBuffer(data) {
-	return new Promise((resolve, reject) => {
-		const chunks = [];
-		const writableStream = new WritableStream({
-			write(chunk) {
-				chunks.push(chunk);
-			},
-			close() {
-				resolve(Buffer.concat(chunks));
-			},
-			abort(reason) {
-				reject(/* @__PURE__ */ new Error("Stream aborted: " + String(reason)));
-			}
-		});
-		data.pipeTo(writableStream).catch(reject);
-	});
-}
 
 //#endregion
 //#region src/Adapters/aws-lambda/index.ts
 /**
 * Converts a Vercube App instance into an AWS Lambda handler function for API Gateway integration.
-* 
+*
 * This function creates a serverless handler that bridges between AWS API Gateway events and
 * the Vercube application framework. It handles the conversion of AWS Lambda events to standard
 * web Request objects, processes them through the Vercube app, and converts the responses back
 * to the format expected by AWS API Gateway.
-* 
+*
 * The handler supports both API Gateway v1 (APIGatewayProxyEvent) and v2 (APIGatewayProxyEventV2)
 * event formats, automatically detecting and handling the appropriate format. It processes:
 * - HTTP method, URL, headers, and body from the Lambda event
 * - Converts them to a standard web Request object
 * - Passes the request through the Vercube application
 * - Converts the Response back to AWS API Gateway format
-* 
+*
 * The returned handler function can be directly used as an AWS Lambda function handler,
 * providing seamless integration between AWS Lambda and Vercube applications.
-* 
+*
 * @param app - The Vercube App instance that will handle the requests
 * @returns An async function that accepts AWS API Gateway events and returns API Gateway responses
-* 
+*
 * @see {@link convertEventToRequest} For details on event to request conversion
 * @see {@link convertResponseToAWSResponse} For details on response header conversion
 * @see {@link convertBodyToAWSResponse} For details on response body conversion

package/dist/Adapters/azure-functions/index.d.mts

@@ -0,0 +1,32 @@
+import { ServerlessHandler } from "../../ServerlessTypes-WMcCL6v7.mjs";
+import { App } from "@vercube/core";
+import { HttpRequest } from "@azure/functions";
+
+//#region src/Adapters/azure-functions/index.d.ts
+
+/**
+ * Converts a Vercube App instance into an Azure Functions handler function for HTTP integration.
+ *
+ * This function creates a serverless handler that bridges between Azure Functions HTTP triggers
+ * and the Vercube application framework. It handles the conversion of Azure Functions HttpRequest
+ * objects to standard web Request objects, processes them through the Vercube app, and converts
+ * the responses back to the format expected by Azure Functions.
+ *
+ * The handler processes:
+ * - HTTP method, URL, headers, and body from the Azure Functions HttpRequest
+ * - Converts them to a standard web Request object
+ * - Passes the request through the Vercube application
+ * - Converts the Response back to Azure Functions HttpResponseInit format
+ *
+ * The returned handler function can be directly used as an Azure Functions HTTP trigger handler,
+ * providing seamless integration between Azure Functions and Vercube applications.
+ *
+ * @param app - The Vercube App instance that will handle the requests
+ * @returns An async function that accepts Azure Functions HttpRequest and returns HttpResponseInit
+ *
+ * @see {@link convertEventToRequest} For details on HttpRequest to Request conversion
+ * @see {@link convertResponseToAzureFunctionsResponse} For details on Response to HttpResponseInit conversion
+ */
+declare function toServerlessHandler(app: App): ServerlessHandler<HttpRequest, any>;
+//#endregion
+export { toServerlessHandler };

package/dist/Adapters/azure-functions/index.mjs

@@ -0,0 +1,193 @@
+import { headersToObject, streamToAsyncIterator } from "../../streams-jCOA2riB.mjs";
+
+//#region src/Utils/cookies.ts
+/**
+* Parses a cookie string into a generic cookie object.
+*
+* This function parses a standard Set-Cookie header string and extracts all cookie attributes
+* including name, value, path, sameSite, secure, httpOnly, domain, expires, and maxAge.
+* It handles URL decoding of the cookie value and proper type conversion for boolean and
+* numeric attributes.
+*
+* The function expects cookie strings in the format:
+* "name=value; path=/; secure; httpOnly; sameSite=Strict; domain=example.com; expires=Wed, 09 Jun 2021 10:18:14 GMT; max-age=3600"
+*
+* @param cookieString - The Set-Cookie header string to parse
+* @returns A GenericCookie object with all parsed attributes
+* @throws {Error} If the cookie string format is invalid or cannot be parsed
+*/
+function parseCookieString(cookieString) {
+	if (!cookieString || typeof cookieString !== "string") throw new Error("Invalid cookie string: must be a non-empty string");
+	const [nameValue, ...attributeParts] = cookieString.split(";");
+	const [nameRaw, encodedValue] = nameValue.split("=");
+	const name = nameRaw ? nameRaw.trim().toLowerCase() : "";
+	if (!name || encodedValue === void 0) throw new Error("Invalid cookie string: must contain a name and value separated by \"=\"");
+	const attributesArray = attributeParts.map((part) => part.split("=")).map(([key, value]) => [key.trim().toLowerCase(), value ?? "true"]);
+	const attrs = Object.fromEntries(attributesArray);
+	return {
+		name,
+		value: encodedValue ? decodeURIComponent(encodedValue) : "",
+		path: attrs["path"],
+		sameSite: attrs["samesite"],
+		secure: attrs["secure"] === "true",
+		httpOnly: attrs["httponly"] === "true",
+		domain: attrs["domain"],
+		expires: attrs["expires"] ? new Date(attrs["expires"]) : void 0,
+		maxAge: attrs["max-age"] ? Number.parseInt(attrs["max-age"], 10) : void 0
+	};
+}
+/**
+* Extracts cookies from a Headers object and converts them to generic cookie format.
+*
+* This function processes the Set-Cookie headers from a standard web Response Headers object
+* and converts them into generic cookie objects. It handles the case where no cookies are
+* present by returning undefined.
+*
+* @param headers - The Headers object from a web Response
+* @returns An array of GenericCookie objects, or undefined if no cookies are present
+*/
+function cookiesFromHeaders$1(headers) {
+	const cookies = headers.getSetCookie();
+	if (cookies.length === 0) return void 0;
+	return cookies.map(parseCookieString);
+}
+
+//#endregion
+//#region src/Adapters/azure-functions/Utils/Request.ts
+/**
+* Converts an Azure Functions HttpRequest to a standard web Request object.
+*
+* This function bridges the gap between Azure Functions HTTP triggers and the standard
+* web Request API. It extracts the HTTP method, URL, headers, and body from the Azure
+* Functions HttpRequest and creates a standard Request object that can be used with
+* the Vercube application framework.
+*
+* The function handles:
+* - HTTP method extraction from the request
+* - URL preservation from the Azure Functions request
+* - Header conversion from Azure Functions format to standard Headers
+* - Body handling for non-GET/HEAD requests with proper duplex stream support
+*
+* This file is highly inspired by the `newRequestFromAzureFunctions` from `hono-azurefunc-adapter`
+* @see https://github.com/Marplex/hono-azurefunc-adapter/blob/main/src/request.ts
+*
+* @param request - The Azure Functions HttpRequest object to convert
+* @returns A standard web Request object compatible with the fetch API
+* @throws {Error} If the request object is invalid or missing required properties
+*/
+function convertEventToRequest(request) {
+	const hasBody = !["GET", "HEAD"].includes(request.method);
+	return new Request(request.url, {
+		method: request.method,
+		headers: headersToObject(request.headers),
+		...hasBody ? {
+			body: request.body,
+			duplex: "half"
+		} : {}
+	});
+}
+
+//#endregion
+//#region src/Adapters/azure-functions/Utils/Utils.ts
+/**
+* Extracts cookies from a Headers object and converts them to Azure Functions Cookie format.
+*
+* This function processes the Set-Cookie headers from a standard web Response Headers object
+* and converts them into the Cookie format expected by Azure Functions. It handles the case
+* where no cookies are present by returning undefined.
+*
+* @param headers - The Headers object from a web Response
+* @returns An array of Cookie objects, or undefined if no cookies are present
+*/
+function cookiesFromHeaders(headers) {
+	const genericCookies = cookiesFromHeaders$1(headers);
+	if (!genericCookies) return void 0;
+	return genericCookies.map(convertGenericCookieToAzure);
+}
+/**
+* Converts a generic cookie object to Azure Functions Cookie format.
+*
+* @param genericCookie - The generic cookie object to convert
+* @returns An Azure Functions Cookie object
+*/
+function convertGenericCookieToAzure(genericCookie) {
+	return {
+		name: genericCookie.name,
+		value: genericCookie.value,
+		path: genericCookie.path,
+		sameSite: genericCookie.sameSite,
+		secure: genericCookie.secure,
+		httpOnly: genericCookie.httpOnly,
+		domain: genericCookie.domain,
+		expires: genericCookie.expires,
+		maxAge: genericCookie.maxAge
+	};
+}
+
+//#endregion
+//#region src/Adapters/azure-functions/Utils/Response.ts
+/**
+* Converts a standard web Response object to Azure Functions HttpResponseInit format.
+*
+* This function transforms a standard web Response object into the format expected by
+* Azure Functions HTTP responses. It handles the conversion of headers, cookies, status
+* code, and body to ensure compatibility with Azure Functions runtime.
+*
+* The function processes:
+* - Response headers conversion to plain object format
+* - Set-Cookie headers extraction and conversion to Azure Functions Cookie format
+* - HTTP status code preservation
+* - Response body conversion to AsyncIterableIterator for Azure Functions compatibility
+*
+* This file is highly inspired by the `newAzureFunctionsResponse` from `hono-azurefunc-adapter`
+* @see https://github.com/Marplex/hono-azurefunc-adapter/blob/main/src/response.ts
+*
+* @param response - The standard web Response object to convert
+* @returns An HttpResponseInit object compatible with Azure Functions
+* @throws {Error} If the response object is invalid or missing required properties
+*/
+function convertResponseToAzureFunctionsResponse(response) {
+	const headers = headersToObject(response.headers);
+	return {
+		cookies: cookiesFromHeaders(response.headers),
+		headers,
+		status: response.status,
+		body: streamToAsyncIterator(response.body)
+	};
+}
+
+//#endregion
+//#region src/Adapters/azure-functions/index.ts
+/**
+* Converts a Vercube App instance into an Azure Functions handler function for HTTP integration.
+*
+* This function creates a serverless handler that bridges between Azure Functions HTTP triggers
+* and the Vercube application framework. It handles the conversion of Azure Functions HttpRequest
+* objects to standard web Request objects, processes them through the Vercube app, and converts
+* the responses back to the format expected by Azure Functions.
+*
+* The handler processes:
+* - HTTP method, URL, headers, and body from the Azure Functions HttpRequest
+* - Converts them to a standard web Request object
+* - Passes the request through the Vercube application
+* - Converts the Response back to Azure Functions HttpResponseInit format
+*
+* The returned handler function can be directly used as an Azure Functions HTTP trigger handler,
+* providing seamless integration between Azure Functions and Vercube applications.
+*
+* @param app - The Vercube App instance that will handle the requests
+* @returns An async function that accepts Azure Functions HttpRequest and returns HttpResponseInit
+*
+* @see {@link convertEventToRequest} For details on HttpRequest to Request conversion
+* @see {@link convertResponseToAzureFunctionsResponse} For details on Response to HttpResponseInit conversion
+*/
+function toServerlessHandler(app) {
+	return async (event) => {
+		const request = convertEventToRequest(event);
+		const response = await app.fetch(request);
+		return convertResponseToAzureFunctionsResponse(response);
+	};
+}
+
+//#endregion
+export { toServerlessHandler };

package/dist/index.d.mts

@@ -1,2 +1,2 @@
-import { ServerlessHandler } from "./ServerlessTypes-lXnSKHNA.mjs";
+import { ServerlessHandler } from "./ServerlessTypes-WMcCL6v7.mjs";
 export { ServerlessHandler };

package/dist/streams-jCOA2riB.mjs

@@ -0,0 +1,108 @@
+//#region src/Utils/headers.ts
+/**
+* Converts a loopable header object to a plain JavaScript object.
+*
+* This function is used to convert header objects (which have a forEach method)
+* into standard JavaScript objects with string keys and values. This is necessary for
+* compatibility with the standard web Headers API and other parts of the application.
+*
+* @param input - A header-like object with a forEach method
+* @returns A plain object with string keys and string values representing the headers
+*/
+function headersToObject(input) {
+	const headers = {};
+	input.forEach((value, key) => {
+		headers[key] = value;
+	});
+	return headers;
+}
+/**
+* Safely gets a header value with case-insensitive fallback.
+*
+* This utility function searches through a headers object using multiple possible
+* key variations to find a header value. It's useful for handling headers that
+* might have different casing across different platforms.
+*
+* @param headers - The headers object to search in
+* @param keys - Array of possible header keys to try (in order of preference)
+* @returns The header value if found, undefined otherwise
+*/
+function getHeaderValue(headers, keys) {
+	if (!headers) return;
+	for (const key of keys) {
+		const value = headers[key];
+		if (value !== void 0) return value;
+	}
+}
+
+//#endregion
+//#region src/Utils/streams.ts
+/**
+* Converts a ReadableStream to a Buffer using Web Streams API.
+*
+* This function reads all chunks from a ReadableStream and concatenates them
+* into a single Buffer. It uses the modern Web Streams API with WritableStream
+* to efficiently process the stream data without blocking.
+*
+* The function handles stream errors gracefully and provides proper cleanup
+* of stream resources. It's designed to work with Response.body streams
+* from fetch API responses.
+*
+* @param data - The ReadableStream to convert to a Buffer
+* @returns A promise that resolves to a Buffer containing all stream data
+* @throws {Error} If the stream cannot be read or an error occurs during processing
+*/
+function toBuffer(data) {
+	return new Promise((resolve, reject) => {
+		const chunks = [];
+		const writableStream = new WritableStream({
+			write(chunk) {
+				chunks.push(chunk);
+			},
+			close() {
+				resolve(Buffer.concat(chunks));
+			},
+			abort(reason) {
+				reject(/* @__PURE__ */ new Error("Stream aborted: " + String(reason)));
+			}
+		});
+		data.pipeTo(writableStream).catch(reject);
+	});
+}
+/**
+* Converts a ReadableStream to an AsyncIterableIterator for platform compatibility.
+*
+* Some serverless platforms expect response bodies to be AsyncIterableIterator<Uint8Array>.
+* This function wraps a standard web ReadableStream to provide the required interface
+* for serverless HTTP responses.
+*
+* The returned iterator provides:
+* - `next()` method that reads chunks from the stream
+* - `return()` method that releases the stream reader lock
+* - Symbol.asyncIterator for async iteration support
+*
+* @param readable - The ReadableStream from a Response body, or null/undefined
+* @returns An AsyncIterableIterator<Uint8Array> or null if no readable stream provided
+*/
+function streamToAsyncIterator(readable) {
+	if (readable == null) return null;
+	const reader = readable.getReader();
+	return {
+		next() {
+			return reader.read();
+		},
+		return() {
+			reader.releaseLock();
+			return Promise.resolve({
+				done: true,
+				value: void 0
+			});
+		},
+		[Symbol.asyncIterator]() {
+			return this;
+		}
+	};
+}
+
+//#endregion
+export { getHeaderValue, headersToObject, streamToAsyncIterator, toBuffer };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercube/serverless",
-  "version": "0.0.22",
+  "version": "0.0.24",
   "description": "Serverless module for Vercube framework",
   "repository": {
     "type": "git",
@@ -15,7 +15,8 @@
   "exports": {
     ".": "./dist/index.mjs",
     "./package.json": "./package.json",
-    "./aws-lambda": "./dist/Adapters/aws-lambda/index.mjs"
+    "./aws-lambda": "./dist/Adapters/aws-lambda/index.mjs",
+    "./azure-functions": "./dist/Adapters/azure-functions/index.mjs"
   },
   "types": "./dist/index.d.mts",
   "files": [
@@ -35,12 +36,12 @@
   ],
   "dependencies": {
     "ufo": "1.6.1",
-    "@vercube/core": "0.0.22",
-    "@vercube/di": "0.0.22"
+    "@vercube/core": "0.0.24",
+    "@vercube/di": "0.0.24"
   },
   "devDependencies": {
-    "@types/aws-lambda": "8.10.152",
-    "@azure/functions": "4.7.2-preview"
+    "@azure/functions": "4.8.0",
+    "@types/aws-lambda": "8.10.152"
   },
   "publishConfig": {
     "access": "public"