@h4ad/serverless-adapter 1.0.1

package/lib/adapters/aws/api-gateway-v1.adapter.js

@@ -0,0 +1,126 @@
+"use strict";
+//#region Imports
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiGatewayV1Adapter = void 0;
+const core_1 = require("../../core");
+/**
+ * The adapter to handle requests from AWS Api Gateway V1
+ *
+ * As per {@link https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-known-issues.html know issues}, we throw an exception when you send the `transfer-encoding=chunked`, currently, API Gateway doesn't support chunked transfer.
+ *
+ * @note This adapter is not fully compatible with @vendia/serverless-express, on @vendia they filter `transfer-encoding=chunked` but we throw an exception.
+ *
+ * @example```typescript
+ * const stripBasePath = '/any/custom/base/path'; // default ''
+ * const adapter = new ApiGatewayV1Adapter({ stripBasePath });
+ * ```
+ *
+ * {@link https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-develop-integrations-lambda.html Event Reference}
+ */
+class ApiGatewayV1Adapter {
+    //#region Constructor
+    /**
+     * Default constructor
+     *
+     * @param options The options to customize the {@link ApiGatewayV1Adapter}
+     */
+    constructor(options) {
+        this.options = options;
+    }
+    //#endregion
+    //#region Public Methods
+    /**
+     * @inheritDoc
+     */
+    getAdapterName() {
+        return ApiGatewayV1Adapter.name;
+    }
+    /**
+     * @inheritDoc
+     */
+    canHandle(event) {
+        const partialEventV1 = event;
+        return !!((partialEventV1 === null || partialEventV1 === void 0 ? void 0 : partialEventV1.requestContext) &&
+            partialEventV1.version !== '2.0' &&
+            partialEventV1.headers &&
+            partialEventV1.multiValueHeaders &&
+            (partialEventV1.queryStringParameters ===
+                partialEventV1.multiValueQueryStringParameters ||
+                (partialEventV1.queryStringParameters &&
+                    partialEventV1.multiValueQueryStringParameters)));
+    }
+    /**
+     * @inheritDoc
+     */
+    getRequest(event) {
+        const method = event.httpMethod;
+        const headers = event.headers;
+        const path = this.getPathFromEvent(event);
+        let body;
+        if (event.body) {
+            const [bufferBody, contentLength] = (0, core_1.getEventBodyAsBuffer)(event.body, event.isBase64Encoded);
+            body = bufferBody;
+            headers['content-length'] = String(contentLength);
+        }
+        const remoteAddress = event.requestContext.identity.sourceIp;
+        return {
+            method,
+            headers,
+            body,
+            remoteAddress,
+            path,
+        };
+    }
+    /**
+     * @inheritDoc
+     */
+    getResponse({ headers: responseHeaders, body, isBase64Encoded, statusCode, response, }) {
+        const multiValueHeaders = (0, core_1.getMultiValueHeadersMap)(responseHeaders);
+        const transferEncodingHeader = multiValueHeaders['transfer-encoding'];
+        const hasTransferEncodingChunked = transferEncodingHeader &&
+            transferEncodingHeader.some(value => value.includes('chunked'));
+        if (hasTransferEncodingChunked) {
+            throw new Error('chunked encoding in headers is not supported by API Gateway V1');
+        }
+        if (response === null || response === void 0 ? void 0 : response.chunkedEncoding) {
+            throw new Error('chunked encoding in response is not supported by API Gateway V1');
+        }
+        return {
+            statusCode,
+            body,
+            multiValueHeaders,
+            isBase64Encoded,
+        };
+    }
+    /**
+     * @inheritDoc
+     */
+    onErrorWhileForwarding({ error, delegatedResolver, respondWithErrors, event, log, }) {
+        const body = respondWithErrors ? error.stack : '';
+        const errorResponse = this.getResponse({
+            event,
+            statusCode: 500,
+            body: body || '',
+            headers: {},
+            isBase64Encoded: false,
+            log,
+        });
+        delegatedResolver.succeed(errorResponse);
+    }
+    //#endregion
+    //#region Protected Methods
+    /**
+     * Get path from event with query strings
+     *
+     * @param event The event sent by serverless
+     */
+    getPathFromEvent(event) {
+        var _a;
+        const stripBasePath = (0, core_1.getDefaultIfUndefined)((_a = this.options) === null || _a === void 0 ? void 0 : _a.stripBasePath, '');
+        const replaceRegex = new RegExp(`^${stripBasePath}`);
+        const path = event.path.replace(replaceRegex, '');
+        const queryParams = event.queryStringParameters || {};
+        return (0, core_1.getPathWithQueryStringParams)(path, queryParams);
+    }
+}
+exports.ApiGatewayV1Adapter = ApiGatewayV1Adapter;

