@vercube/serverless 0.0.41 → 0.0.43

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

@@ -1,4 +1,4 @@
-import { t as ServerlessHandler } from "../../ServerlessTypes-CIdGp_-x.mjs";
+import { t as ServerlessHandler } from "../../ServerlessTypes-XdyGzZOn.mjs";
 import { App } from "@vercube/core";
 import { Writable } from "node:stream";
 
@@ -242,6 +242,21 @@ interface APIGatewayProxyEventBase<TAuthorizerContext> {
   requestContext: APIGatewayEventRequestContextWithAuthorizer<TAuthorizerContext>;
   resource: string;
 }
+/**
+ * Works with Lambda Proxy Integration for Rest API or HTTP API integration Payload Format version 1.0
+ * @see - https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-develop-integrations-lambda.html
+ */
+interface APIGatewayProxyResult {
+  statusCode: number;
+  headers?: {
+    [header: string]: boolean | number | string;
+  } | undefined;
+  multiValueHeaders?: {
+    [header: string]: Array<boolean | number | string>;
+  } | undefined;
+  body: string;
+  isBase64Encoded?: boolean | undefined;
+}
 /**
  * Works with HTTP API integration Payload Format version 2.0
  * @see - https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-develop-integrations-lambda.html
@@ -288,6 +303,25 @@ interface APIGatewayProxyEventV2WithRequestContext<TRequestContext> {
  * Default Proxy event with no Authorizer
  */
 type APIGatewayProxyEventV2 = APIGatewayProxyEventV2WithRequestContext<APIGatewayEventRequestContextV2>;
+/**
+ * Works with HTTP API integration Payload Format version 2.0
+ * @see - https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-develop-integrations-lambda.html
+ */
+type APIGatewayProxyResultV2<T = never> = APIGatewayProxyStructuredResultV2 | string | T;
+/**
+ * Interface for structured response with `statusCode` and`headers`
+ * Works with HTTP API integration Payload Format version 2.0
+ * @see - https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-develop-integrations-lambda.html
+ */
+interface APIGatewayProxyStructuredResultV2 {
+  statusCode?: number | undefined;
+  headers?: {
+    [header: string]: boolean | number | string;
+  } | undefined;
+  body?: string | undefined;
+  isBase64Encoded?: boolean | undefined;
+  cookies?: string[] | undefined;
+}
 //#endregion
 //#region src/Adapters/aws-lambda/index.d.ts
 /**
@@ -315,6 +349,6 @@ type APIGatewayProxyEventV2 = APIGatewayProxyEventV2WithRequestContext<APIGatewa
  * @see {@link convertResponseToAWSResponse} For details on response header conversion
  * @see {@link convertBodyToAWSResponse} For details on response body conversion
  */
-declare function toServerlessHandler(app: App): ServerlessHandler<APIGatewayProxyEvent | APIGatewayProxyEventV2>;
+declare function toServerlessHandler(app: App): ServerlessHandler<APIGatewayProxyEvent | APIGatewayProxyEventV2, APIGatewayProxyResult | APIGatewayProxyResultV2, Context>;
 //#endregion
 export { toServerlessHandler };

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

@@ -1,278 +1,5 @@
-import { n as toBuffer, r as getHeaderValue } from "../../streams-gpVDFRFm.mjs";
-import { stringifyQuery } from "ufo";
+import { toLambdaHandler } from "srvx/aws-lambda";
 
