@stone-js/aws-lambda-http-adapter 0.1.0

package/dist/index.js

@@ -0,0 +1,889 @@
+import { IntegrationError, Adapter, AdapterEventBuilder, defaultLoggerResolver, isNotEmpty, defaultKernelResolver, classDecoratorLegacyWrapper, addBlueprint } from '@stone-js/core';
+import { IncomingHttpEvent, HTTP_INTERNAL_SERVER_ERROR, BinaryFileResponse, OutgoingHttpResponse, CookieCollection, isIpTrusted, getHostname, getProtocol, httpCoreBlueprint, isMultipart, getCharset, getType, getFilesUploads } from '@stone-js/http-core';
+import mime from 'mime';
+import accepts from 'accepts';
+import statuses from 'statuses';
+import { getString } from '@stone-js/env';
+import { File } from '@stone-js/filesystem';
+import proxyAddr from 'proxy-addr';
+import bytes from 'bytes';
+import typeIs from 'type-is';
+
+/**
+ * Wrapper for HTTP raw responses in AWS Lambda.
+ *
+ * The `RawHttpResponseWrapper` is responsible for constructing and returning
+ * a raw HTTP response that conforms to the expected structure for AWS Lambda.
+ * It implements the `IRawResponseWrapper` interface, ensuring compatibility
+ * with the Stone.js framework.
+ */
+class RawHttpResponseWrapper {
+    options;
+    /**
+     * Factory method to create an instance of `RawHttpResponseWrapper`.
+     *
+     * This method accepts partial response options, allowing the user to configure
+     * only the required fields. It initializes the wrapper with these options.
+     *
+     * @param options - Partial options to configure the HTTP response.
+     * @returns A new instance of `RawHttpResponseWrapper`.
+     *
+     * @example
+     * ```typescript
+     * const responseWrapper = RawHttpResponseWrapper.create({
+     *   statusCode: 200,
+     *   body: { message: 'Success' },
+     *   headers: { 'Content-Type': 'application/json' }
+     * });
+     *
+     * const response = responseWrapper.respond();
+     * console.log(response); // { statusCode: 200, body: '{"message":"Success"}', headers: { 'Content-Type': 'application/json' } }
+     * ```
+     */
+    static create(options) {
+        return new this(options);
+    }
+    /**
+     * Constructs an instance of `RawHttpResponseWrapper`.
+     *
+     * This constructor is private and should not be called directly.
+     * Use the `create` method to initialize an instance.
+     *
+     * @param options - Partial options for configuring the HTTP response.
+     */
+    constructor(options) {
+        this.options = options;
+    }
+    /**
+     * Constructs and returns the raw HTTP response.
+     *
+     * The `respond` method generates a `RawHttpResponse` object based on the
+     * provided options. If any required fields are missing, it assigns default values:
+     * - `statusCode`: Defaults to `500`.
+     *
+     * @returns A `RawHttpResponse` object.
+     *
+     * @example
+     * ```typescript
+     * const responseWrapper = RawHttpResponseWrapper.create({ body: 'Hello, world!', statusCode: 200 });
+     * const response = responseWrapper.respond();
+     * console.log(response); // { statusCode: 500, statusMessage: '', body: 'Hello, world!', headers: undefined }
+     * ```
+     */
+    respond() {
+        return {
+            ...this.options,
+            statusCode: this.options.statusCode ?? 500
+        };
+    }
+}
+
+/**
+ * Custom error for AWS Lambda adapter operations.
+ */
+class AwsLambdaHttpAdapterError extends IntegrationError {
+    constructor(message, options) {
+        super(message, options);
+        this.name = 'AwsLambdaHttpAdapterError';
+    }
+}
+
+/**
+ * AWS Lambda HTTP Adapter for Stone.js.
+ *
+ * The `AwsLambdaHttpAdapter` extends the functionality of the Stone.js `Adapter`
+ * to provide seamless integration with AWS Lambda for HTTP-based events. This adapter
+ * transforms incoming HTTP events from AWS Lambda into `IncomingHttpEvent` instances
+ * and produces a `RawHttpResponse` as output.
+ *
+ * This adapter simplifies the process of handling HTTP events within AWS Lambda
+ * while adhering to the Stone.js framework's event-driven architecture.
+ *
+ * @template AwsLambdaHttpEvent - The type of the raw HTTP event from AWS Lambda.
+ * @template RawHttpResponse - The type of the raw HTTP response to send back.
+ * @template AwsLambdaContext - The AWS Lambda execution context type.
+ * @template IncomingHttpEvent - The type of the processed incoming HTTP event.
+ * @template IncomingHttpEventOptions - Options used to create an incoming HTTP event.
+ * @template OutgoingHttpResponse - The type of the outgoing HTTP response after processing.
+ * @template AwsLambdaHttpAdapterContext - Context type specific to the HTTP adapter.
+ *
+ * @extends Adapter
+ *
+ * @example
+ * ```typescript
+ * import { AwsLambdaHttpAdapter } from '@stone-js/aws-lambda-http-adapter';
+ *
+ * const adapter = AwsLambdaHttpAdapter.create({...});
+ *
+ * const handler = await adapter.run();
+ *
+ * export { handler };
+ * ```
+ *
+ * @see {@link https://stone-js.com/docs Stone.js Documentation}
+ * @see {@link https://docs.aws.amazon.com/lambda/latest/dg/ AWS Lambda Documentation}
+ */
+class AwsLambdaHttpAdapter extends Adapter {
+    /**
+     * Creates an instance of the `AwsLambdaHttpAdapter`.
+     *
+     * @param blueprint - The application blueprint.
+     * @returns A new instance of `AwsLambdaHttpAdapter`.
+     *
+     * @example
+     * ```typescript
+     * const adapter = AwsLambdaHttpAdapter.create(blueprint);
+     * await adapter.run();
+     * ```
+     */
+    static create(blueprint) {
+        return new this(blueprint);
+    }
+    /**
+     * Executes the adapter and provides an AWS Lambda-compatible HTTP handler function.
+     *
+     * This method initializes the adapter and returns a handler function that can
+     * process HTTP events in AWS Lambda. It transforms raw events into `IncomingHttpEvent`
+     * instances and produces `RawHttpResponse` objects as output.
+     *
+     * @template ExecutionResultType - The type representing the AWS Lambda event handler function.
+     * @returns A promise resolving to the AWS Lambda HTTP handler function.
+     * @throws {AwsLambdaHttpAdapterError} If used outside the AWS Lambda environment.
+     */
+    async run() {
+        await this.onStart();
+        const handler = async (rawEvent, executionContext) => {
+            return await this.eventListener(rawEvent, executionContext);
+        };
+        return handler;
+    }
+    /**
+     * Initializes the adapter and validates its execution context.
+     *
+     * Ensures that the adapter is running in an AWS Lambda environment. Throws an error
+     * if it detects that the adapter is being used in an unsupported environment (e.g., a browser).
+     *
+     * @throws {AwsLambdaHttpAdapterError} If executed outside an AWS Lambda environment.
+     */
+    async onStart() {
+        if (typeof window === 'object') {
+            throw new AwsLambdaHttpAdapterError('This `AWSLambdaAdapter` must be used only in AWS Lambda context.');
+        }
+        await this.executeHooks('onStart');
+    }
+    /**
+     * Processes an incoming AWS Lambda HTTP event.
+     *
+     * Converts a raw AWS Lambda HTTP event into an `IncomingHttpEvent`, processes it through
+     * the Stone.js pipeline, and generates a `RawHttpResponse` to send back.
+     *
+     * @param rawEvent - The raw HTTP event received from AWS Lambda.
+     * @param executionContext - The AWS Lambda execution context associated with the event.
+     * @returns A promise resolving to the processed `RawHttpResponse`.
+     */
+    async eventListener(rawEvent, executionContext) {
+        const incomingEventBuilder = AdapterEventBuilder.create({
+            resolver: (options) => IncomingHttpEvent.create(options)
+        });
+        const rawResponseBuilder = AdapterEventBuilder.create({
+            resolver: (options) => RawHttpResponseWrapper.create(options)
+        });
+        const rawResponse = { statusCode: 500 };
+        const context = {
+            rawEvent,
+            rawResponse,
+            executionContext,
+            rawResponseBuilder,
+            incomingEventBuilder
+        };
+        try {
+            const eventHandler = this.resolveEventHandler();
+            await this.executeEventHandlerHooks('onInit', eventHandler);
+            return await this.sendEventThroughDestination(context, eventHandler);
+        }
+        catch (error) {
+            const rawResponseBuilder = await this.handleError(error, context);
+            return await this.buildRawResponse({ ...context, rawResponseBuilder });
+        }
+    }
+}
+
+/**
+ * Class representing an AwsLambdaHttpErrorHandler.
+ */
+class AwsLambdaHttpErrorHandler {
+    logger;
+    /**
+     * Create an NodeHttpErrorHandler.
+     *
+     * @param options - NodeHttpErrorHandler options.
+     */
+    constructor({ blueprint }) {
+        this.logger = blueprint.get('stone.logger.resolver', defaultLoggerResolver)(blueprint);
+    }
+    /**
+     * Handle an error.
+     *
+     * @param error - The error to handle.
+     * @param context - The context of the adapter.
+     * @returns The raw response builder.
+     */
+    handle(error, context) {
+        this.logger.error(error.message, { error });
+        const statusCode = error.cause?.status ?? HTTP_INTERNAL_SERVER_ERROR;
+        const type = accepts(context.rawEvent).type(['json', 'html']);
+        const contentType = mime.getType(type !== false ? type : 'txt') ?? context.rawEvent.headers['content-type'] ?? 'text/plain';
+        const headers = new Headers({ 'Content-Type': contentType });
+        return context
+            .rawResponseBuilder
+            .add('headers', headers)
+            .add('statusCode', statusCode)
+            .add('statusMessage', statuses.message[statusCode]);
+    }
+}
+
+/**
+ * A constant representing the AWS Lambda HTTP platform identifier.
+ *
+ * This constant is used as an alias for the AWS Lambda HTTP Adapter within the Stone.js framework.
+ * It helps in identifying and configuring platform-specific adapters or components for handling
+ * HTTP requests and responses.
+ */
+const AWS_LAMBDA_HTTP_PLATFORM = 'aws_lambda_http';
+
+/**
+ * Adapter resolver for AWS Lambda HTTP adapter.
+ *
+ * Creates and configures an `AWSLambdaHttpAdapter` for handling HTTP events in AWS Lambda.
+ *
+ * @param blueprint - The `IBlueprint` providing configuration and dependencies.
+ * @returns An `AWSLambdaHttpAdapter` instance.
+ */
+const awsLambdaHttpAdapterResolver = (blueprint) => {
+    return AwsLambdaHttpAdapter.create(blueprint);
+};
+
+function getDefaultExportFromCjs (x) {
+	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
+}
+
+var cjs;
+var hasRequiredCjs;
+
+function requireCjs () {
+	if (hasRequiredCjs) return cjs;
+	hasRequiredCjs = 1;
+
+	var isMergeableObject = function isMergeableObject(value) {
+		return isNonNullObject(value)
+			&& !isSpecial(value)
+	};
+
+	function isNonNullObject(value) {
+		return !!value && typeof value === 'object'
+	}
+
+	function isSpecial(value) {
+		var stringValue = Object.prototype.toString.call(value);
+
+		return stringValue === '[object RegExp]'
+			|| stringValue === '[object Date]'
+			|| isReactElement(value)
+	}
+
+	// see https://github.com/facebook/react/blob/b5ac963fb791d1298e7f396236383bc955f916c1/src/isomorphic/classic/element/ReactElement.js#L21-L25
+	var canUseSymbol = typeof Symbol === 'function' && Symbol.for;
+	var REACT_ELEMENT_TYPE = canUseSymbol ? Symbol.for('react.element') : 0xeac7;
+
+	function isReactElement(value) {
+		return value.$$typeof === REACT_ELEMENT_TYPE
+	}
+
+	function emptyTarget(val) {
+		return Array.isArray(val) ? [] : {}
+	}
+
+	function cloneUnlessOtherwiseSpecified(value, options) {
+		return (options.clone !== false && options.isMergeableObject(value))
+			? deepmerge(emptyTarget(value), value, options)
+			: value
+	}
+
+	function defaultArrayMerge(target, source, options) {
+		return target.concat(source).map(function(element) {
+			return cloneUnlessOtherwiseSpecified(element, options)
+		})
+	}
+
+	function getMergeFunction(key, options) {
+		if (!options.customMerge) {
+			return deepmerge
+		}
+		var customMerge = options.customMerge(key);
+		return typeof customMerge === 'function' ? customMerge : deepmerge
+	}
+
+	function getEnumerableOwnPropertySymbols(target) {
+		return Object.getOwnPropertySymbols
+			? Object.getOwnPropertySymbols(target).filter(function(symbol) {
+				return Object.propertyIsEnumerable.call(target, symbol)
+			})
+			: []
+	}
+
+	function getKeys(target) {
+		return Object.keys(target).concat(getEnumerableOwnPropertySymbols(target))
+	}
+
+	function propertyIsOnObject(object, property) {
+		try {
+			return property in object
+		} catch(_) {
+			return false
+		}
+	}
+
+	// Protects from prototype poisoning and unexpected merging up the prototype chain.
+	function propertyIsUnsafe(target, key) {
+		return propertyIsOnObject(target, key) // Properties are safe to merge if they don't exist in the target yet,
+			&& !(Object.hasOwnProperty.call(target, key) // unsafe if they exist up the prototype chain,
+				&& Object.propertyIsEnumerable.call(target, key)) // and also unsafe if they're nonenumerable.
+	}
+
+	function mergeObject(target, source, options) {
+		var destination = {};
+		if (options.isMergeableObject(target)) {
+			getKeys(target).forEach(function(key) {
+				destination[key] = cloneUnlessOtherwiseSpecified(target[key], options);
+			});
+		}
+		getKeys(source).forEach(function(key) {
+			if (propertyIsUnsafe(target, key)) {
+				return
+			}
+
+			if (propertyIsOnObject(target, key) && options.isMergeableObject(source[key])) {
+				destination[key] = getMergeFunction(key, options)(target[key], source[key], options);
+			} else {
+				destination[key] = cloneUnlessOtherwiseSpecified(source[key], options);
+			}
+		});
+		return destination
+	}
+
+	function deepmerge(target, source, options) {
+		options = options || {};
+		options.arrayMerge = options.arrayMerge || defaultArrayMerge;
+		options.isMergeableObject = options.isMergeableObject || isMergeableObject;
+		// cloneUnlessOtherwiseSpecified is added to `options` so that custom arrayMerge()
+		// implementations can use it. The caller may not replace it.
+		options.cloneUnlessOtherwiseSpecified = cloneUnlessOtherwiseSpecified;
+
+		var sourceIsArray = Array.isArray(source);
+		var targetIsArray = Array.isArray(target);
+		var sourceAndTargetTypesMatch = sourceIsArray === targetIsArray;
+
+		if (!sourceAndTargetTypesMatch) {
+			return cloneUnlessOtherwiseSpecified(source, options)
+		} else if (sourceIsArray) {
+			return options.arrayMerge(target, source, options)
+		} else {
+			return mergeObject(target, source, options)
+		}
+	}
+
+	deepmerge.all = function deepmergeAll(array, options) {
+		if (!Array.isArray(array)) {
+			throw new Error('first argument should be an array')
+		}
+
+		return array.reduce(function(prev, next) {
+			return deepmerge(prev, next, options)
+		}, {})
+	};
+
+	var deepmerge_1 = deepmerge;
+
+	cjs = deepmerge_1;
+	return cjs;
+}
+
+var cjsExports = requireCjs();
+var deepmerge = /*@__PURE__*/getDefaultExportFromCjs(cjsExports);
+
+/**
+ * Middleware to dynamically set response resolver for adapter.
+ *
+ * @param context - The configuration context containing modules and blueprint.
+ * @param next - The next pipeline function to continue processing.
+ * @returns The updated blueprint or a promise resolving to it.
+ *
+ * @example
+ * ```typescript
+ * SetAwsLambdaHttpResponseResolverMiddleware(context, next)
+ * ```
+ */
+const SetAwsLambdaHttpResponseResolverMiddleware = async (context, next) => {
+    if (context.blueprint.get('stone.adapter.platform') === AWS_LAMBDA_HTTP_PLATFORM) {
+        context.blueprint.set('stone.kernel.responseResolver', (options) => {
+            return options.content instanceof File
+                ? BinaryFileResponse.file({ ...options, content: undefined, file: options.content })
+                : OutgoingHttpResponse.create(options);
+        });
+    }
+    return await next(context);
+};
+/**
+ * Configuration for adapter processing middleware.
+ *
+ * This array defines a list of middleware pipes, each with a `pipe` function and a `priority`.
+ * These pipes are executed in the order of their priority values, with lower values running first.
+ */
+const metaAdapterBlueprintMiddleware = [
+    { module: SetAwsLambdaHttpResponseResolverMiddleware, priority: 6 }
+];
+
+/**
+ * Middleware for handling incoming events and transforming them into Stone.js events.
+ *
+ * This class processes incoming HTTP requests, extracting relevant data such as URL, IP addresses,
+ * headers, cookies, and more, and forwards them to the next middleware in the pipeline.
+ */
+class IncomingEventMiddleware {
+    /**
+     * The blueprint for resolving configuration and dependencies.
+     */
+    blueprint;
+    /**
+     * Create an IncomingEventMiddleware instance.
+     *
+     * @param {blueprint} options - Options containing the blueprint for resolving configuration and dependencies.
+     */
+    constructor({ blueprint }) {
+        this.blueprint = blueprint;
+    }
+    /**
+     * Handles the incoming event, processes it, and invokes the next middleware in the pipeline.
+     *
+     * @param context - The adapter context containing the raw event, execution context, and other data.
+     * @param next - The next middleware to be invoked in the pipeline.
+     * @returns A promise that resolves to the processed context.
+     * @throws {AwsLambdaHttpAdapterError} If required components are missing in the context.
+     */
+    async handle(context, next) {
+        if ((context.rawEvent === undefined) || ((context.incomingEventBuilder?.add) === undefined)) {
+            throw new AwsLambdaHttpAdapterError('The context is missing required components.');
+        }
+        const proxyOptions = this.getProxyOptions();
+        const cookieOptions = this.getCookieOptions();
+        const url = this.extractUrl(context.rawEvent, proxyOptions);
+        const ipAddresses = this.extractIpAddresses(context.rawEvent, proxyOptions);
+        context
+            .incomingEventBuilder
+            .add('url', url)
+            .add('ips', ipAddresses)
+            .add('source', this.getSource(context))
+            .add('headers', context.rawEvent.headers)
+            // If not defined by other middleware
+            // In fullstack forms, the method is spoofed and sent as a hidden field
+            .addIf('method', this.getMethod(context.rawEvent))
+            .add('queryString', context.rawEvent.queryStringParameters)
+            .add('protocol', this.getProtocol(context.rawEvent, proxyOptions))
+            .add('cookies', CookieCollection.create(context.rawEvent.headers.cookie, cookieOptions, this.getCookieSecret()))
+            .add('ip', proxyAddr(this.toNodeMessage(context.rawEvent), isIpTrusted(proxyOptions.trustedIp, proxyOptions.untrustedIp)));
+        return await next(context);
+    }
+    /**
+     * Create the IncomingEventSource from the context.
+     *
+     * @param context - The adapter context containing the raw event, execution context, and other data.
+     * @returns The Incoming Event Source.
+     */
+    getSource(context) {
+        return {
+            rawEvent: context.rawEvent,
+            platform: AWS_LAMBDA_HTTP_PLATFORM,
+            rawContext: context.executionContext
+        };
+    }
+    /**
+     * Extracts the HTTP method from the incoming rawEvent.
+     *
+     * @param rawEvent - The incoming rawEvent.
+     * @returns The HTTP method string.
+     */
+    getMethod(rawEvent) {
+        return rawEvent.httpMethod ??
+            rawEvent.requestContext?.httpMethod ??
+            rawEvent.requestContext?.http?.method ??
+            'GET';
+    }
+    /**
+     * Extracts proxy-related options from the blueprint.
+     *
+     * @returns Proxy options.
+     */
+    getProxyOptions() {
+        const defaultProxyOptions = { trusted: [], trustedIp: [], untrustedIp: [] };
+        const proxyOptions = this.blueprint.get('stone.http.proxies', defaultProxyOptions);
+        proxyOptions.trusted = this.blueprint.get('stone.http.hosts.trusted', []);
+        return proxyOptions;
+    }
+    /**
+     * Retrieves cookie-related options from the blueprint.
+     *
+     * @returns Cookie options.
+     */
+    getCookieOptions() {
+        return this.blueprint.get('stone.http.cookie.options', {});
+    }
+    /**
+     * Retrieves the cookie secret from the blueprint.
+     *
+     * @returns The cookie secret string.
+     */
+    getCookieSecret() {
+        return this.blueprint.get('stone.http.cookie.secret', this.blueprint.get('stone.secret', ''));
+    }
+    /**
+     * Extracts and parses the URL from the incoming rawEvent.
+     *
+     * @param rawEvent - The incoming HTTP rawEvent.
+     * @param options - Proxy options.
+     * @returns The parsed URL object.
+     */
+    extractUrl(rawEvent, options) {
+        const hostname = getHostname(this.getRemoteAddress(rawEvent), rawEvent.headers, options);
+        const proto = getProtocol(this.getRemoteAddress(rawEvent), rawEvent.headers, true, options);
+        return new URL(rawEvent.path ?? rawEvent.rawPath ?? '', `${String(proto)}://${String(hostname)}`);
+    }
+    /**
+     * Extracts a list of IP addresses from the incoming rawEvent.
+     *
+     * @param rawEvent - The incoming HTTP rawEvent.
+     * @param options - Proxy options.
+     * @returns An array of IP addresses.
+     */
+    extractIpAddresses(rawEvent, options) {
+        const isTrusted = isIpTrusted(options.trustedIp, options.untrustedIp);
+        return proxyAddr.all(this.toNodeMessage(rawEvent), isTrusted).slice(1).reverse();
+    }
+    /**
+     * Converts the incoming rawEvent to a Node.js IncomingMessage.
+     *
+     * @param rawEvent - The incoming rawEvent.
+     * @returns The converted IncomingMessage.
+     */
+    toNodeMessage(rawEvent) {
+        return {
+            connection: { remoteAddress: this.getRemoteAddress(rawEvent) },
+            headers: { 'x-forwarded-for': rawEvent.headers['x-forwarded-for'] ?? rawEvent.headers['X-Forwarded-For'] }
+        };
+    }
+    /**
+     * Determines the protocol from the incoming rawEvent.
+     *
+     * @param rawEvent - The incoming rawEvent.
+     * @param options - Proxy options.
+     * @returns The protocol string.
+     */
+    getProtocol(rawEvent, options) {
+        return getProtocol(this.getRemoteAddress(rawEvent), rawEvent.headers, true, options);
+    }
+    /**
+     * Retrieves the remote address from the incoming rawEvent.
+     * This method is used as a fallback when the remote address is not found in the rawEvent.
+     * @param rawEvent - The incoming rawEvent.
+     * @returns The remote address string.
+     */
+    getRemoteAddress(rawEvent) {
+        return rawEvent.requestContext?.http?.sourceIp ?? rawEvent.requestContext?.identity?.sourceIp ?? '';
+    }
+}
+/**
+ * Meta Middleware for processing incoming events.
+ */
+const MetaIncomingEventMiddleware = { module: IncomingEventMiddleware, isClass: true };
+
+/**
+ * Middleware for handling server responses and transforming them into the appropriate HTTP responses.
+ *
+ * This middleware processes outgoing responses and attaches the necessary headers, status codes,
+ * and body content to the HTTP response.
+ */
+class ServerResponseMiddleware {
+    /**
+     * Handles the outgoing response, processes it, and invokes the next middleware in the pipeline.
+     *
+     * @param context - The adapter context containing the raw event, execution context, and other data.
+     * @param next - The next middleware to be invoked in the pipeline.
+     * @returns A promise resolving to the rawResponseBuilder.
+     * @throws {AwsLambdaHttpAdapterError} If required components are missing in the context.
+     */
+    async handle(context, next) {
+        const rawResponseBuilder = await next(context);
+        if (context.rawEvent === undefined || context.incomingEvent === undefined || context.outgoingResponse === undefined || rawResponseBuilder?.add === undefined) {
+            throw new AwsLambdaHttpAdapterError('The context is missing required components.');
+        }
+        rawResponseBuilder
+            .add('headers', context.outgoingResponse.headers)
+            .add('statusCode', context.outgoingResponse.statusCode ?? 500)
+            .add('statusMessage', context.outgoingResponse.statusMessage ?? statuses.message[context.outgoingResponse.statusCode ?? 500]);
+        if (!context.incomingEvent.isMethod('HEAD')) {
+            if (context.outgoingResponse instanceof BinaryFileResponse) {
+                rawResponseBuilder
+                    .add('isBase64Encoded', true)
+                    .add('body', context.outgoingResponse.file.getContent('base64'));
+            }
+            else {
+                const isBuffer = Buffer.isBuffer(context.outgoingResponse.content);
+                const content = isBuffer
+                    ? context.outgoingResponse.content.toString('base64')
+                    : context.outgoingResponse.content;
+                rawResponseBuilder
+                    .add('body', content)
+                    .add('isBase64Encoded', isBuffer)
+                    .add('charset', context.outgoingResponse.charset);
+            }
+        }
+        return rawResponseBuilder;
+    }
+}
+/**
+ * Meta Middleware for processing server responses.
+ */
+const MetaServerResponseMiddleware = { module: ServerResponseMiddleware, isClass: true };
+
+/**
+ * Default blueprint configuration for the AWS Lambda Http Adapter.
+ *
+ * This blueprint defines the initial configuration for the AWS Lambda Http adapter
+ * within the Stone.js framework. It includes:
+ * - An alias for the AWS Lambda platform (`AWS_LAMBDA_HTTP_PLATFORM`).
+ * - A default resolver function (currently a placeholder).
+ * - Middleware, hooks, and state flags (`current`, `default`, `preferred`).
+ */
+const awsLambdaHttpAdapterBlueprint = {
+    stone: {
+        ...httpCoreBlueprint.stone,
+        blueprint: {
+            middleware: metaAdapterBlueprintMiddleware
+        },
+        adapters: [
+            {
+                current: false,
+                variant: 'server',
+                platform: AWS_LAMBDA_HTTP_PLATFORM,
+                middleware: [
+                    MetaIncomingEventMiddleware,
+                    MetaServerResponseMiddleware
+                ],
+                resolver: awsLambdaHttpAdapterResolver,
+                eventHandlerResolver: defaultKernelResolver,
+                errorHandlers: {
+                    default: { module: AwsLambdaHttpErrorHandler, isClass: true }
+                },
+                default: isNotEmpty(getString('AWS_LAMBDA_FUNCTION_NAME', ''))
+            }
+        ]
+    }
+};
+
+/**
+ * A Stone.js decorator that integrates the AWS Lambda HTTP Adapter with a class.
+ *
+ * This decorator modifies the class to seamlessly enable AWS Lambda HTTP as the
+ * execution environment for a Stone.js application. By applying this decorator,
+ * the class is automatically configured with the necessary blueprint for AWS Lambda HTTP.
+ *
+ * @template T - The type of the class being decorated. Defaults to `ClassType`.
+ * @param options - Optional configuration to customize the AWS Lambda HTTP Adapter.
+ *
+ * @returns A class decorator that applies the AWS Lambda HTTP adapter configuration.
+ *
+ * @example
+ * ```typescript
+ * import { AwsLambdaHttp } from '@stone-js/aws-lambda-http-adapter';
+ *
+ * @AwsLambdaHttp({
+ *   alias: 'MyAwsLambdaHttpAdapter',
+ *   current: true,
+ * })
+ * class App {
+ *   // Your application logic here
+ * }
+ * ```
+ */
+const AwsLambdaHttp = (options = {}) => {
+    return classDecoratorLegacyWrapper((target, context) => {
+        if (awsLambdaHttpAdapterBlueprint.stone?.adapters?.[0] !== undefined) {
+            // Merge provided options with the default AWS Lambda HTTP adapter blueprint.
+            awsLambdaHttpAdapterBlueprint.stone.adapters[0] = deepmerge(awsLambdaHttpAdapterBlueprint.stone.adapters[0], options);
+        }
+        // Add the modified blueprint to the target class.
+        addBlueprint(target, context, awsLambdaHttpAdapterBlueprint);
+    });
+};
+
+/**
+ * Class representing a BodyEventMiddleware.
+ *
+ * This middleware handles platform-specific messages and transforms them into Stone.js IncomingEvent objects.
+ *
+ * @author Mr. Stone
+ */
+class BodyEventMiddleware {
+    /**
+     * The blueprint for resolving configuration and dependencies.
+     */
+    blueprint;
+    /**
+     * Create a BodyEventMiddleware.
+     *
+     * @param {blueprint} options - Options for creating the BodyEventMiddleware.
+     */
+    constructor({ blueprint }) {
+        this.blueprint = blueprint;
+    }
+    /**
+     * Handles the incoming event, processes it, and invokes the next middleware in the pipeline.
+     *
+     * @param context - The adapter context containing the raw event, execution context, and other data.
+     * @param next - The next middleware to be invoked in the pipeline.
+     * @returns A promise that resolves to the destination type after processing.
+     *
+     * @throws {AwsLambdaHttpAdapterError} If required components such as the rawEvent or IncomingEventBuilder are not provided.
+     */
+    async handle(context, next) {
+        if (context.rawEvent === undefined || context.incomingEventBuilder?.add === undefined) {
+            throw new AwsLambdaHttpAdapterError('The context is missing required components.');
+        }
+        if (!isMultipart(this.toNodeMessage(context.rawEvent))) {
+            const body = this.getBody(this.toNodeMessage(context.rawEvent), context.rawEvent);
+            const method = body.$method$;
+            context
+                .incomingEventBuilder
+                .add('body', body)
+                .add('metadata', body);
+            // In fullstack forms, the method is spoofed and sent as a hidden field
+            isNotEmpty(method) && context.incomingEventBuilder.add('method', method);
+        }
+        return await next(context);
+    }
+    /**
+     * Convert the raw event into a Node.js IncomingMessage.
+     *
+     * @param rawEvent - The raw event from the platform.
+     * @returns The converted IncomingMessage.
+     */
+    toNodeMessage(rawEvent) {
+        return {
+            headers: {
+                'content-type': rawEvent.headers['content-type'] ?? rawEvent.headers['Content-Type'],
+                'content-length': rawEvent.headers['content-length'] ?? rawEvent.headers['Content-Length'],
+                'transfer-encoding': rawEvent.headers['transfer-encoding'] ?? rawEvent.headers['Transfer-Encoding']
+            }
+        };
+    }
+    /**
+     * Extract and parse the body from the message.
+     *
+     * @param message - The incoming HTTP message.
+     * @returns A Promise resolving to the parsed body.
+     * @throws {AwsLambdaHttpAdapterError} If the body parsing fails or is invalid.
+     */
+    getBody(message, rawEvent) {
+        if (!typeIs.hasBody(message)) {
+            return {};
+        }
+        const defaultOptions = { limit: '100kb', defaultType: 'text/plain', defaultCharset: 'utf-8' };
+        const { defaultType, defaultCharset, limit: rawLimit } = this.blueprint.get('stone.http.body', defaultOptions);
+        const limit = bytes.parse(rawLimit) ?? 100000;
+        const encoding = getCharset(message, defaultCharset);
+        const type = getType(message, defaultType);
+        if (typeIs.is(type, ['urlencoded', 'json', 'text', 'bin']) === false) {
+            return {};
+        }
+        const stringifiedBody = typeof rawEvent.body === 'string'
+            ? rawEvent.body
+            : (typeof rawEvent.body === 'object' && rawEvent.body !== null
+                ? JSON.stringify(rawEvent.body)
+                : '');
+        if (Buffer.byteLength(stringifiedBody, encoding) > limit) {
+            throw new AwsLambdaHttpAdapterError('The context is missing required components.');
+        }
+        return rawEvent.body;
+    }
+}
+/**
+ * Meta Middleware for processing the request body.
+ */
+const MetaBodyEventMiddleware = { module: BodyEventMiddleware, isClass: true };
+
+/**
+ * Class representing a FilesEventMiddleware.
+ *
+ * @author Mr. Stone <evensstone@gmail.com>
+ */
+class FilesEventMiddleware {
+    /**
+     * The blueprint for resolving configuration and dependencies.
+     */
+    blueprint;
+    /**
+     * Create a FilesEventMiddleware.
+     *
+     * @param {blueprint} options - Options for creating the FilesEventMiddleware.
+     */
+    constructor({ blueprint }) {
+        this.blueprint = blueprint;
+    }
+    /**
+     * Handles the incoming event, processes it, and invokes the next middleware in the pipeline.
+     *
+     * @param context - The adapter context containing the raw event, execution context, and other data.
+     * @param next - The next middleware to be invoked in the pipeline.
+     * @returns A promise that resolves to the destination type after processing.
+     *
+     * @throws {AwsLambdaHttpAdapterError} If required components such as the rawEvent or IncomingEventBuilder are not provided.
+     */
+    async handle(context, next) {
+        if (context.rawEvent === undefined || context.incomingEventBuilder?.add === undefined) {
+            throw new AwsLambdaHttpAdapterError('The context is missing required components.');
+        }
+        if (isMultipart(this.normalizeEvent(context.rawEvent))) {
+            const options = this.blueprint.get('stone.http.files.upload', {});
+            const response = await getFilesUploads(this.normalizeEvent(context.rawEvent), options);
+            const method = response.fields.$method$;
+            context
+                .incomingEventBuilder
+                .add('files', response.files)
+                .add('body', response.fields);
+            // In fullstack forms, the method is spoofed and sent as a hidden field
+            isNotEmpty(method) && context.incomingEventBuilder.add('method', method);
+        }
+        return await next(context);
+    }
+    /**
+     * Normalize the incoming event to an IncomingMessage.
+     *
+     * @param rawEvent - The raw event to be normalized.
+     * @returns The normalized event.
+     */
+    normalizeEvent(rawEvent) {
+        return {
+            body: rawEvent.body,
+            headers: {
+                'content-type': rawEvent.headers['content-type'] ?? rawEvent.headers['Content-Type'],
+                'content-length': rawEvent.headers['content-length'] ?? rawEvent.headers['Content-Length'],
+                'transfer-encoding': rawEvent.headers['transfer-encoding'] ?? rawEvent.headers['Transfer-Encoding']
+            }
+        };
+    }
+}
+/**
+ * Meta Middleware for processing files uploads.
+ */
+const MetaFilesEventMiddleware = { module: FilesEventMiddleware, isClass: true };
+
+export { AWS_LAMBDA_HTTP_PLATFORM, AwsLambdaHttp, AwsLambdaHttpAdapter, AwsLambdaHttpAdapterError, AwsLambdaHttpErrorHandler, BodyEventMiddleware, FilesEventMiddleware, IncomingEventMiddleware, MetaBodyEventMiddleware, MetaFilesEventMiddleware, MetaIncomingEventMiddleware, MetaServerResponseMiddleware, RawHttpResponseWrapper, ServerResponseMiddleware, SetAwsLambdaHttpResponseResolverMiddleware, awsLambdaHttpAdapterBlueprint, awsLambdaHttpAdapterResolver, metaAdapterBlueprintMiddleware };