package/lib/adapters/aws/api-gateway-v2.adapter.d.ts

@@ -0,0 +1,61 @@
+import type { APIGatewayProxyEventV2, Context } from 'aws-lambda';
+import type { APIGatewayProxyStructuredResultV2 } from 'aws-lambda/trigger/api-gateway-proxy';
+import { AdapterContract, AdapterRequest, GetResponseAdapterProps, OnErrorProps } from '../../contracts';
+/**
+ * The options to customize the {@link ApiGatewayV2Adapter}
+ */
+export interface ApiGatewayV2Options {
+    /**
+     * Strip base path for custom domains
+     *
+     * @default ''
+     */
+    stripBasePath?: string;
+}
+/**
+ * The adapter to handle requests from AWS Api Gateway V2
+ *
+ * As per {@link https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-known-issues.html know issues}, we throw an exception when you send the `transfer-encoding=chunked`, currently, API Gateway doesn't support chunked transfer.
+ *
+ * @example```typescript
+ * const stripBasePath = '/any/custom/base/path'; // default ''
+ * const adapter = new ApiGatewayV2Adapter({ stripBasePath });
+ * ```
+ *
+ * {@link https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-develop-integrations-lambda.html Event Reference}
+ */
+export declare class ApiGatewayV2Adapter implements AdapterContract<APIGatewayProxyEventV2, Context, APIGatewayProxyStructuredResultV2> {
+    protected readonly options?: ApiGatewayV2Options | undefined;
+    /**
+     * Default constructor
+     *
+     * @param options The options to customize the {@link ApiGatewayV2Adapter}
+     */
+    constructor(options?: ApiGatewayV2Options | undefined);
+    /**
+     * @inheritDoc
+     */
+    getAdapterName(): string;
+    /**
+     * @inheritDoc
+     */
+    canHandle(event: unknown): event is APIGatewayProxyEventV2;
+    /**
+     * @inheritDoc
+     */
+    getRequest(event: APIGatewayProxyEventV2): AdapterRequest;
+    /**
+     * @inheritDoc
+     */
+    getResponse({ headers: responseHeaders, body, isBase64Encoded, statusCode, response, }: GetResponseAdapterProps<APIGatewayProxyEventV2>): APIGatewayProxyStructuredResultV2;
+    /**
+     * @inheritDoc
+     */
+    onErrorWhileForwarding({ error, delegatedResolver, respondWithErrors, event, log, }: OnErrorProps<APIGatewayProxyEventV2, APIGatewayProxyStructuredResultV2>): void;
+    /**
+     * Get path from event with query strings
+     *
+     * @param event The event sent by serverless
+     */
+    protected getPathFromEvent(event: APIGatewayProxyEventV2): string;
+}

package/lib/adapters/aws/api-gateway-v2.adapter.js