-//#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
-*/
-function isV2Event(event) {
-	return "requestContext" in event && "http" in event.requestContext && "method" in event.requestContext.http;
-}
-/**
-* Type guard to check if an event is APIGatewayProxyEvent
-*/
-function isV1Event(event) {
-	return "httpMethod" in event;
-}
-/**
-* 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
-*/
-function getEventMethod(event) {
-	if (isV1Event(event)) return event.httpMethod || DEFAULT_METHOD;
-	if (isV2Event(event)) return event.requestContext?.http?.method || DEFAULT_METHOD;
-	return DEFAULT_METHOD;
-}
-/**
-* 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
-*/
-function getEventUrl(event) {
-	const hostname = getEventHostname(event);
-	const path = getEventPath(event);
-	const query = getEventQuery(event);
-	const protocol = getEventProtocol(event);
-	const urlPath = query ? `${path}?${query}` : path;
-	return new URL(urlPath, `${protocol}://${hostname}`);
-}
-/**
-* Extracts the hostname from the event
-*/
-function getEventHostname(event) {
-	const hostHeader = getHeaderValue(event.headers, HEADER_KEYS.HOST);
-	if (hostHeader) return hostHeader;
-	return event.requestContext?.domainName || DEFAULT_HOSTNAME;
-}
-/**
-* Extracts the path from the event
-*/
-function getEventPath(event) {
-	if (isV1Event(event)) return event.path || "/";
-	if (isV2Event(event)) return event.rawPath || "/";
-	return "/";
-}
-/**
-* Determines the protocol from the event headers
-*/
-function getEventProtocol(event) {
-	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 '?')
-*/
-function getEventQuery(event) {
-	if (isV2Event(event) && typeof event.rawQueryString === "string") return event.rawQueryString;
-	const queryParams = event.queryStringParameters || {};
-	const multiValueParams = isV1Event(event) ? event.multiValueQueryStringParameters || {} : {};
-	return stringifyQuery({
-		...queryParams,
-		...multiValueParams
-	});
-}
-/**
-* 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
-*/
-function getEventHeaders(event) {
-	const headers = new Headers();
-	if (event.headers) {
-		for (const [key, value] of Object.entries(event.headers)) if (value !== void 0 && value !== null) headers.set(key, value);
-	}
-	if (isV2Event(event) && event.cookies && Array.isArray(event.cookies)) {
-		for (const cookie of event.cookies) if (cookie) headers.append(HEADER_KEYS.COOKIE, cookie);
-	}
-	return headers;
-}
-/**
-* 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;
-	if (event.isBase64Encoded) try {
-		return Buffer.from(event.body, "base64");
-	} catch {
-		return event.body;
-	}
-	return event.body;
-}
-/**
-* 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
-*/
-function convertEventToRequest(event) {
-	if (!event || typeof event !== "object") throw new Error("Invalid event: event must be a valid object");
-	const method = getEventMethod(event);
-	const url = getEventUrl(event);
-	const headers = getEventHeaders(event);
-	const body = getEventBody(event);
-	return new Request(url, {
-		method,
-		headers,
-		body
-	});
-}
-
-//#endregion
-//#region src/Adapters/aws-lambda/Utils/Response.ts
-/**
-* 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
-*/
-function convertResponseToAWSResponse(response) {
-	if (!response || !response.headers) throw new Error("Invalid response: response must be a valid Response object with headers");
-	const headers = Object.create(null);
-	response.headers.forEach((value, key) => {
-		if (value !== void 0 && value !== null) headers[key] = Array.isArray(value) ? value.join(",") : String(value);
-		else if (value === null) headers[key] = "null";
-		else if (value === void 0) headers[key] = "undefined";
-	});
-	const cookies = typeof response.headers.getSetCookie === "function" ? response.headers.getSetCookie() : [];
-	if (cookies.length > 0) return {
-		headers,
-		cookies,
-		multiValueHeaders: { "set-cookie": cookies }
-	};
-	return { headers };
-}
-/**
-* 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
-*/
-async function convertBodyToAWSResponse(response) {
-	if (!response) throw new Error("Invalid response: response must be a valid Response object");
-	if (!response.body) return { body: DEFAULT_BODY };
-	try {
-		const buffer = await toBuffer(response.body);
-		if (isTextType(response.headers.get("content-type") || DEFAULT_CONTENT_TYPE)) return { body: buffer.toString(UTF8_ENCODING) };
-		else return {
-			body: buffer.toString(BASE64_ENCODING),
-			isBase64Encoded: true
-		};
-	} catch (error) {
-		const errorMessage = error instanceof Error ? error.message : "Unknown error";
-		throw new Error(`Failed to convert response body: ${errorMessage}`);
-	}
-}
-
-//#endregion
 //#region src/Adapters/aws-lambda/index.ts
 /**
 * Converts a Vercube App instance into an AWS Lambda handler function for API Gateway integration.
@@ -300,15 +27,9 @@ async function convertBodyToAWSResponse(response) {
 * @see {@link convertBodyToAWSResponse} For details on response body conversion
 */
 function toServerlessHandler(app) {
-	return async (event) => {
-		const request = convertEventToRequest(event);
-		const response = await app.fetch(request);
-		return {
-			statusCode: response.status,
-			...convertResponseToAWSResponse(response),
-			...await convertBodyToAWSResponse(response)
-		};
-	};
+	return toLambdaHandler({ fetch: async (request) => {
+		return await app.fetch(request);
+	} });
 }
 
 //#endregion

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

