@h4ad/serverless-adapter 1.0.1

package/lib/adapters/aws/lambda-edge.adapter.d.ts

@@ -0,0 +1,179 @@
+import type { CloudFrontRequest, Context } from 'aws-lambda';
+import type { CloudFrontEvent, CloudFrontHeaders } from 'aws-lambda/common/cloudfront';
+import type { CloudFrontRequestEvent, CloudFrontRequestResult } from 'aws-lambda/trigger/cloudfront-request';
+import { BothValueHeaders, SingleValueHeaders } from '../../@types';
+import { Concrete } from '../../@types/helpers';
+import { AdapterContract, AdapterRequest, GetResponseAdapterProps, OnErrorProps } from '../../contracts';
+/**
+ * The type alias to indicate where we get the default value of query string to create the request.
+ */
+export declare type DefaultQueryString = CloudFrontRequestEvent['Records'][number]['cf']['request']['querystring'];
+/**
+ * The type alias to indicate where we get the default value of path to create the request.
+ */
+export declare type DefaultForwardPath = CloudFrontRequestEvent['Records'][number]['cf']['request']['uri'];
+/**
+ * Represents the body of the new version of Lambda@edge, which uses the `body` property inside `request` as the body (library) of the request.
+ */
+export declare type NewLambdaEdgeBody = CloudFrontRequestEvent['Records'][number]['cf']['request']['body'];
+/**
+ * Represents the body of the old version of Lambda@edge supported by @vendia/serverless-express which returns the `data` property within `body` for the body (library) of the request.
+ */
+export declare type OldLambdaEdgeBody = Concrete<CloudFrontRequestEvent['Records'][number]['cf']['request']>['body']['data'];
+/**
+ * The list was created based on {@link https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/edge-functions-restrictions.html these docs} in the "Disallowed Headers" section.
+ */
+export declare const DEFAULT_LAMBDA_EDGE_DISALLOWED_HEADERS: (string | RegExp)[];
+/**
+ * The default max response size in bytes of viewer request and viewer response.
+ *
+ * @default 1024 * 40 = 40960 = 40KB
+ *
+ * {@link https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/cloudfront-limits.html Reference}
+ */
+export declare const DEFAULT_VIEWER_MAX_RESPONSE_SIZE_IN_BYTES: number;
+/**
+ * The default max response size in bytes of origin request and origin response.
+ *
+ * @default 1024 * 1024 = 1048576 = 1MB
+ *
+ * {@link https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/cloudfront-limits.html Reference}
+ */
+export declare const DEFAULT_ORIGIN_MAX_RESPONSE_SIZE_IN_BYTES: number;
+/**
+ * The options to customize the {@link LambdaEdgeAdapter}.
+ */
+export interface LambdaEdgeAdapterOptions {
+    /**
+     * The max response size in bytes of viewer request and viewer response.
+     *
+     * {@link https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/cloudfront-limits.html Reference}
+     *
+     * @default {@link DEFAULT_VIEWER_MAX_RESPONSE_SIZE_IN_BYTES}
+     */
+    viewerMaxResponseSizeInBytes?: number;
+    /**
+     * The max response size in bytes of origin request and origin response.
+     *
+     * {@link https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/cloudfront-limits.html Reference}
+     *
+     * @default {@link DEFAULT_ORIGIN_MAX_RESPONSE_SIZE_IN_BYTES}
+     */
+    originMaxResponseSizeInBytes?: number;
+    /**
+     * The function called when the response size exceed the max limits of the Lambda@edge
+     *
+     * @param response The response from framework that exceed the limit of Lambda@edge
+     * @default undefined
+     */
+    onResponseSizeExceedLimit?: (response: CloudFrontRequestResult) => CloudFrontRequestResult;
+    /**
+     * Return the path to be used to create a request to the framework
+     *
+     * @note You MUST append the query params from {@link DefaultQueryString}, you can use the helper {@link getPathWithQueryStringParams}.
+     *
+     * @param event The event sent by the serverless
+     * @default The value from {@link DefaultForwardPath}
+     */
+    getPathFromEvent?: (event: CloudFrontRequestEvent['Records'][number]) => string;
+    /**
+     * The headers that will be stripped from the headers object because Lambda@edge will fail if these headers are passed in the response.
+     *
+     * @note All headers will be compared with other headers using toLowerCase, but for the RegExp, if you modify this list, you must put the flag `/gmi` at the end of the RegExp (ex: `/(X-Amz-Cf-)(.*)/gim`)
+     *
+     * @default To get the full list, see {@link DEFAULT_LAMBDA_EDGE_DISALLOWED_HEADERS}.
+     */
+    disallowedHeaders?: (string | RegExp)[];
+    /**
+     * If you want to change how we check against the header if it should be stripped, you can pass a function to this property.
+     *
+     * @param header The header of the response
+     * @default The default method is implemented to test the header against the list {@link disallowedHeaders}.
+     */
+    shouldStripHeader?: (header: string) => boolean;
+    /**
+     * By default, the {@link CloudFrontRequestResult} has the `headers` property, but we also have the headers sent by the framework too.
+     * So this setting tells us how to handle this case, if you pass `true` to this property, we will use the framework headers.
+     * Otherwise, we will forward the body back to cloudfront without modifying or trying to set the `headers` property inside {@link CloudFrontRequestResult}.
+     *
+     * @default false
+     */
+    shouldUseHeadersFromFramework?: boolean;
+}
+/**
+ * The adapter to handle requests from AWS Lambda@Edge.
+ *
+ * This adapter is not fully compatible with Lambda@edge supported by @vendia/serverless-express, the request body was modified to return {@link NewLambdaEdgeBody} instead {@link OldLambdaEdgeBody}.
+ * Also, the response has been modified to return entire body sent by the framework, in this form you MUST return the body from the framework in the format of {@link CloudFrontRequestResult}.
+ * And when we get an error during the forwarding to the framework, we call `resolver.fail` instead of trying to return status 500 like the old implementation was.
+ *
+ * {@link https://docs.aws.amazon.com/lambda/latest/dg/lambda-edge.html Lambda edge docs}
+ * {@link https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/lambda-event-structure.html Event Reference}
+ *
+ * @example```typescript
+ * ```
+ */
+export declare class LambdaEdgeAdapter implements AdapterContract<CloudFrontRequestEvent, Context, CloudFrontRequestResult> {
+    protected readonly options?: LambdaEdgeAdapterOptions | undefined;
+    /**
+     * Default constructor
+     *
+     * @param options The options to customize the {@link LambdaEdgeAdapter}
+     */
+    constructor(options?: LambdaEdgeAdapterOptions | undefined);
+    /**
+     * This property is used to cache the disallowed headers in `RegExp` version, even if you provide a string in `disallowedHeader`, we will cache it in an instance of `RegExp`.
+     */
+    protected readonly cachedDisallowedHeaders: RegExp[];
+    /**
+     * @inheritDoc
+     */
+    getAdapterName(): string;
+    /**
+     * @inheritDoc
+     */
+    canHandle(event: unknown): event is CloudFrontRequestEvent;
+    /**
+     * @inheritDoc
+     */
+    getRequest(event: CloudFrontRequestEvent): AdapterRequest;
+    /**
+     * @inheritDoc
+     */
+    getResponse(props: GetResponseAdapterProps<CloudFrontRequestEvent>): CloudFrontRequestResult;
+    /**
+     * @inheritDoc
+     */
+    onErrorWhileForwarding({ error, delegatedResolver, }: OnErrorProps<CloudFrontRequestEvent, CloudFrontRequestResult>): void;
+    /**
+     * Returns the headers with the flattened (non-list) values of the cloudfront request headers
+     *
+     * @param cloudFrontRequest The cloudfront request
+     */
+    protected getFlattenedHeadersFromCloudfrontRequest(cloudFrontRequest: CloudFrontRequest): SingleValueHeaders;
+    /**
+     * Returns the framework response in the format required by the Lambda@edge.
+     *
+     * @param body The body of the response
+     * @param frameworkHeaders The headers from the framework
+     */
+    protected getResponseToLambdaEdge({ body, headers: frameworkHeaders, }: GetResponseAdapterProps<CloudFrontRequestEvent>): CloudFrontRequestResult;
+    /**
+     * Returns headers in Cloudfront Response format.
+     *
+     * @param originalHeaders The original version of the request sent by the framework
+     */
+    protected getHeadersForCloudfrontResponse(originalHeaders: BothValueHeaders): CloudFrontHeaders;
+    /**
+     * Returns the information if we should remove the response header
+     *
+     * @param headerKey The header that will be tested
+     */
+    protected shouldStripHeader(headerKey: string): boolean;
+    /**
+     * Determines whether the event is from origin or is from viewer.
+     *
+     * @param content The event sent by AWS or the response sent by the framework
+     */
+    protected isEventTypeOrigin(content: CloudFrontEvent['config']): boolean;
+}