@@ -0,0 +1,123 @@
+"use strict";
+//#region Imports
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiGatewayV2Adapter = void 0;
+const core_1 = require("../../core");
+/**
+ * The adapter to handle requests from AWS Api Gateway V2
+ *
+ * As per {@link https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-known-issues.html know issues}, we throw an exception when you send the `transfer-encoding=chunked`, currently, API Gateway doesn't support chunked transfer.
+ *
+ * @example```typescript
+ * const stripBasePath = '/any/custom/base/path'; // default ''
+ * const adapter = new ApiGatewayV2Adapter({ stripBasePath });
+ * ```
+ *
+ * {@link https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-develop-integrations-lambda.html Event Reference}
+ */
+class ApiGatewayV2Adapter {
+    //#region Constructor
+    /**
+     * Default constructor
+     *
+     * @param options The options to customize the {@link ApiGatewayV2Adapter}
+     */
+    constructor(options) {
+        this.options = options;
+    }
+    //#endregion
+    //#region Public Methods
+    /**
+     * @inheritDoc
+     */
+    getAdapterName() {
+        return ApiGatewayV2Adapter.name;
+    }
+    /**
+     * @inheritDoc
+     */
+    canHandle(event) {
+        const apiGatewayEvent = event;
+        return !!((apiGatewayEvent === null || apiGatewayEvent === void 0 ? void 0 : apiGatewayEvent.requestContext) && apiGatewayEvent.version === '2.0');
+    }
+    /**
+     * @inheritDoc
+     */
+    getRequest(event) {
+        const method = event.requestContext.http.method;
+        const path = this.getPathFromEvent(event);
+        const headers = (0, core_1.getFlattenedHeadersMap)(event.headers, ',', true);
+        if (event.cookies)
+            headers.cookie = event.cookies.join('; ');
+        let body;
+        if (event.body) {
+            const [bufferBody, contentLength] = (0, core_1.getEventBodyAsBuffer)(event.body, event.isBase64Encoded);
+            body = bufferBody;
+            headers['content-length'] = String(contentLength);
+        }
+        const remoteAddress = event.requestContext.http.sourceIp;
+        return {
+            method,
+            headers,
+            body,
+            remoteAddress,
+            path,
+        };
+    }
+    /**
+     * @inheritDoc
+     */
+    getResponse({ headers: responseHeaders, body, isBase64Encoded, statusCode, response, }) {
+        const headers = (0, core_1.getFlattenedHeadersMap)(responseHeaders);
+        const transferEncodingHeader = headers['transfer-encoding'];
+        const hasTransferEncodingChunked = transferEncodingHeader && transferEncodingHeader.includes('chunked');
+        if (hasTransferEncodingChunked) {
+            throw new Error('chunked encoding in headers is not supported by API Gateway V1');
+        }
+        if (response === null || response === void 0 ? void 0 : response.chunkedEncoding) {
+            throw new Error('chunked encoding in response is not supported by API Gateway V1');
+        }
+        const cookies = headers['set-cookie'];
+        if (cookies) {
+            headers.cookies = cookies;
+            delete headers['set-cookie'];
+        }
+        return {
+            statusCode,
+            body,
+            headers,
+            isBase64Encoded,
+        };
+    }
+    /**
+     * @inheritDoc
+     */
+    onErrorWhileForwarding({ error, delegatedResolver, respondWithErrors, event, log, }) {
+        const body = respondWithErrors ? error.stack : '';
+        const errorResponse = this.getResponse({
+            event,
+            statusCode: 500,
+            body: body || '',
+            headers: {},
+            isBase64Encoded: false,
+            log,
+        });
+        delegatedResolver.succeed(errorResponse);
+    }
+    //#endregion
+    //#region Protected Methods
+    /**
+     * Get path from event with query strings
+     *
+     * @param event The event sent by serverless
+     */
+    getPathFromEvent(event) {
+        var _a;
+        const stripBasePath = (0, core_1.getDefaultIfUndefined)((_a = this.options) === null || _a === void 0 ? void 0 : _a.stripBasePath, '');
+        const replaceRegex = new RegExp(`^${stripBasePath}`);
+        const path = event.rawPath.replace(replaceRegex, '');
+        const queryParams = event.rawQueryString;
+        return (0, core_1.getPathWithQueryStringParams)(path, queryParams || {});
+    }
+}
+exports.ApiGatewayV2Adapter = ApiGatewayV2Adapter;

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

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

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

