@vercube/serverless 0.0.34 → 0.0.36

package/README.md

@@ -1,246 +1,40 @@
 <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>
+  <img src="https://raw.githubusercontent.com/vercube/vercube/refs/heads/main/.github/assets/cover.png" width="100%" alt="Vercube - Unleash your server development." />
   <br>
   <br>
 
 # @vercube/serverless
 
-Serverless deployment adapters for Vercube applications
+### Serverless adapters for Vercube
 
-  <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>
-  <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>
-
-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.
-
----
+[![Ask DeepWiki](<https://img.shields.io/badge/ask-deepwiki-%20blue?style=for-the-badge&logo=bookstack&logoColor=rgba(255%2C%20255%2C%20255%2C%200.6)&labelColor=%23000&color=%232f2f2f>)](https://deepwiki.com/vercube/vercube)
+![NPM Version](<https://img.shields.io/npm/v/%40vercube%2Fserverless?style=for-the-badge&logo=npm&logoColor=rgba(255%2C%20255%2C%20255%2C%200.6)&labelColor=%23000&color=%232e2e2e&link=https%3A%2F%2Fwww.npmjs.com%2Fpackage%2F%40vercube%2Fserverless>)
+![GitHub License](<https://img.shields.io/github/license/vercube/vercube?style=for-the-badge&logo=gitbook&logoColor=rgba(255%2C%20255%2C%20255%2C%200.6)&labelColor=%23000&color=%232f2f2f>)
+![Codecov](<https://img.shields.io/codecov/c/github/vercube/vercube?style=for-the-badge&logo=vitest&logoColor=rgba(255%2C%20255%2C%20255%2C%200.6)&labelColor=%23000&color=%232f2f2f>)
 
-## 🧩 `@vercube/serverless` Module
+**Deploy your Vercube app to AWS Lambda or Azure Functions. Same code, different platform - just swap the adapter.**
 
-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.
+[Website](https://vercube.dev) • [Documentation](https://vercube.dev/docs/getting-started)
 
-### ✅ Key Features
+</div>
 
-- **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 and Azure Functions
-- **Error Handling** - Robust error handling and validation
-- **Performance Optimized** - Efficient request/response conversion
+## ✨ Features
 
----
+- **AWS Lambda** - full API Gateway v1 and v2 support
+- **Azure Functions** - HTTP triggers, streaming, the works
+- **Zero config** - works with your existing Vercube app
+- **Binary support** - handles images, files, whatever you throw at it
 
-## 🚀 Installation
+## 📦 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);
-```
-
-### 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,
-});
+pnpm add @vercube/serverless
 ```
 
-### 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
-
-### 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
-
-### `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
-
-**Examples:**
-
-```ts
-// AWS Lambda
-import { createApp } from '@vercube/core';
-import { toServerlessHandler } from '@vercube/serverless/aws-lambda';
-
-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
-
-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 for AWS, AsyncIterableIterator for Azure)
-- **Cookies** - Handled for both API Gateway versions and Azure Functions
-
----
-
-## 🚀 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 (AWS Lambda)
-- **AsyncIterableIterator** - Efficient streaming for Azure Functions 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)
-- [hono-azurefunc-adapter](https://github.com/Marplex/hono-azurefunc-adapter)
+## 📖 Usage
 
----
+Check out the full [documentation](https://vercube.dev/docs/modules/serverless/overview)
 
-## 🪪 License
+## 📜 License
 
-[MIT License](https://github.com/vercube/vercube/blob/main/LICENSE)
+[MIT](https://github.com/vercube/vercube/blob/main/LICENSE)

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

@@ -1,9 +1,295 @@
-import { t as ServerlessHandler } from "../../ServerlessTypes-3cDqKHky.mjs";
+import { t as ServerlessHandler } from "../../ServerlessTypes-CIdGp_-x.mjs";
 import { App } from "@vercube/core";
-import { APIGatewayProxyEvent, APIGatewayProxyEventV2 } from "aws-lambda";
+import { Writable } from "node:stream";
 
+//#region ../../node_modules/.pnpm/@types+aws-lambda@8.10.160/node_modules/@types/aws-lambda/common/api-gateway.d.ts
+// Default authorizer type, prefer using a specific type with the "...WithAuthorizer..." variant types.
+// Note that this doesn't have to be a context from a custom lambda outhorizer, AWS also has a cognito
+// authorizer type and could add more, so the property won't always be a string.
+type APIGatewayEventDefaultAuthorizerContext = undefined | null | {
+  [name: string]: any;
+};
+// The requestContext property of both request authorizer and proxy integration events.
+interface APIGatewayEventRequestContextWithAuthorizer<TAuthorizerContext> {
+  accountId: string;
+  apiId: string; // This one is a bit confusing: it is not actually present in authorizer calls
+  // and proxy calls without an authorizer. We model this by allowing undefined in the type,
+  // since it ends up the same and avoids breaking users that are testing the property.
+  // This lets us allow parameterizing the authorizer for proxy events that know what authorizer
+  // context values they have.
+  authorizer: TAuthorizerContext;
+  connectedAt?: number | undefined;
+  connectionId?: string | undefined;
+  domainName?: string | undefined;
+  domainPrefix?: string | undefined;
+  eventType?: string | undefined;
+  extendedRequestId?: string | undefined;
+  protocol: string;
+  httpMethod: string;
+  identity: APIGatewayEventIdentity;
+  messageDirection?: string | undefined;
+  messageId?: string | null | undefined;
+  path: string;
+  stage: string;
+  requestId: string;
+  requestTime?: string | undefined;
+  requestTimeEpoch: number;
+  resourceId: string;
+  resourcePath: string;
+  routeKey?: string | undefined;
+}
+interface APIGatewayEventClientCertificate {
+  clientCertPem: string;
+  serialNumber: string;
+  subjectDN: string;
+  issuerDN: string;
+  validity: {
+    notAfter: string;
+    notBefore: string;
+  };
+}
+interface APIGatewayEventIdentity {
+  accessKey: string | null;
+  accountId: string | null;
+  apiKey: string | null;
+  apiKeyId: string | null;
+  caller: string | null;
+  clientCert: APIGatewayEventClientCertificate | null;
+  cognitoAuthenticationProvider: string | null;
+  cognitoAuthenticationType: string | null;
+  cognitoIdentityId: string | null;
+  cognitoIdentityPoolId: string | null;
+  principalOrgId: string | null;
+  sourceIp: string;
+  user: string | null;
+  userAgent: string | null;
+  userArn: string | null;
+  vpcId?: string | undefined;
+  vpceId?: string | undefined;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@types+aws-lambda@8.10.160/node_modules/@types/aws-lambda/handler.d.ts
+/**
+ * {@link Handler} context parameter.
+ * See {@link https://docs.aws.amazon.com/lambda/latest/dg/nodejs-prog-model-context.html AWS documentation}.
+ */
+interface Context {
+  callbackWaitsForEmptyEventLoop: boolean;
+  functionName: string;
+  functionVersion: string;
+  invokedFunctionArn: string;
+  memoryLimitInMB: string;
+  awsRequestId: string;
+  logGroupName: string;
+  logStreamName: string;
+  identity?: CognitoIdentity | undefined;
+  clientContext?: ClientContext | undefined;
+  tenantId?: string | undefined;
+  getRemainingTimeInMillis(): number; // Functions for compatibility with earlier Node.js Runtime v0.10.42
+  // No longer documented, so they are deprecated, but they still work
+  // as of the 12.x runtime, so they are not removed from the types.
+  /** @deprecated Use handler callback or promise result */
+  done(error?: Error, result?: any): void;
+  /** @deprecated Use handler callback with first argument or reject a promise result */
+  fail(error: Error | string): void;
+  /** @deprecated Use handler callback with second argument or resolve a promise result */
+  succeed(messageOrObject: any): void; // Unclear what behavior this is supposed to have, I couldn't find any still extant reference,
+  // and it behaves like the above, ignoring the object parameter.
+  /** @deprecated Use handler callback or promise result */
+  succeed(message: string, object: any): void;
+}
+interface CognitoIdentity {
+  cognitoIdentityId: string;
+  cognitoIdentityPoolId: string;
+}
+interface ClientContext {
+  client: ClientContextClient;
+  custom?: any;
+  env: ClientContextEnv;
+}
+interface ClientContextClient {
+  installationId: string;
+  appTitle: string;
+  appVersionName: string;
+  appVersionCode: string;
+  appPackageName: string;
+}
+interface ClientContextEnv {
+  platformVersion: string;
+  platform: string;
+  make: string;
+  model: string;
+  locale: string;
+}
+/**
+ * Interface for using response streaming from AWS Lambda.
+ * To indicate to the runtime that Lambda should stream your function’s responses, you must wrap your function handler with the `awslambda.streamifyResponse()` decorator.
+ *
+ * The `streamifyResponse` decorator accepts the following additional parameter, `responseStream`, besides the default node handler parameters, `event`, and `context`.
+ * The new `responseStream` object provides a stream object that your function can write data to. Data written to this stream is sent immediately to the client. You can optionally set the Content-Type header of the response to pass additional metadata to your client about the contents of the stream.
+ *
+ * {@link https://aws.amazon.com/blogs/compute/introducing-aws-lambda-response-streaming/ AWS blog post}
+ * {@link https://docs.aws.amazon.com/lambda/latest/dg/config-rs-write-functions.html AWS documentation}
+ *
+ * @example <caption>Writing to the response stream</caption>
+ * import 'aws-lambda';
+ *
+ * export const handler = awslambda.streamifyResponse(
+ *   async (event, responseStream, context) => {
+ *       responseStream.setContentType("text/plain");
+ *       responseStream.write("Hello, world!");
+ *       responseStream.end();
+ *   }
+ * );
+ *
+ * @example <caption>Using pipeline</caption>
+ * import 'aws-lambda';
+ * import { Readable } from 'stream';
+ * import { pipeline } from 'stream/promises';
+ * import zlib from 'zlib';
+ *
+ * export const handler = awslambda.streamifyResponse(
+ *   async (event, responseStream, context) => {
+ *     // As an example, convert event to a readable stream.
+ *     const requestStream = Readable.from(Buffer.from(JSON.stringify(event)));
+ *
+ *     await pipeline(requestStream, zlib.createGzip(), responseStream);
+ *   }
+ * );
+ */
+type StreamifyHandler<TEvent = any, TResult = any> = (event: TEvent, responseStream: awslambda.HttpResponseStream, context: Context) => TResult | Promise<TResult>;
+declare global {
+  namespace awslambda {
+    class HttpResponseStream extends Writable {
+      static from(writable: Writable, metadata: Record<string, unknown>): HttpResponseStream;
+      setContentType: (contentType: string) => void;
+    }
+    /**
+     * Decorator for using response streaming from AWS Lambda.
+     * To indicate to the runtime that Lambda should stream your function’s responses, you must wrap your function handler with the `awslambda.streamifyResponse()` decorator.
+     *
+     * The `streamifyResponse` decorator accepts the following additional parameter, `responseStream`, besides the default node handler parameters, `event`, and `context`.
+     * The new `responseStream` object provides a stream object that your function can write data to. Data written to this stream is sent immediately to the client. You can optionally set the Content-Type header of the response to pass additional metadata to your client about the contents of the stream.
+     *
+     * {@link https://aws.amazon.com/blogs/compute/introducing-aws-lambda-response-streaming/ AWS blog post}
+     * {@link https://docs.aws.amazon.com/lambda/latest/dg/config-rs-write-functions.html AWS documentation}
+     *
+     * @example <caption>Writing to the response stream</caption>
+     * import 'aws-lambda';
+     *
+     * export const handler = awslambda.streamifyResponse(
+     *   async (event, responseStream, context) => {
+     *       responseStream.setContentType("text/plain");
+     *       responseStream.write("Hello, world!");
+     *       responseStream.end();
+     *   }
+     * );
+     *
+     * @example <caption>Using pipeline</caption>
+     * import 'aws-lambda';
+     * import { Readable } from 'stream';
+     * import { pipeline } from 'stream/promises';
+     * import zlib from 'zlib';
+     *
+     * export const handler = awslambda.streamifyResponse(
+     *   async (event, responseStream, context) => {
+     *     // As an example, convert event to a readable stream.
+     *     const requestStream = Readable.from(Buffer.from(JSON.stringify(event)));
+     *
+     *     await pipeline(requestStream, zlib.createGzip(), responseStream);
+     *   }
+     * );
+     */
+    function streamifyResponse<TEvent = any, TResult = void>(handler: StreamifyHandler<TEvent, TResult>): StreamifyHandler<TEvent, TResult>;
+  }
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@types+aws-lambda@8.10.160/node_modules/@types/aws-lambda/trigger/api-gateway-proxy.d.ts
+/**
+ * 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
+ */
+type APIGatewayProxyEvent = APIGatewayProxyEventBase<APIGatewayEventDefaultAuthorizerContext>;
+interface APIGatewayProxyEventHeaders {
+  [name: string]: string | undefined;
+}
+interface APIGatewayProxyEventMultiValueHeaders {
+  [name: string]: string[] | undefined;
+}
+interface APIGatewayProxyEventPathParameters {
+  [name: string]: string | undefined;
+}
+interface APIGatewayProxyEventQueryStringParameters {
+  [name: string]: string | undefined;
+}
+interface APIGatewayProxyEventMultiValueQueryStringParameters {
+  [name: string]: string[] | undefined;
+}
+interface APIGatewayProxyEventStageVariables {
+  [name: string]: string | undefined;
+}
+interface APIGatewayProxyEventBase<TAuthorizerContext> {
+  body: string | null;
+  headers: APIGatewayProxyEventHeaders;
+  multiValueHeaders: APIGatewayProxyEventMultiValueHeaders;
+  httpMethod: string;
+  isBase64Encoded: boolean;
+  path: string;
+  pathParameters: APIGatewayProxyEventPathParameters | null;
+  queryStringParameters: APIGatewayProxyEventQueryStringParameters | null;
+  multiValueQueryStringParameters: APIGatewayProxyEventMultiValueQueryStringParameters | null;
+  stageVariables: APIGatewayProxyEventStageVariables | null;
+  requestContext: APIGatewayEventRequestContextWithAuthorizer<TAuthorizerContext>;
+  resource: string;
+}
+/**
+ * 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 APIGatewayEventRequestContextV2 {
+  accountId: string;
+  apiId: string;
+  authentication?: {
+    clientCert: APIGatewayEventClientCertificate;
+  };
+  domainName: string;
+  domainPrefix: string;
+  http: {
+    method: string;
+    path: string;
+    protocol: string;
+    sourceIp: string;
+    userAgent: string;
+  };
+  requestId: string;
+  routeKey: string;
+  stage: string;
+  time: string;
+  timeEpoch: number;
+}
+/**
+ * Proxy Event with adaptable requestContext for different authorizer scenarios
+ */
+interface APIGatewayProxyEventV2WithRequestContext<TRequestContext> {
+  version: string;
+  routeKey: string;
+  rawPath: string;
+  rawQueryString: string;
+  cookies?: string[];
+  headers: APIGatewayProxyEventHeaders;
+  queryStringParameters?: APIGatewayProxyEventQueryStringParameters;
+  requestContext: TRequestContext;
+  body?: string;
+  pathParameters?: APIGatewayProxyEventPathParameters;
+  isBase64Encoded: boolean;
+  stageVariables?: APIGatewayProxyEventStageVariables;
+}
+/**
+ * Default Proxy event with no Authorizer
+ */
+type APIGatewayProxyEventV2 = APIGatewayProxyEventV2WithRequestContext<APIGatewayEventRequestContextV2>;
+//#endregion
 //#region src/Adapters/aws-lambda/index.d.ts
-
 /**
  * Converts a Vercube App instance into an AWS Lambda handler function for API Gateway integration.
  *

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

@@ -1,4 +1,4 @@
-import { n as toBuffer, r as getHeaderValue } from "../../streams-CBN0Ix32.mjs";
+import { n as toBuffer, r as getHeaderValue } from "../../streams-gpVDFRFm.mjs";
 import { stringifyQuery } from "ufo";
 
 //#region src/Utils/content-type.ts

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

@@ -1,9 +1,139 @@
-import { t as ServerlessHandler } from "../../ServerlessTypes-3cDqKHky.mjs";
+import { t as ServerlessHandler } from "../../ServerlessTypes-CIdGp_-x.mjs";
 import { App } from "@vercube/core";
-import { HttpRequest } from "@azure/functions";
+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
+/**
+ * HTTP request object. Provided to your function when using HTTP Bindings.
+ */
+declare class HttpRequest {
+  /**
+   * For testing purposes only. This will always be constructed for you when run in the context of the Azure Functions runtime
+   */
+  constructor(httpRequestInit: HttpRequestInit);
+  /**
+   * HTTP request method used to invoke this function.
+   */
+  readonly method: string;
+  /**
+   * Request URL.
+   */
+  readonly url: string;
+  /**
+   * HTTP request headers.
+   */
+  readonly headers: Headers;
+  /**
+   * Query string parameter keys and values from the URL.
+   */
+  readonly query: URLSearchParams;
+  /**
+   * Route parameter keys and values.
+   */
+  readonly params: HttpRequestParams;
+  /**
+   *  Object representing logged-in user, either through
+   *  AppService/Functions authentication, or SWA Authentication
+   *  null when no such user is logged in.
+   */
+  readonly user: HttpRequestUser | null;
+  /**
+   * Returns the body as a ReadableStream
+   */
+  readonly body: ReadableStream | null;
+  /**
+   * Returns whether the body has been read from
+   */
+  readonly bodyUsed: boolean;
+  /**
+   * Returns a promise fulfilled with the body as an ArrayBuffer
+   */
+  readonly arrayBuffer: () => Promise<ArrayBuffer>;
+  /**
+   * Returns a promise fulfilled with the body as a Blob
+   */
+  readonly blob: () => Promise<Blob>;
+  /**
+   * Returns a promise fulfilled with the body as FormData
+   */
+  readonly formData: () => Promise<FormData>;
+  /**
+   * Returns a promise fulfilled with the body parsed as JSON
+   */
+  readonly json: () => Promise<unknown>;
+  /**
+   * Returns a promise fulfilled with the body as a string
+   */
+  readonly text: () => Promise<string>;
+  /**
+   * Creates a copy of the request object, with special handling of the body.
+   * [Learn more here](https://developer.mozilla.org/docs/Web/API/Request/clone)
+   */
+  readonly clone: () => HttpRequest;
+}
+/**
+ * Route parameter keys and values.
+ */
+type HttpRequestParams = Record<string, string>;
+/**
+ *  Object representing logged-in user, either through
+ *  AppService/Functions authentication, or SWA Authentication
+ */
+interface HttpRequestUser {
+  /**
+   * Type of authentication, either AppService or StaticWebApps
+   */
+  type: HttpRequestUserType;
+  /**
+   * unique user GUID
+   */
+  id: string;
+  /**
+   * unique username
+   */
+  username: string;
+  /**
+   * provider of authentication service
+   */
+  identityProvider: string;
+  /**
+   * Extra authentication information, dependent on auth type
+   * and auth provider
+   */
+  claimsPrincipalData: Record<string, unknown>;
+}
+/**
+ * Possible values for an HTTP Request user type
+ */
+type HttpRequestUserType = 'AppService' | 'StaticWebApps';
+/**
+ * For testing purposes only. This will always be constructed for you when run in the context of the Azure Functions runtime
+ */
+interface HttpRequestInit {
+  method?: string;
+  url?: string;
+  body?: HttpRequestBodyInit;
+  headers?: Record<string, string>;
+  query?: Record<string, string>;
+  params?: Record<string, string>;
+}
+/**
+ * For testing purposes only. This will always be constructed for you when run in the context of the Azure Functions runtime
+ */
+interface HttpRequestBodyInit {
+  /**
+   * The body as a buffer. You only need to specify one of the `bytes` or `string` properties
+   */
+  bytes?: Uint8Array;
+  /**
+   * The body as a string. You only need to specify one of the `bytes` or `string` properties
+   */
+  string?: string;
+}
+//#endregion
 //#region src/Adapters/azure-functions/index.d.ts
-
 /**
  * Converts a Vercube App instance into an Azure Functions handler function for HTTP integration.
  *

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

@@ -1,4 +1,4 @@
-import { i as headersToObject, t as streamToAsyncIterator } from "../../streams-CBN0Ix32.mjs";
+import { i as headersToObject, t as streamToAsyncIterator } from "../../streams-gpVDFRFm.mjs";
 
 //#region src/Utils/cookies.ts
 /**

package/dist/index.d.mts

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercube/serverless",
-  "version": "0.0.34",
+  "version": "0.0.36",
   "description": "Serverless module for Vercube framework",
   "repository": {
     "type": "git",
@@ -10,8 +10,6 @@
   "license": "MIT",
   "sideEffects": false,
   "type": "module",
-  "main": "./dist/index.mjs",
-  "module": "./dist/index.mjs",
   "exports": {
     ".": "./dist/index.mjs",
     "./package.json": "./package.json",
@@ -32,16 +30,19 @@
     "aws-serverless",
     "aws-api-gateway",
     "aws-apigw",
-    "aws-apigw-lambda"
+    "aws-apigw-lambda",
+    "azure-functions",
+    "azure-function",
+    "azure-function-http"
   ],
   "dependencies": {
-    "ufo": "1.6.1",
-    "@vercube/core": "0.0.34",
-    "@vercube/di": "0.0.34"
+    "ufo": "1.6.3",
+    "@vercube/core": "0.0.36",
+    "@vercube/di": "0.0.36"
   },
   "devDependencies": {
-    "@azure/functions": "4.9.0",
-    "@types/aws-lambda": "8.10.159"
+    "@azure/functions": "4.11.0",
+    "@types/aws-lambda": "8.10.160"
   },
   "publishConfig": {
     "access": "public"