@vercube/serverless 0.0.22

package/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2025-present - Vercube
+
+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

@@ -0,0 +1,192 @@
+<div align="center">
+  <a href="https://vercube.dev/"><img src="https://github.com/OskarLebuda/vue-lazy-hydration/raw/main/.github/assets/logo.png?raw=true" alt="Vercube logo" width="200"></a>
+  <br>
+  <br>
+
+  # @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>
+  <a href="https://www.npmjs.com/package/@vercube/serverless">
+    <img src="https://img.shields.io/npm/dm/%40vercube%2Fserverless?style=for-the-badge&logo=npm&color=%23767eff" alt="npm"/>
+  </a>
+  <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>
+  <br/>
+  <br/>
+</div>
+
+Deploy your Vercube applications to serverless platforms with zero configuration. This package provides seamless adapters for AWS Lambda, Vercel, and other serverless providers, allowing you to run your Vercube apps anywhere without code changes.
+
+---
+
+## 🧩 `@vercube/serverless` Module
+
+The `@vercube/serverless` module provides unified, provider-agnostic adapters for deploying Vercube applications to serverless platforms. It abstracts the differences between various serverless providers into a consistent API, enabling easy deployment across different environments without modifying your application code.
+
+### ✅ Key Features
+
+- **AWS Lambda Integration** - Full support for API Gateway v1 and v2
+- **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
+- **Error Handling** - Robust error handling and validation
+- **Performance Optimized** - Efficient request/response conversion
+
+---
+
+## 🚀 Installation
+
+```bash
+pnpm install @vercube/serverless
+```
+
+---
+
+## ⚙️ Usage
+
+### AWS Lambda Integration
+
+Deploy your Vercube application to AWS Lambda with API Gateway:
+
+```ts
+// lambda.ts
+import { createApp } from '@vercube/core';
+import { toServerlessHandler } from '@vercube/serverless/aws-lambda';
+
+const app = createApp();
+export const handler = toServerlessHandler(app);
+```
+
+### Serverless Framework Configuration
+
+```yaml
+# serverless.yml
+service: vercube-app
+
+provider:
+  name: aws
+  runtime: nodejs22.x
+  region: us-east-1
+
+functions:
+  api:
+    handler: lambda.handler
+    events:
+      - http:
+          path: /{proxy+}
+          method: ANY
+          cors: true
+```
+
+---
+
+## 🔧 Supported Platforms
+
+### AWS Lambda
+
+Full support for AWS Lambda with API Gateway integration:
+
+- **API Gateway v1** - Complete compatibility with `APIGatewayProxyEvent`
+- **API Gateway v2** - Full support for `APIGatewayProxyEventV2`
+- **Binary Content** - Automatic base64 encoding for binary responses
+- **Cookies** - Proper cookie handling for both API Gateway versions
+- **Headers** - Complete header conversion and processing
+
+---
+
+## 📋 API Reference
+
+### `toServerlessHandler(app: App)`
+
+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:**
+```ts
+import { createApp } from '@vercube/core';
+import { toServerlessHandler } from '@vercube/serverless/aws-lambda';
+
+const app = createApp();
+export const handler = toServerlessHandler(app);
+```
+
+---
+
+## 🔄 Request/Response Conversion
+
+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
+
+---
+
+## 🚀 Performance Considerations
+
+- **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
+
+---
+
+## 🔍 Debugging
+
+Enable debug logging to troubleshoot serverless deployments:
+
+```ts
+import { createApp } from '@vercube/core';
+import { toServerlessHandler } from '@vercube/serverless/aws-lambda';
+
+const app = createApp({
+  logger: {
+    level: 'debug'
+  }
+});
+
+export const handler = toServerlessHandler(app);
+```
+
+---
+
+## 📚 Documentation
+
+Full documentation is available at [**vercube.dev**](https://vercube.dev).
+Explore guides, API references, and best practices to master Vercube serverless deployment.
+
+---
+
+## 🙌 Credits
+
+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)
+
+---
+
+## 🪪 License
+
+[MIT License](https://github.com/vercube/vercube/blob/main/LICENSE)
+

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

@@ -0,0 +1,34 @@
+import { ServerlessHandler } from "../../ServerlessTypes-lXnSKHNA.mjs";
+import { App } from "@vercube/core";
+import { APIGatewayProxyEvent, APIGatewayProxyEventV2 } from "aws-lambda";
+
+//#region src/Adapters/aws-lambda/index.d.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
+ */
+declare function toServerlessHandler(app: App): ServerlessHandler<APIGatewayProxyEvent | APIGatewayProxyEventV2>;
+//#endregion
+export { toServerlessHandler };

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

@@ -0,0 +1,353 @@
+import { stringifyQuery } from "ufo";
+
+//#region src/Adapters/aws-lambda/Utils/Request.ts
+const DEFAULT_METHOD = "GET";
+const DEFAULT_HOSTNAME = ".";
+const HTTP_PROTOCOL = "http";
+const HTTPS_PROTOCOL = "https";
+const HEADER_KEYS = {
+	HOST: ["host", "Host"],
+	X_FORWARDED_PROTO: ["X-Forwarded-Proto", "x-forwarded-proto"],
+	COOKIE: "cookie"
+};
+/**
+* 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;
+}
+/**
+* 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
+*/
+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) {
+	const forwardedProto = getHeaderValue(event.headers, HEADER_KEYS.X_FORWARDED_PROTO);
+	return forwardedProto === 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 || {} : {};
+	const combinedParams = {
+		...queryParams,
+		...multiValueParams
+	};
+	return stringifyQuery(combinedParams);
+}
+/**
+* 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 void 0;
+	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
+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
+*/
+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);
+		const contentType = response.headers.get("content-type") || DEFAULT_CONTENT_TYPE;
+		if (isTextType(contentType)) 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}`);
+	}
+}
+/**
+* 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
+*/
+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)
+		};
+	};
+}
+
+//#endregion
+export { toServerlessHandler };

package/dist/ServerlessTypes-lXnSKHNA.d.mts

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

package/dist/index.d.mts

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

package/dist/index.mjs

@@ -0,0 +1 @@
+export {  };

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "@vercube/serverless",
+  "version": "0.0.22",
+  "description": "Serverless module for Vercube framework",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/vercube/vercube.git",
+    "directory": "packages/serverless"
+  },
+  "license": "MIT",
+  "sideEffects": false,
+  "type": "module",
+  "main": "./dist/index.mjs",
+  "module": "./dist/index.mjs",
+  "exports": {
+    ".": "./dist/index.mjs",
+    "./package.json": "./package.json",
+    "./aws-lambda": "./dist/Adapters/aws-lambda/index.mjs"
+  },
+  "types": "./dist/index.d.mts",
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "keywords": [
+    "vercube",
+    "serverless",
+    "aws",
+    "lambda",
+    "aws-lambda",
+    "aws-serverless",
+    "aws-api-gateway",
+    "aws-apigw",
+    "aws-apigw-lambda"
+  ],
+  "dependencies": {
+    "ufo": "1.6.1",
+    "@vercube/core": "0.0.22",
+    "@vercube/di": "0.0.22"
+  },
+  "devDependencies": {
+    "@types/aws-lambda": "8.10.152",
+    "@azure/functions": "4.7.2-preview"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsdown --config tsdown.config.ts"
+  }
+}