@@ -0,0 +1,81 @@
+"use strict";
+//#region Imports
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DynamoDBAdapter = void 0;
+const core_1 = require("../../core");
+/**
+ * The adapter to handle requests from AWS DynamoDB.
+ *
+ * The option of `responseWithErrors` is ignored by this adapter and we always call `resolver.fail` with the error.
+ *
+ * {@link https://docs.aws.amazon.com/lambda/latest/dg/with-ddb.html Event Reference}
+ *
+ * @example```typescript
+ * const dynamoDBForwardPath = '/your/route/dynamo'; // default /dynamo
+ * const dynamoDBForwardMethod = 'POST'; // default POST
+ * const adapter = new DynamoDBAdapter({ dynamoDBForwardPath, dynamoDBForwardMethod });
+ * ```
+ */
+class DynamoDBAdapter {
+    //#region Constructor
+    /**
+     * Default constructor
+     *
+     * @param options The options to customize the {@link DynamoDBAdapter}
+     */
+    constructor(options) {
+        this.options = options;
+    }
+    //#endregion
+    //#region Public Methods
+    /**
+     * @inheritDoc
+     */
+    getAdapterName() {
+        return DynamoDBAdapter.name;
+    }
+    /**
+     * @inheritDoc
+     */
+    canHandle(event) {
+        var _a;
+        const dynamoDBevent = event;
+        if (!Array.isArray(dynamoDBevent === null || dynamoDBevent === void 0 ? void 0 : dynamoDBevent.Records))
+            return false;
+        const eventSource = (_a = dynamoDBevent.Records[0]) === null || _a === void 0 ? void 0 : _a.eventSource;
+        return eventSource === 'aws:dynamodb';
+    }
+    /**
+     * @inheritDoc
+     */
+    getRequest(event) {
+        var _a, _b;
+        const path = (0, core_1.getDefaultIfUndefined)((_a = this.options) === null || _a === void 0 ? void 0 : _a.dynamoDBForwardPath, '/dynamo');
+        const method = (0, core_1.getDefaultIfUndefined)((_b = this.options) === null || _b === void 0 ? void 0 : _b.dynamoDBForwardMethod, 'POST');
+        const [body, contentLength] = (0, core_1.getEventBodyAsBuffer)(JSON.stringify(event), false);
+        const headers = {
+            host: 'dynamodb.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.DynamoDBAdapter = DynamoDBAdapter;

package/lib/adapters/aws/event-bridge.adapter.d.ts

@@ -0,0 +1,66 @@
+import type { Context, EventBridgeEvent } from 'aws-lambda';
+import { AdapterContract, AdapterRequest, OnErrorProps } from '../../contracts';
+import { IEmptyResponse } from '../../core';
+/**
+ * The options to customize the {@link EventBridgeAdapter}
+ */
+export interface EventBridgeOptions {
+    /**
+     * The path that will be used to create a request to be forwarded to the framework.
+     *
+     * @default /eventbridge
+     */
+    eventBridgeForwardPath?: string;
+    /**
+     * The http method that will be used to create a request to be forwarded to the framework.
+     *
+     * @default POST
+     */
+    eventBridgeForwardMethod?: string;
+}
+/**
+ * Just a type alias to ignore generic types in the event
+ */
+export declare type EventBridgeEventAll = EventBridgeEvent<any, any>;
+/**
+ * The adapter to handle requests from AWS EventBridge (Cloudwatch Events).
+ *
+ * The option of `responseWithErrors` is ignored by this adapter and we always call `resolver.fail` with the error.
+ *
+ * {@link https://docs.aws.amazon.com/lambda/latest/dg/services-cloudwatchevents.html Event Reference}
+ *
+ * @example```typescript
+ * const eventBridgeForwardPath = '/your/route/eventbridge'; // default /eventbridge
+ * const eventBridgeForwardMethod = 'POST'; // default POST
+ * const adapter = new EventBridgeAdapter({ eventBridgeForwardPath, eventBridgeForwardMethod });
+ * ```
+ */
+export declare class EventBridgeAdapter implements AdapterContract<EventBridgeEventAll, Context, IEmptyResponse> {
+    protected readonly options?: EventBridgeOptions | undefined;
+    /**
+     * Default constructor
+     *
+     * @param options The options to customize the {@link EventBridgeAdapter}
+     */
+    constructor(options?: EventBridgeOptions | undefined);
+    /**
+     * @inheritDoc
+     */
+    getAdapterName(): string;
+    /**
+     * @inheritDoc
+     */
+    canHandle(event: unknown): event is EventBridgeEventAll;
+    /**
+     * @inheritDoc
+     */
+    getRequest(event: EventBridgeEventAll): AdapterRequest;
+    /**
+     * @inheritDoc
+     */
+    getResponse(): IEmptyResponse;
+    /**
+     * @inheritDoc
+     */
+    onErrorWhileForwarding({ error, delegatedResolver, }: OnErrorProps<EventBridgeEventAll, IEmptyResponse>): void;
+}

package/lib/adapters/aws/event-bridge.adapter.js

@@ -0,0 +1,91 @@
+"use strict";
+//#region Imports
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventBridgeAdapter = void 0;
+const core_1 = require("../../core");
+/**
+ * The adapter to handle requests from AWS EventBridge (Cloudwatch Events).
+ *
+ * The option of `responseWithErrors` is ignored by this adapter and we always call `resolver.fail` with the error.
+ *
+ * {@link https://docs.aws.amazon.com/lambda/latest/dg/services-cloudwatchevents.html Event Reference}
+ *
+ * @example```typescript
+ * const eventBridgeForwardPath = '/your/route/eventbridge'; // default /eventbridge
+ * const eventBridgeForwardMethod = 'POST'; // default POST
+ * const adapter = new EventBridgeAdapter({ eventBridgeForwardPath, eventBridgeForwardMethod });
+ * ```
+ */
+class EventBridgeAdapter {
+    //#region Constructor
+    /**
+     * Default constructor
+     *
+     * @param options The options to customize the {@link EventBridgeAdapter}
+     */
+    constructor(options) {
+        this.options = options;
+    }
+    //#endregion
+    //#region Public Methods
+    /**
+     * @inheritDoc
+     */
+    getAdapterName() {
+        return EventBridgeAdapter.name;
+    }
+    /**
+     * @inheritDoc
+     */
+    canHandle(event) {
+        const eventBridgeEvent = event;
+        // thanks to @cnuss in https://github.com/vendia/serverless-express/blob/b5da6070b8dd2fb674c1f7035dd7edfef1dc83a2/src/event-sources/utils.js#L87
+        return !!(eventBridgeEvent &&
+            eventBridgeEvent.version &&
+            eventBridgeEvent.version === '0' &&
+            eventBridgeEvent.id &&
+            eventBridgeEvent['detail-type'] &&
+            eventBridgeEvent.source &&
+            eventBridgeEvent.account &&
+            eventBridgeEvent.time &&
+            eventBridgeEvent.region &&
+            eventBridgeEvent.resources &&
+            Array.isArray(eventBridgeEvent.resources) &&
+            eventBridgeEvent.detail &&
+            typeof eventBridgeEvent.detail === 'object' &&
+            !Array.isArray(eventBridgeEvent.detail));
+    }
+    /**
+     * @inheritDoc
+     */
+    getRequest(event) {
+        var _a, _b;
+        const path = (0, core_1.getDefaultIfUndefined)((_a = this.options) === null || _a === void 0 ? void 0 : _a.eventBridgeForwardPath, '/eventbridge');
+        const method = (0, core_1.getDefaultIfUndefined)((_b = this.options) === null || _b === void 0 ? void 0 : _b.eventBridgeForwardMethod, 'POST');
+        const [body, contentLength] = (0, core_1.getEventBodyAsBuffer)(JSON.stringify(event), false);
+        const headers = {
+            host: 'events.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.EventBridgeAdapter = EventBridgeAdapter;

package/lib/adapters/aws/index.d.ts

@@ -0,0 +1,8 @@
+export * from './alb.adapter';
+export * from './api-gateway-v1.adapter';
+export * from './api-gateway-v2.adapter';
+export * from './dynamodb.adapter';
+export * from './event-bridge.adapter';
+export * from './lambda-edge.adapter';
+export * from './sns.adapter';
+export * from './sqs.adapter';

package/lib/adapters/aws/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./alb.adapter"), exports);
+__exportStar(require("./api-gateway-v1.adapter"), exports);
+__exportStar(require("./api-gateway-v2.adapter"), exports);
+__exportStar(require("./dynamodb.adapter"), exports);
+__exportStar(require("./event-bridge.adapter"), exports);
+__exportStar(require("./lambda-edge.adapter"), exports);
+__exportStar(require("./sns.adapter"), exports);
+__exportStar(require("./sqs.adapter"), exports);