@@ -1,10 +1,10 @@
-import { t as ServerlessHandler } from "../../ServerlessTypes-CIdGp_-x.mjs";
+import { t as ServerlessHandler } from "../../ServerlessTypes-XdyGzZOn.mjs";
 import { App } from "@vercube/core";
 import { Blob } from "buffer";
 import { ReadableStream } from "stream/web";
 import { URLSearchParams } from "url";
 
-//#region ../../node_modules/.pnpm/@azure+functions@4.11.0/node_modules/@azure/functions/types/http.d.ts
+//#region ../../node_modules/.pnpm/@azure+functions@4.11.1/node_modules/@azure/functions/types/http.d.ts
 /**
  * HTTP request object. Provided to your function when using HTTP Bindings.
  */

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

@@ -1,5 +1,23 @@
-import { i as headersToObject, t as streamToAsyncIterator } from "../../streams-gpVDFRFm.mjs";
+//#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;
+}
 
+//#endregion
 //#region src/Utils/cookies.ts
 /**
 * Parses a cookie string into a generic cookie object.
@@ -152,7 +170,7 @@ function convertResponseToAzureFunctionsResponse(response) {
 		cookies: cookiesFromHeaders(response.headers),
 		headers,
 		status: response.status,
-		body: streamToAsyncIterator(response.body)
+		body: response.body
 	};
 }
 

package/dist/{ServerlessTypes-CIdGp_-x.d.mts → ServerlessTypes-XdyGzZOn.d.mts}

@@ -1,6 +1,6 @@
 import { MaybePromise } from "@vercube/core";
 
 //#region src/Types/ServerlessTypes.d.ts
-type ServerlessHandler<Event = unknown, HandlerResponse = unknown> = (event: Event) => MaybePromise<HandlerResponse>;
+type ServerlessHandler<Event = unknown, HandlerResponse = unknown, Context = unknown> = (event: Event, context?: Context) => MaybePromise<HandlerResponse>;
 //#endregion
 export { ServerlessHandler as t };

package/dist/index.d.mts

@@ -1,2 +1,2 @@
-import { t as ServerlessHandler } from "./ServerlessTypes-CIdGp_-x.mjs";
+import { t as ServerlessHandler } from "./ServerlessTypes-XdyGzZOn.mjs";
 export { ServerlessHandler };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercube/serverless",
-  "version": "0.0.41",
+  "version": "0.0.43",
   "description": "Serverless module for Vercube framework",
   "repository": {
     "type": "git",
@@ -36,12 +36,13 @@
     "azure-function-http"
   ],
   "dependencies": {
+    "srvx": "0.11.0",
     "ufo": "1.6.3",
-    "@vercube/core": "0.0.41",
-    "@vercube/di": "0.0.41"
+    "@vercube/core": "0.0.43",
+    "@vercube/di": "0.0.43"
   },
   "devDependencies": {
-    "@azure/functions": "4.11.0",
+    "@azure/functions": "4.11.1",
     "@types/aws-lambda": "8.10.160"
   },
   "publishConfig": {

package/dist/streams-gpVDFRFm.mjs

@@ -1,108 +0,0 @@
-//#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 { headersToObject as i, toBuffer as n, getHeaderValue as r, streamToAsyncIterator as t };