@stone-js/aws-lambda-http-adapter 0.2.0 → 0.3.1

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2025 Stone.js
+Copyright © 2026 Stone Foundation
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -3,7 +3,7 @@
 [![npm](https://img.shields.io/npm/l/@stone-js/aws-lambda-http-adapter)](https://opensource.org/licenses/MIT)
 [![npm](https://img.shields.io/npm/v/@stone-js/aws-lambda-http-adapter)](https://www.npmjs.com/package/@stone-js/aws-lambda-http-adapter)
 [![npm](https://img.shields.io/npm/dm/@stone-js/aws-lambda-http-adapter)](https://www.npmjs.com/package/@stone-js/aws-lambda-http-adapter)
-![Maintenance](https://img.shields.io/maintenance/yes/2025)
+![Maintenance](https://img.shields.io/maintenance/yes/2026)
 [![Build Status](https://github.com/stone-foundation/stone-js-aws-lambda-http-adapter/actions/workflows/main.yml/badge.svg)](https://github.com/stone-foundation/stone-js-aws-lambda-http-adapter/actions/workflows/main.yml)
 [![Publish Package to npmjs](https://github.com/stone-foundation/stone-js-aws-lambda-http-adapter/actions/workflows/release.yml/badge.svg)](https://github.com/stone-foundation/stone-js-aws-lambda-http-adapter/actions/workflows/release.yml)
 [![Quality Gate Status](https://sonarcloud.io/api/project_badges/measure?project=stone-foundation_stone-js-aws-lambda-http-adapter&metric=alert_status)](https://sonarcloud.io/summary/new_code?id=stone-foundation_stone-js-aws-lambda-http-adapter)

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { IRawResponseWrapper, RawResponseOptions, AdapterContext, IAdapterEventBuilder, Adapter, IBlueprint, IAdapterErrorHandler, AdapterErrorContext, AdapterEventBuilderType, AdapterResolver, AdapterConfig, AppConfig, StoneBlueprint, ClassType, IntegrationError, ErrorOptions, BlueprintContext, NextMiddleware, MetaMiddleware } from '@stone-js/core';
+import { IRawResponseWrapper, RawResponseOptions, AdapterContext, IAdapterEventBuilder, Adapter, IBlueprint, IAdapterErrorHandler, AdapterErrorContext, AdapterEventBuilderType, AdapterResolver, AdapterConfig, StoneBlueprint, AppConfig, ClassType, IntegrationError, ErrorOptions, BlueprintContext, NextMiddleware, MetaMiddleware } from '@stone-js/core';
 import { IncomingHttpEvent, IncomingHttpEventOptions, OutgoingHttpResponse, HttpConfig } from '@stone-js/http-core';
 
 /**
@@ -59,6 +59,16 @@ declare class RawHttpResponseWrapper implements IRawResponseWrapper<RawHttpRespo
      * ```
      */
     respond(): RawHttpResponse;
+    /**
+     * Normalizes the headers to a consistent format.
+     *
+     * Converts Headers or Record<string, string> to a normalized Record<string, string>
+     * with all keys in lowercase.
+     *
+     * @param headers - The headers to normalize.
+     * @returns A normalized record of headers.
+     */
+    private normalizeHeaders;
 }
 
 /**
@@ -451,6 +461,24 @@ declare class BodyEventMiddleware {
      * @throws {AwsLambdaHttpAdapterError} If the body parsing fails or is invalid.
      */
     private getBody;
+    /**
+     * Get the normalized raw body from the event.
+     *
+     * @param rawEvent - The raw event containing the body.
+     * @param encoding - The encoding to use for the body.
+     * @returns The normalized body as a string.
+     */
+    private getNormalizedRawBody;
+    /**
+     * Parse the body content based on the specified type and encoding.
+     *
+     * @param type - The content type of the body.
+     * @param body - The raw body content as a string.
+     * @param encoding - The encoding of the body content.
+     * @returns The parsed body content as an object, string, or Buffer.
+     * @throws {AwsLambdaHttpAdapterError} If parsing fails.
+     */
+    private parseBodyContent;
 }
 /**
  * Meta Middleware for processing the request body.
@@ -460,6 +488,50 @@ declare const MetaBodyEventMiddleware: {
     isClass: boolean;
 };
 
+/**
+ * Class representing a FilesEventMiddleware.
+ *
+ * @author Mr. Stone <evensstone@gmail.com>
+ */
+declare class FilesEventMiddleware {
+    /**
+     * The blueprint for resolving configuration and dependencies.
+     */
+    private readonly blueprint;
+    /**
+     * Create a FilesEventMiddleware.
+     *
+     * @param {blueprint} options - Options for creating the FilesEventMiddleware.
+     */
+    constructor({ blueprint }: {
+        blueprint: IBlueprint;
+    });
+    /**
+     * 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.
+     */
+    handle(context: AwsLambdaHttpAdapterContext, next: NextMiddleware<AwsLambdaHttpAdapterContext, AwsLambdaHttpAdapterResponseBuilder>): Promise<AwsLambdaHttpAdapterResponseBuilder>;
+    /**
+     * Normalize the incoming event to an IncomingMessage.
+     *
+     * @param rawEvent - The raw event to be normalized.
+     * @returns The normalized event.
+     */
+    private normalizeEvent;
+}
+/**
+ * Meta Middleware for processing files uploads.
+ */
+declare const MetaFilesEventMiddleware: {
+    module: typeof FilesEventMiddleware;
+    isClass: boolean;
+};
+
 /**
  * Middleware for handling incoming events and transforming them into Stone.js events.
  *
@@ -567,50 +639,6 @@ declare const MetaIncomingEventMiddleware: {
     isClass: boolean;
 };
 
-/**
- * Class representing a FilesEventMiddleware.
- *
- * @author Mr. Stone <evensstone@gmail.com>
- */
-declare class FilesEventMiddleware {
-    /**
-     * The blueprint for resolving configuration and dependencies.
-     */
-    private readonly blueprint;
-    /**
-     * Create a FilesEventMiddleware.
-     *
-     * @param {blueprint} options - Options for creating the FilesEventMiddleware.
-     */
-    constructor({ blueprint }: {
-        blueprint: IBlueprint;
-    });
-    /**
-     * 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.
-     */
-    handle(context: AwsLambdaHttpAdapterContext, next: NextMiddleware<AwsLambdaHttpAdapterContext, AwsLambdaHttpAdapterResponseBuilder>): Promise<AwsLambdaHttpAdapterResponseBuilder>;
-    /**
-     * Normalize the incoming event to an IncomingMessage.
-     *
-     * @param rawEvent - The raw event to be normalized.
-     * @returns The normalized event.
-     */
-    private normalizeEvent;
-}
-/**
- * Meta Middleware for processing files uploads.
- */
-declare const MetaFilesEventMiddleware: {
-    module: typeof FilesEventMiddleware;
-    isClass: boolean;
-};
-
 /**
  * Middleware for handling server responses and transforming them into the appropriate HTTP responses.
  *

package/dist/index.js

@@ -1,13 +1,47 @@
-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 { defaultLoggerResolver, IntegrationError, Adapter, AdapterEventBuilder, isNotEmpty, defaultKernelResolver, classDecoratorLegacyWrapper, addBlueprint } from '@stone-js/core';
 import mime from 'mime';
 import accepts from 'accepts';
 import statuses from 'statuses';
-import { getString } from '@stone-js/env';
+import { HTTP_INTERNAL_SERVER_ERROR, IncomingHttpEvent, BinaryFileResponse, OutgoingHttpResponse, isMultipart, getFilesUploads, CookieCollection, isIpTrusted, getHostname, getProtocol, getCharset, httpCoreBlueprint } from '@stone-js/http-core';
 import { File } from '@stone-js/filesystem';
 import proxyAddr from 'proxy-addr';
 import bytes from 'bytes';
 import typeIs from 'type-is';
+import { getString } from '@stone-js/env';
+
+/**
+ * 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]);
+    }
+}
 
 /**
  * Wrapper for HTTP raw responses in AWS Lambda.
@@ -73,9 +107,22 @@ class RawHttpResponseWrapper {
     respond() {
         return {
             ...this.options,
-            statusCode: this.options.statusCode ?? 500
+            statusCode: this.options.statusCode ?? 500,
+            headers: this.normalizeHeaders(this.options.headers)
         };
     }
+    /**
+     * Normalizes the headers to a consistent format.
+     *
+     * Converts Headers or Record<string, string> to a normalized Record<string, string>
+     * with all keys in lowercase.
+     *
+     * @param headers - The headers to normalize.
+     * @returns A normalized record of headers.
+     */
+    normalizeHeaders(headers) {
+        return Object.fromEntries(new Headers(headers ?? {}));
+    }
 }
 
 /**
@@ -208,40 +255,6 @@ class AwsLambdaHttpAdapter extends Adapter {
     }
 }
 
-/**
- * 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.
  *
@@ -263,154 +276,6 @@ 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.
  *
@@ -444,20 +309,19 @@ const metaAdapterBlueprintMiddleware = [
 ];
 
 /**
- * Middleware for handling incoming events and transforming them into Stone.js events.
+ * Class representing a FilesEventMiddleware.
  *
- * 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.
+ * @author Mr. Stone <evensstone@gmail.com>
  */
-class IncomingEventMiddleware {
+class FilesEventMiddleware {
     /**
      * The blueprint for resolving configuration and dependencies.
      */
     blueprint;
     /**
-     * Create an IncomingEventMiddleware instance.
+     * Create a FilesEventMiddleware.
      *
-     * @param {blueprint} options - Options containing the blueprint for resolving configuration and dependencies.
+     * @param {blueprint} options - Options for creating the FilesEventMiddleware.
      */
     constructor({ blueprint }) {
         this.blueprint = blueprint;
@@ -467,28 +331,101 @@ class IncomingEventMiddleware {
      *
      * @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.
+     * @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)) {
+        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))
+        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) {
+        let body = rawEvent.body;
+        if (typeof rawEvent.body === 'string') {
+            body = rawEvent.isBase64Encoded === true
+                ? Buffer.from(rawEvent.body, 'base64')
+                : Buffer.from(rawEvent.body, 'utf-8');
+        }
+        return {
+            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 };
+
+/**
+ * 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);
@@ -654,77 +591,6 @@ class ServerResponseMiddleware {
  */
 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.
  *
@@ -800,90 +666,282 @@ class BodyEventMiddleware {
         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.');
+        const type = typeIs(message, ['urlencoded', 'json', 'text', 'bin']) ?? defaultType;
+        const rawBodyContent = this.getNormalizedRawBody(rawEvent, encoding);
+        if (Buffer.byteLength(rawBodyContent, encoding) > limit) {
+            throw new AwsLambdaHttpAdapterError('Body payload exceeds configured limit.');
         }
-        return rawEvent.body;
+        return this.parseBodyContent(type, rawBodyContent, encoding);
     }
-}
-/**
- * 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.
+     * Get the normalized raw body from the event.
      *
-     * @param {blueprint} options - Options for creating the FilesEventMiddleware.
+     * @param rawEvent - The raw event containing the body.
+     * @param encoding - The encoding to use for the body.
+     * @returns The normalized body as a string.
      */
-    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.');
+    getNormalizedRawBody(rawEvent, encoding) {
+        if (typeof rawEvent.body === 'string') {
+            return rawEvent.isBase64Encoded === true
+                ? Buffer.from(rawEvent.body, 'base64').toString(encoding)
+                : rawEvent.body;
         }
-        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);
+        if (typeof rawEvent.body === 'object' && rawEvent.body !== null) {
+            return JSON.stringify(rawEvent.body);
         }
-        return await next(context);
+        return '';
     }
     /**
-     * Normalize the incoming event to an IncomingMessage.
+     * Parse the body content based on the specified type and encoding.
      *
-     * @param rawEvent - The raw event to be normalized.
-     * @returns The normalized event.
+     * @param type - The content type of the body.
+     * @param body - The raw body content as a string.
+     * @param encoding - The encoding of the body content.
+     * @returns The parsed body content as an object, string, or Buffer.
+     * @throws {AwsLambdaHttpAdapterError} If parsing fails.
      */
-    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']
+    parseBodyContent(type, body, encoding) {
+        try {
+            switch (type) {
+                case 'json':
+                    return isNotEmpty(body) ? JSON.parse(body) : {};
+                case 'text':
+                    return body;
+                case 'urlencoded':
+                    return new URLSearchParams(body);
+                case 'bin':
+                    return Buffer.from(body, encoding);
+                default:
+                    return {};
             }
-        };
+        }
+        catch (error) {
+            throw new AwsLambdaHttpAdapterError('Failed to parse request body.', { cause: error });
+        }
     }
 }
 /**
- * Meta Middleware for processing files uploads.
+ * Meta Middleware for processing the request body.
  */
-const MetaFilesEventMiddleware = { module: FilesEventMiddleware, isClass: true };
+const MetaBodyEventMiddleware = { module: BodyEventMiddleware, isClass: true };
+
+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);
+
+/**
+ * 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);
+    });
+};
 
 export { AWS_LAMBDA_HTTP_PLATFORM, AwsLambdaHttp, AwsLambdaHttpAdapter, AwsLambdaHttpAdapterError, AwsLambdaHttpErrorHandler, BodyEventMiddleware, FilesEventMiddleware, IncomingEventMiddleware, MetaBodyEventMiddleware, MetaFilesEventMiddleware, MetaIncomingEventMiddleware, MetaServerResponseMiddleware, RawHttpResponseWrapper, ServerResponseMiddleware, SetAwsLambdaHttpResponseResolverMiddleware, awsLambdaHttpAdapterBlueprint, awsLambdaHttpAdapterResolver, metaAdapterBlueprintMiddleware };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stone-js/aws-lambda-http-adapter",
-  "version": "0.2.0",
+  "version": "0.3.1",
   "description": "Official AWS Lambda HTTP adapter for Stone.js. Run your Stone.js apps on AWS Lambda behind API Gateway with full Continuum lifecycle support.",
   "author": "Mr. Stone <evensstone@gmail.com>",
   "license": "MIT",
@@ -62,16 +62,16 @@
     "prepare": "husky"
   },
   "peerDependencies": {
-    "@stone-js/core": "^0.1.1",
-    "@stone-js/env": "^0.1.1",
-    "@stone-js/filesystem": "^0.1.1",
-    "@stone-js/http-core": "^0.1.2"
+    "@stone-js/core": "^0.2.1",
+    "@stone-js/env": "^0.1.2",
+    "@stone-js/filesystem": "^0.1.2",
+    "@stone-js/http-core": "^0.1.4"
   },
   "dependencies": {
     "accepts": "^1.3.8",
     "bytes": "^3.1.2",
     "content-type": "^1.0.5",
-    "mime": "^4.0.7",
+    "mime": "^4.1.0",
     "proxy-addr": "^2.0.7",
     "statuses": "^2.0.1",
     "type-is": "^2.0.1"
@@ -82,27 +82,27 @@
     "@rollup/plugin-commonjs": "^28.0.2",
     "@rollup/plugin-multi-entry": "^6.0.1",
     "@rollup/plugin-node-resolve": "^15.2.3",
-    "@rollup/plugin-typescript": "^12.1.1",
+    "@rollup/plugin-typescript": "^12.3.0",
     "@types/accepts": "^1.3.7",
     "@types/bytes": "^3.1.5",
     "@types/content-type": "^1.1.8",
-    "@types/node": "^24.0.1",
+    "@types/node": "^24.9.2",
     "@types/proxy-addr": "^2.0.3",
     "@types/statuses": "^2.0.5",
     "@types/type-is": "^1.6.7",
-    "@vitest/coverage-v8": "^3.2.3",
+    "@vitest/coverage-v8": "^3.2.4",
     "husky": "^9.1.7",
-    "rimraf": "^6.0.1",
-    "rollup": "^4.43.0",
+    "rimraf": "^6.1.0",
+    "rollup": "^4.52.5",
     "rollup-plugin-delete": "^3.0.1",
-    "rollup-plugin-dts": "^6.2.1",
-    "rollup-plugin-node-externals": "^8.0.0",
+    "rollup-plugin-dts": "^6.2.3",
+    "rollup-plugin-node-externals": "^8.1.1",
     "ts-standard": "^12.0.2",
     "tslib": "^2.8.1",
-    "typedoc": "^0.28.5",
-    "typedoc-plugin-markdown": "^4.6.4",
-    "typescript": "^5.6.3",
-    "vitest": "^3.2.3"
+    "typedoc": "^0.28.14",
+    "typedoc-plugin-markdown": "^4.9.0",
+    "typescript": "^5.9.3",
+    "vitest": "^3.2.4"
   },
   "ts-standard": {
     "globals": [