package/lib/adapters/aws/lambda-edge.adapter.js

@@ -0,0 +1,248 @@
+"use strict";
+//#region Imports
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LambdaEdgeAdapter = exports.DEFAULT_ORIGIN_MAX_RESPONSE_SIZE_IN_BYTES = exports.DEFAULT_VIEWER_MAX_RESPONSE_SIZE_IN_BYTES = exports.DEFAULT_LAMBDA_EDGE_DISALLOWED_HEADERS = void 0;
+const core_1 = require("../../core");
+/**
+ * The list was created based on {@link https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/edge-functions-restrictions.html these docs} in the "Disallowed Headers" section.
+ */
+exports.DEFAULT_LAMBDA_EDGE_DISALLOWED_HEADERS = [
+    'Connection',
+    'Expect',
+    'Keep-Alive',
+    'Proxy-Authenticate',
+    'Proxy-Authorization',
+    'Proxy-Connection',
+    'Trailer',
+    'Upgrade',
+    'X-Accel-Buffering',
+    'X-Accel-Charset',
+    'X-Accel-Limit-Rate',
+    'X-Accel-Redirect',
+    /(X-Amz-Cf-)(.*)/gim,
+    'X-Cache',
+    /(X-Edge-)(.*)/gim,
+    'X-Forwarded-Proto',
+    'X-Real-IP',
+];
+/**
+ * The default max response size in bytes of viewer request and viewer response.
+ *
+ * @default 1024 * 40 = 40960 = 40KB
+ *
+ * {@link https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/cloudfront-limits.html Reference}
+ */
+exports.DEFAULT_VIEWER_MAX_RESPONSE_SIZE_IN_BYTES = 1024 * 40;
+/**
+ * The default max response size in bytes of origin request and origin response.
+ *
+ * @default 1024 * 1024 = 1048576 = 1MB
+ *
+ * {@link https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/cloudfront-limits.html Reference}
+ */
+exports.DEFAULT_ORIGIN_MAX_RESPONSE_SIZE_IN_BYTES = 1024 * 1024;
+/**
+ * The adapter to handle requests from AWS Lambda@Edge.
+ *
+ * This adapter is not fully compatible with Lambda@edge supported by @vendia/serverless-express, the request body was modified to return {@link NewLambdaEdgeBody} instead {@link OldLambdaEdgeBody}.
+ * Also, the response has been modified to return entire body sent by the framework, in this form you MUST return the body from the framework in the format of {@link CloudFrontRequestResult}.
+ * And when we get an error during the forwarding to the framework, we call `resolver.fail` instead of trying to return status 500 like the old implementation was.
+ *
+ * {@link https://docs.aws.amazon.com/lambda/latest/dg/lambda-edge.html Lambda edge docs}
+ * {@link https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/lambda-event-structure.html Event Reference}
+ *
+ * @example```typescript
+ * ```
+ */
+class LambdaEdgeAdapter {
+    //#region Constructor
+    /**
+     * Default constructor
+     *
+     * @param options The options to customize the {@link LambdaEdgeAdapter}
+     */
+    constructor(options) {
+        var _a;
+        this.options = options;
+        const disallowedHeaders = (0, core_1.getDefaultIfUndefined)((_a = this.options) === null || _a === void 0 ? void 0 : _a.disallowedHeaders, exports.DEFAULT_LAMBDA_EDGE_DISALLOWED_HEADERS);
+        this.cachedDisallowedHeaders = disallowedHeaders.map(disallowedHeader => {
+            if (disallowedHeader instanceof RegExp)
+                return disallowedHeader;
+            return new RegExp(`(${disallowedHeader})`, 'gim');
+        });
+    }
+    //#endregion
+    //#region Public Methods
+    /**
+     * @inheritDoc
+     */
+    getAdapterName() {
+        return LambdaEdgeAdapter.name;
+    }
+    /**
+     * @inheritDoc
+     */
+    canHandle(event) {
+        var _a, _b, _c;
+        const lambdaEdgeEvent = event;
+        if (!Array.isArray(lambdaEdgeEvent === null || lambdaEdgeEvent === void 0 ? void 0 : lambdaEdgeEvent.Records))
+            return false;
+        const eventType = (_c = (_b = (_a = lambdaEdgeEvent.Records[0]) === null || _a === void 0 ? void 0 : _a.cf) === null || _b === void 0 ? void 0 : _b.config) === null || _c === void 0 ? void 0 : _c.eventType;
+        const validEventTypes = [
+            'origin-response',
+            'origin-request',
+            'viewer-response',
+            'viewer-request',
+        ];
+        return validEventTypes.includes(eventType);
+    }
+    /**
+     * @inheritDoc
+     */
+    getRequest(event) {
+        var _a;
+        const request = event.Records[0];
+        const cloudFrontRequest = request.cf.request;
+        const method = cloudFrontRequest.method;
+        const pathFromOptions = ((_a = this.options) === null || _a === void 0 ? void 0 : _a.getPathFromEvent)
+            ? this.options.getPathFromEvent(request)
+            : undefined;
+        const defaultPath = (0, core_1.getPathWithQueryStringParams)(cloudFrontRequest.uri, cloudFrontRequest.querystring);
+        const path = (0, core_1.getDefaultIfUndefined)(pathFromOptions, defaultPath);
+        const remoteAddress = cloudFrontRequest.clientIp;
+        const headers = this.getFlattenedHeadersFromCloudfrontRequest(cloudFrontRequest);
+        let body;
+        if (cloudFrontRequest.body) {
+            const [buffer, contentLength] = (0, core_1.getEventBodyAsBuffer)(JSON.stringify(cloudFrontRequest.body), false);
+            body = buffer;
+            headers['content-length'] = contentLength.toString();
+        }
+        const { host } = headers;
+        return {
+            method,
+            path,
+            headers,
+            body,
+            remoteAddress,
+            host,
+            hostname: host,
+        };
+    }
+    /**
+     * @inheritDoc
+     */
+    getResponse(props) {
+        var _a, _b, _c;
+        const response = this.getResponseToLambdaEdge(props);
+        const responseToServiceBytes = new TextEncoder().encode(JSON.stringify(response)).length;
+        const isOriginRequestOrResponse = this.isEventTypeOrigin(props.event.Records[0].cf.config);
+        const maxSizeInBytes = isOriginRequestOrResponse
+            ? (0, core_1.getDefaultIfUndefined)((_a = this.options) === null || _a === void 0 ? void 0 : _a.originMaxResponseSizeInBytes, exports.DEFAULT_ORIGIN_MAX_RESPONSE_SIZE_IN_BYTES)
+            : (0, core_1.getDefaultIfUndefined)((_b = this.options) === null || _b === void 0 ? void 0 : _b.viewerMaxResponseSizeInBytes, exports.DEFAULT_VIEWER_MAX_RESPONSE_SIZE_IN_BYTES);
+        if (responseToServiceBytes <= maxSizeInBytes)
+            return response;
+        if ((_c = this.options) === null || _c === void 0 ? void 0 : _c.onResponseSizeExceedLimit)
+            this.options.onResponseSizeExceedLimit(response);
+        else {
+            props.log.error(`SERVERLESS_ADAPTER:LAMBDA_EDGE_ADAPTER: Max response size exceeded: ${responseToServiceBytes} of the max of ${maxSizeInBytes}.`);
+        }
+        return response;
+    }
+    /**
+     * @inheritDoc
+     */
+    onErrorWhileForwarding({ error, delegatedResolver, }) {
+        delegatedResolver.fail(error);
+    }
+    //#endregion
+    //#region Protected Methods
+    /**
+     * Returns the headers with the flattened (non-list) values of the cloudfront request headers
+     *
+     * @param cloudFrontRequest The cloudfront request
+     */
+    getFlattenedHeadersFromCloudfrontRequest(cloudFrontRequest) {
+        const headers = {};
+        const headerValuePairs = Object.entries(cloudFrontRequest.headers);
+        for (const [headerKey, headerValue] of headerValuePairs)
+            headers[headerKey] = headerValue.map(header => header.value).join(',');
+        return headers;
+    }
+    /**
+     * Returns the framework response in the format required by the Lambda@edge.
+     *
+     * @param body The body of the response
+     * @param frameworkHeaders The headers from the framework
+     */
+    getResponseToLambdaEdge({ body, headers: frameworkHeaders, }) {
+        var _a;
+        const shouldUseHeadersFromFramework = (0, core_1.getDefaultIfUndefined)((_a = this.options) === null || _a === void 0 ? void 0 : _a.shouldUseHeadersFromFramework, false);
+        const parsedBody = JSON.parse(body);
+        if (parsedBody.headers) {
+            parsedBody.headers = Object.keys(parsedBody.headers).reduce((acc, header) => {
+                if (this.shouldStripHeader(header))
+                    return acc;
+                acc[header] = parsedBody.headers[header];
+                return acc;
+            }, {});
+        }
+        if (!shouldUseHeadersFromFramework)
+            return parsedBody;
+        parsedBody.headers = this.getHeadersForCloudfrontResponse(frameworkHeaders);
+        return parsedBody;
+    }
+    /**
+     * Returns headers in Cloudfront Response format.
+     *
+     * @param originalHeaders The original version of the request sent by the framework
+     */
+    getHeadersForCloudfrontResponse(originalHeaders) {
+        const originalHeadersEntries = Object.entries(originalHeaders);
+        const headers = {};
+        for (const [headerKey, headerValue] of originalHeadersEntries) {
+            if (this.shouldStripHeader(headerKey))
+                continue;
+            if (!headers[headerKey])
+                headers[headerKey] = [];
+            if (!Array.isArray(headerValue)) {
+                headers[headerKey].push({
+                    key: headerKey,
+                    value: headerValue || '',
+                });
+                continue;
+            }
+            const headersArray = headerValue.map(value => ({
+                key: headerKey,
+                value: value,
+            }));
+            headers[headerKey].push(...headersArray);
+        }
+        return headers;
+    }
+    /**
+     * Returns the information if we should remove the response header
+     *
+     * @param headerKey The header that will be tested
+     */
+    shouldStripHeader(headerKey) {
+        var _a;
+        if ((_a = this.options) === null || _a === void 0 ? void 0 : _a.shouldStripHeader)
+            return this.options.shouldStripHeader(headerKey);
+        const headerKeyLowerCase = headerKey.toLowerCase();
+        for (const stripHeaderIf of this.cachedDisallowedHeaders) {
+            if (!stripHeaderIf.test(headerKeyLowerCase))
+                continue;
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Determines whether the event is from origin or is from viewer.
+     *
+     * @param content The event sent by AWS or the response sent by the framework
+     */
+    isEventTypeOrigin(content) {
+        return content.eventType.includes('origin');
+    }
+}
+exports.LambdaEdgeAdapter = LambdaEdgeAdapter;

package/lib/adapters/aws/sns.adapter.d.ts

@@ -0,0 +1,62 @@
+import type { Context, SNSEvent } from 'aws-lambda';
+import { AdapterContract, AdapterRequest, OnErrorProps } from '../../contracts';
+import { IEmptyResponse } from '../../core';
+/**
+ * The options to customize the {@link SNSAdapter}
+ */
+export interface SNSAdapterOptions {
+    /**
+     * The path that will be used to create a request to be forwarded to the framework.
+     *
+     * @default /sns
+     */
+    snsForwardPath?: string;
+    /**
+     * The http method that will be used to create a request to be forwarded to the framework.
+     *
+     * @default POST
+     */
+    snsForwardMethod?: string;
+}
+/**
+ * The adapter to handle requests from AWS SNS.
+ *
+ * The option of `responseWithErrors` is ignored by this adapter and we always call `resolver.fail` with the error.
+ *
+ * {@link https://docs.aws.amazon.com/pt_br/lambda/latest/dg/with-sns.html Event Reference}
+ *
+ * @example```typescript
+ * const snsForwardPath = '/your/route/sns'; // default /sns
+ * const snsForwardMethod = 'POST'; // default POST
+ * const adapter = new SNSAdapter({ snsForwardPath, snsForwardMethod });
+ * ```
+ */
+export declare class SNSAdapter implements AdapterContract<SNSEvent, Context, IEmptyResponse> {
+    protected readonly options?: SNSAdapterOptions | undefined;
+    /**
+     * Default constructor
+     *
+     * @param options The options to customize the {@link SNSAdapter}
+     */
+    constructor(options?: SNSAdapterOptions | undefined);
+    /**
+     * @inheritDoc
+     */
+    getAdapterName(): string;
+    /**
+     * @inheritDoc
+     */
+    canHandle(event: unknown): event is SNSEvent;
+    /**
+     * @inheritDoc
+     */
+    getRequest(event: SNSEvent): AdapterRequest;
+    /**
+     * @inheritDoc
+     */
+    getResponse(): IEmptyResponse;
+    /**
+     * @inheritDoc
+     */
+    onErrorWhileForwarding({ error, delegatedResolver, }: OnErrorProps<SNSEvent, IEmptyResponse>): void;
+}

package/lib/adapters/aws/sns.adapter.js

@@ -0,0 +1,81 @@
+"use strict";
+//#region Imports
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SNSAdapter = void 0;
+const core_1 = require("../../core");
+/**
+ * The adapter to handle requests from AWS SNS.
+ *
+ * The option of `responseWithErrors` is ignored by this adapter and we always call `resolver.fail` with the error.
+ *
+ * {@link https://docs.aws.amazon.com/pt_br/lambda/latest/dg/with-sns.html Event Reference}
+ *
+ * @example```typescript
+ * const snsForwardPath = '/your/route/sns'; // default /sns
+ * const snsForwardMethod = 'POST'; // default POST
+ * const adapter = new SNSAdapter({ snsForwardPath, snsForwardMethod });
+ * ```
+ */
+class SNSAdapter {
+    //#region Constructor
+    /**
+     * Default constructor
+     *
+     * @param options The options to customize the {@link SNSAdapter}
+     */
+    constructor(options) {
+        this.options = options;
+    }
+    //#endregion
+    //#region Public Methods
+    /**
+     * @inheritDoc
+     */
+    getAdapterName() {
+        return SNSAdapter.name;
+    }
+    /**
+     * @inheritDoc
+     */
+    canHandle(event) {
+        var _a;
+        const snsEvent = event;
+        if (!Array.isArray(snsEvent === null || snsEvent === void 0 ? void 0 : snsEvent.Records))
+            return false;
+        const eventSource = (_a = snsEvent.Records[0]) === null || _a === void 0 ? void 0 : _a.EventSource;
+        return eventSource === 'aws:sns';
+    }
+    /**
+     * @inheritDoc
+     */
+    getRequest(event) {
+        var _a, _b;
+        const path = (0, core_1.getDefaultIfUndefined)((_a = this.options) === null || _a === void 0 ? void 0 : _a.snsForwardPath, '/sns');
+        const method = (0, core_1.getDefaultIfUndefined)((_b = this.options) === null || _b === void 0 ? void 0 : _b.snsForwardMethod, 'POST');
+        const [body, contentLength] = (0, core_1.getEventBodyAsBuffer)(JSON.stringify(event), false);
+        const headers = {
+            host: 'sns.amazonaws.com',
+            'content-type': 'application/json',
+            'content-length': String(contentLength),
+        };
+        return {
+            method,
+            headers,
+            body,
+            path,
+        };
+    }
+    /**
+     * @inheritDoc
+     */
+    getResponse() {
+        return core_1.EmptyResponse;
+    }
+    /**
+     * @inheritDoc
+     */
+    onErrorWhileForwarding({ error, delegatedResolver, }) {
+        delegatedResolver.fail(error);
+    }
+}
+exports.SNSAdapter = SNSAdapter;

package/lib/adapters/aws/sqs.adapter.d.ts

@@ -0,0 +1,62 @@
+import type { Context, SQSEvent } from 'aws-lambda';
+import { AdapterContract, AdapterRequest, OnErrorProps } from '../../contracts';
+import { IEmptyResponse } from '../../core';
+/**
+ * The options to customize the {@link SQSAdapter}
+ */
+export interface SQSAdapterOptions {
+    /**
+     * The path that will be used to create a request to be forwarded to the framework.
+     *
+     * @default /sqs
+     */
+    sqsForwardPath?: string;
+    /**
+     * The http method that will be used to create a request to be forwarded to the framework.
+     *
+     * @default POST
+     */
+    sqsForwardMethod?: string;
+}
+/**
+ * The adapter to handle requests from AWS SQS.
+ *
+ * The option of `responseWithErrors` is ignored by this adapter and we always call `resolver.fail` with the error.
+ *
+ * {@link https://docs.aws.amazon.com/pt_br/lambda/latest/dg/with-sqs.html Event Reference}
+ *
+ * @example```typescript
+ * const sqsForwardPath = '/your/route/sqs'; // default /sqs
+ * const sqsForwardMethod = 'POST'; // default POST
+ * const adapter = new SQSAdapter({ sqsForwardPath, sqsForwardMethod });
+ * ```
+ */
+export declare class SQSAdapter implements AdapterContract<SQSEvent, Context, IEmptyResponse> {
+    protected readonly options?: SQSAdapterOptions | undefined;
+    /**
+     * Default constructor
+     *
+     * @param options The options to customize the {@link SQSAdapter}
+     */
+    constructor(options?: SQSAdapterOptions | undefined);
+    /**
+     * @inheritDoc
+     */
+    getAdapterName(): string;
+    /**
+     * @inheritDoc
+     */
+    canHandle(event: unknown): event is SQSEvent;
+    /**
+     * @inheritDoc
+     */
+    getRequest(event: SQSEvent): AdapterRequest;
+    /**
+     * @inheritDoc
+     */
+    getResponse(): IEmptyResponse;
+    /**
+     * @inheritDoc
+     */
+    onErrorWhileForwarding({ error, delegatedResolver, }: OnErrorProps<SQSEvent, IEmptyResponse>): void;
+}