@h4ad/serverless-adapter 1.0.1

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

@@ -0,0 +1,81 @@
+"use strict";
+//#region Imports
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SQSAdapter = void 0;
+const core_1 = require("../../core");
+/**
+ * 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 });
+ * ```
+ */
+class SQSAdapter {
+    //#region Constructor
+    /**
+     * Default constructor
+     *
+     * @param options The options to customize the {@link SQSAdapter}
+     */
+    constructor(options) {
+        this.options = options;
+    }
+    //#endregion
+    //#region Public Methods
+    /**
+     * @inheritDoc
+     */
+    getAdapterName() {
+        return SQSAdapter.name;
+    }
+    /**
+     * @inheritDoc
+     */
+    canHandle(event) {
+        var _a;
+        const sqsEvent = event;
+        if (!Array.isArray(sqsEvent === null || sqsEvent === void 0 ? void 0 : sqsEvent.Records))
+            return false;
+        const eventSource = (_a = sqsEvent.Records[0]) === null || _a === void 0 ? void 0 : _a.eventSource;
+        return eventSource === 'aws:sqs';
+    }
+    /**
+     * @inheritDoc
+     */
+    getRequest(event) {
+        var _a, _b;
+        const path = (0, core_1.getDefaultIfUndefined)((_a = this.options) === null || _a === void 0 ? void 0 : _a.sqsForwardPath, '/sqs');
+        const method = (0, core_1.getDefaultIfUndefined)((_b = this.options) === null || _b === void 0 ? void 0 : _b.sqsForwardMethod, 'POST');
+        const [body, contentLength] = (0, core_1.getEventBodyAsBuffer)(JSON.stringify(event), false);
+        const headers = {
+            host: 'sqs.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.SQSAdapter = SQSAdapter;

package/lib/adapters/index.d.ts

@@ -0,0 +1 @@
+export * from './aws';

package/lib/adapters/index.js

@@ -0,0 +1,13 @@
+"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("./aws"), exports);

package/lib/contracts/adapter.contract.d.ts

@@ -0,0 +1,152 @@
+/// <reference types="node" />
+import { BothValueHeaders, SingleValueHeaders } from '../@types';
+import { ILogger } from '../core';
+import { ServerlessResponse } from '../network';
+import { DelegatedResolver } from './resolver.contract';
+/**
+ * The props of the method that verify if this handler should handle the event.
+ */
+export interface CanHandleProps<TEvent, TContext> {
+    /**
+     * The event sent by the serverless
+     */
+    event: TEvent | unknown;
+    /**
+     * The context sent by the serverless
+     */
+    context: TContext | unknown;
+    /**
+     * The instance of the logger.
+     */
+    log: ILogger;
+}
+/**
+ * The request interface used to bridge any event source to the framework.
+ */
+export interface AdapterRequest {
+    /**
+     * The HTTP Method to use to create the request to the framework
+     */
+    method: string;
+    /**
+     * The path to use to create the request to the framework
+     */
+    path: string;
+    /**
+     * The headers to use to create the request to the framework
+     */
+    headers: SingleValueHeaders;
+    /**
+     * The body as buffer to use to create the request to the framework
+     */
+    body: Buffer | undefined;
+    /**
+     * The remote address (client ip) to use to create the request to the framework
+     */
+    remoteAddress?: string;
+    /**
+     * The address of the event source (used in Lambda@edge)
+     */
+    host?: string;
+    /**
+     * The address of the event source (used in Lambda@edge)
+     */
+    hostname?: string;
+}
+/**
+ * The props of the method that get the response from the framework and transform it into a format that the event source can handle
+ */
+export interface GetResponseAdapterProps<TEvent> {
+    /**
+     * The event sent by the serverless
+     */
+    event: TEvent;
+    /**
+     * The framework {@link ServerlessResponse response}.
+     *
+     * @note It can be optional, as this method can be used when an error occurs during the handling of the request by the framework.
+     */
+    response?: ServerlessResponse;
+    /**
+     * The framework response status code
+     */
+    statusCode: number;
+    /**
+     * The framework response body
+     */
+    body: string;
+    /**
+     * The framework response headers
+     */
+    headers: BothValueHeaders;
+    /**
+     * Indicates whether the response is base64 encoded or not
+     */
+    isBase64Encoded: boolean;
+    /**
+     * The instance of the logger
+     */
+    log: ILogger;
+}
+/**
+ * The props of the method that handle the response when an error occurs while forwarding the request to the framework
+ */
+export interface OnErrorProps<TEvent, TResponse> {
+    /**
+     * The event sent by the serverless
+     */
+    event: TEvent;
+    /**
+     * The error throwed during forwarding
+     */
+    error: Error;
+    /**
+     * The instance of the resolver
+     */
+    delegatedResolver: DelegatedResolver<TResponse>;
+    /**
+     * Indicates whether to forward the (error.stack) or not to the client
+     */
+    respondWithErrors: boolean;
+    /**
+     * The instance of the logger
+     */
+    log: ILogger;
+}
+/**
+ * The interface that represents a contract between the adapter and the actual implementation of the adapter.
+ */
+export interface AdapterContract<TEvent, TContext, TResponse> {
+    /**
+     * Get the adapter name
+     */
+    getAdapterName(): string;
+    /**
+     * Decide if this adapter can handle a request based in the event payload
+     *
+     * @param event The event sent by serverless
+     * @param context The context sent by the serverless
+     * @param log The instance of logger
+     */
+    canHandle(event: unknown, context: TContext, log: ILogger): boolean;
+    /**
+     * Maps the serverless payload to an actual request that a framework can handle
+     *
+     * @param event The event sent by serverless
+     * @param context The context sent by the serverless
+     * @param log The instance of logger
+     */
+    getRequest(event: TEvent, context: TContext, log: ILogger): AdapterRequest;
+    /**
+     * Maps the response of the framework to a payload that serverless can handle
+     *
+     * @param props The props sent by serverless
+     */
+    getResponse(props: GetResponseAdapterProps<TEvent>): TResponse;
+    /**
+     * When an error occurs while forwarding the request to the framework
+     *
+     * @note You must call resolver.fail or resolver.succeed when implementing this method.
+     */
+    onErrorWhileForwarding(props: OnErrorProps<TEvent, TResponse>): void;
+}

package/lib/contracts/adapter.contract.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/contracts/framework.contract.d.ts

@@ -0,0 +1,15 @@
+/// <reference types="node" />
+import { IncomingMessage, ServerResponse } from 'http';
+/**
+ * The interface that represents a contract between the framework and the framework implementation
+ */
+export interface FrameworkContract<TApp> {
+    /**
+     * Send the request and response objects to the framework
+     *
+     * @param app
+     * @param request
+     * @param response
+     */
+    sendRequest(app: TApp, request: IncomingMessage, response: ServerResponse): void;
+}

package/lib/contracts/framework.contract.js

@@ -0,0 +1,3 @@
+"use strict";
+//#region Imports
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/contracts/handler.contract.d.ts

@@ -0,0 +1,18 @@
+import { BinarySettings } from '../@types';
+import { ILogger } from '../core';
+import { AdapterContract } from './adapter.contract';
+import { FrameworkContract } from './framework.contract';
+import { ResolverContract } from './resolver.contract';
+/**
+ * The function used to handle serverless requests
+ */
+export declare type ServerlessHandler<TReturn> = (...args: any[]) => TReturn;
+/**
+ * The interface that represents the contract between the handler and the real implementation
+ */
+export interface HandlerContract<TApp, TEvent, TContext, TCallback, TResponse, TReturn> {
+    /**
+     * Get the handler that will handle serverless requests
+     */
+    getHandler(app: TApp, framework: FrameworkContract<TApp>, adapters: AdapterContract<TEvent, TContext, TResponse>[], resolverFactory: ResolverContract<TEvent, TContext, TCallback, TResponse, TReturn>, binarySettings: BinarySettings, respondWithErrors: boolean, log: ILogger): ServerlessHandler<TReturn>;
+}

package/lib/contracts/handler.contract.js

@@ -0,0 +1,3 @@
+"use strict";
+//#region Imports
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/contracts/index.d.ts

@@ -0,0 +1,4 @@
+export * from './adapter.contract';
+export * from './framework.contract';
+export * from './handler.contract';
+export * from './resolver.contract';

package/lib/contracts/index.js

@@ -0,0 +1,16 @@
+"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("./adapter.contract"), exports);
+__exportStar(require("./framework.contract"), exports);
+__exportStar(require("./handler.contract"), exports);
+__exportStar(require("./resolver.contract"), exports);

package/lib/contracts/resolver.contract.d.ts

@@ -0,0 +1,70 @@
+import { ILogger } from '../core';
+import { AdapterContract } from './adapter.contract';
+/**
+ * The type that represents a resolver used to send the response, error or success, to the client
+ */
+export declare type Resolver<TResponse, TReturn> = {
+    /**
+     * The method that will perform the task of forwarding the request to the framework and waiting for the promise to be resolved with the response
+     *
+     * @param task The task to be executed
+     */
+    run(task: () => Promise<TResponse>): TReturn;
+};
+/**
+ * The type that represents a delegate resolver that is passed to the adapter to handle what to do when an error occurs during forwarding.
+ */
+export declare type DelegatedResolver<TResponse> = {
+    /**
+     * Send the success response to the client
+     *
+     * @param success The serverless response
+     */
+    succeed: (response: TResponse) => void;
+    /**
+     * Send the error response to the client
+     *
+     * @param error The error object
+     */
+    fail: (error: Error) => void;
+};
+/**
+ * The createResolver contract props
+ */
+export declare type ResolverProps<TEvent, TContext, TCallback, TResponse> = {
+    /**
+     * The event sent by the serverless environment
+     */
+    event: TEvent;
+    /**
+     * Indicates whether to forward the (error.stack) or not to the client
+     */
+    respondWithErrors: boolean;
+    /**
+     * The instance of the logger
+     */
+    log: ILogger;
+    /**
+     * The instance of the adapter
+     */
+    adapter: AdapterContract<TEvent, TContext, TResponse>;
+    /**
+     * The context sent by serverless
+     */
+    context?: TContext;
+    /**
+     * The callback sent by serverless
+     */
+    callback?: TCallback;
+};
+/**
+ * The interface that represents the contract used to send the response to the client
+ */
+export interface ResolverContract<TEvent, TContext, TCallback, TResponse, TReturn> {
+    /**
+     * Create the resolver based on the context, callback or promise
+     *
+     * @param props The props used to create the resolver
+     */
+    createResolver(props: ResolverProps<TEvent, TContext, TCallback, TResponse>): Resolver<TResponse, TReturn>;
+}

package/lib/contracts/resolver.contract.js

@@ -0,0 +1,3 @@
+"use strict";
+//#region Imports
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/core/constants.d.ts

@@ -0,0 +1,4 @@
+export declare const DEFAULT_BINARY_ENCODINGS: string[];
+export declare const DEFAULT_BINARY_CONTENT_TYPES: (string | RegExp)[];
+export declare type IEmptyResponse = {};
+export declare const EmptyResponse: IEmptyResponse;

package/lib/core/constants.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EmptyResponse = exports.DEFAULT_BINARY_CONTENT_TYPES = exports.DEFAULT_BINARY_ENCODINGS = void 0;
+exports.DEFAULT_BINARY_ENCODINGS = ['gzip', 'deflate', 'br'];
+exports.DEFAULT_BINARY_CONTENT_TYPES = [
+    new RegExp('^image/.*$'),
+    new RegExp('^video/.*$'),
+    'application/pdf',
+];
+exports.EmptyResponse = {};

package/lib/core/current-invoke.d.ts

@@ -0,0 +1,37 @@
+/**
+ * The type that represents the object that handles the references to the event created by the serverless trigger or context created by the serverless environment.
+ */
+export declare type CurrentInvoke<TEvent, TContext> = {
+    /**
+     * The event created by the serverless trigger
+     *
+     * @note It's only null when you call {@link getCurrentInvoke} outside this library's pipeline.
+     */
+    event: TEvent | null;
+    /**
+     * The context created by the serverless environment
+     *
+     * @note It's only null when you call {@link getCurrentInvoke} outside this library's pipeline.
+     */
+    context: TContext | null;
+};
+/**
+ * Get the reference to the event created by the serverless trigger or context created by the serverless environment.
+ *
+ * @example```typescript
+ * import type { ALBEvent, Context } from 'aws-lambda';
+ *
+ * // inside the method that handles the aws alb request.
+ * const { event, context } = getCurrentInvoke<ALBEvent, Context>();
+ * ```
+ */
+export declare function getCurrentInvoke<TEvent = any, TContext = any>(): CurrentInvoke<TEvent, TContext>;
+/**
+ * Method that saves to the event created by the serverless trigger or context created by the serverless environment.
+ *
+ * @note This method MUST NOT be called by you, this method MUST only be used internally in this library.
+ *
+ * @param event The event created by the serverless trigger
+ * @param context The context created by the serverless environment
+ */
+export declare function setCurrentInvoke<TEvent = any, TContext = any>({ event, context, }: CurrentInvoke<TEvent, TContext>): void;

package/lib/core/current-invoke.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setCurrentInvoke = exports.getCurrentInvoke = void 0;
+const currentInvoke = {
+    context: null,
+    event: null,
+};
+/**
+ * Get the reference to the event created by the serverless trigger or context created by the serverless environment.
+ *
+ * @example```typescript
+ * import type { ALBEvent, Context } from 'aws-lambda';
+ *
+ * // inside the method that handles the aws alb request.
+ * const { event, context } = getCurrentInvoke<ALBEvent, Context>();
+ * ```
+ */
+function getCurrentInvoke() {
+    return currentInvoke;
+}
+exports.getCurrentInvoke = getCurrentInvoke;
+/**
+ * Method that saves to the event created by the serverless trigger or context created by the serverless environment.
+ *
+ * @note This method MUST NOT be called by you, this method MUST only be used internally in this library.
+ *
+ * @param event The event created by the serverless trigger
+ * @param context The context created by the serverless environment
+ */
+function setCurrentInvoke({ event, context, }) {
+    currentInvoke.event = event;
+    currentInvoke.context = context;
+}
+exports.setCurrentInvoke = setCurrentInvoke;

package/lib/core/event-body.d.ts

@@ -0,0 +1,16 @@
+/// <reference types="node" />
+/**
+ * Get the event body as buffer from body string with content length
+ *
+ * @example```typescript
+ * const body = '{}';
+ * const [buffer, contentLength] = getEventBodyAsBuffer(body, false);
+ * console.log(buffer);
+ * // <Buffer 7b 7d>
+ * console.log(contentLength);
+ * // 2
+ *
+ * @param body The body string that can be encoded or not
+ * @param isBase64Encoded Tells if body string is encoded in base64
+ */
+export declare function getEventBodyAsBuffer(body: string, isBase64Encoded: boolean): [body: Buffer, contentLength: number];

package/lib/core/event-body.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getEventBodyAsBuffer = void 0;
+/**
+ * Get the event body as buffer from body string with content length
+ *
+ * @example```typescript
+ * const body = '{}';
+ * const [buffer, contentLength] = getEventBodyAsBuffer(body, false);
+ * console.log(buffer);
+ * // <Buffer 7b 7d>
+ * console.log(contentLength);
+ * // 2
+ *
+ * @param body The body string that can be encoded or not
+ * @param isBase64Encoded Tells if body string is encoded in base64
+ */
+function getEventBodyAsBuffer(body, isBase64Encoded) {
+    const encoding = isBase64Encoded ? 'base64' : 'utf8';
+    const buffer = Buffer.from(body, encoding);
+    const contentLength = Buffer.byteLength(buffer, encoding);
+    return [buffer, contentLength];
+}
+exports.getEventBodyAsBuffer = getEventBodyAsBuffer;

package/lib/core/headers.d.ts

@@ -0,0 +1,27 @@
+import { BothValueHeaders } from '../@types';
+/**
+ * Transform a header map and make sure the value is not an array
+ *
+ * @example```typescript
+ * const headers = { 'accept-encoding': 'gzip', 'accept-language': ['en-US', 'en;q=0.9'] };
+ * const flattenedHeaders = getFlattenedHeadersMap(headers, ',', true);
+ * console.log(flattenedHeaders);
+ * // { 'accept-encoding': 'gzip', 'accept-language': 'en-US,en;q=0.9' }
+ * ```
+ * @param headersMap The initial headers
+ * @param separator The separator used when we join the array of header's value
+ * @param lowerCaseKey Should put all keys in lowercase
+ */
+export declare function getFlattenedHeadersMap(headersMap: BothValueHeaders, separator?: string, lowerCaseKey?: boolean): Record<string, string>;
+/**
+ * Transforms a header map into a multi-value map header.
+ *
+ * @example```typescript
+ * const headers = { 'accept-encoding': 'gzip', 'connection': ['keep-alive'] };
+ * const multiValueHeaders = getMultiValueHeadersMap(headers);
+ * console.log(multiValueHeaders);
+ * // { 'accept-encoding': ['gzip'], 'connection': ['keep-alive'] }
+ * ```
+ * @param headersMap The initial headers
+ */
+export declare function getMultiValueHeadersMap(headersMap: BothValueHeaders): Record<string, string[]>;

package/lib/core/headers.js

@@ -0,0 +1,53 @@
+"use strict";
+//#region Imports
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMultiValueHeadersMap = exports.getFlattenedHeadersMap = void 0;
+//#endregion
+/**
+ * Transform a header map and make sure the value is not an array
+ *
+ * @example```typescript
+ * const headers = { 'accept-encoding': 'gzip', 'accept-language': ['en-US', 'en;q=0.9'] };
+ * const flattenedHeaders = getFlattenedHeadersMap(headers, ',', true);
+ * console.log(flattenedHeaders);
+ * // { 'accept-encoding': 'gzip', 'accept-language': 'en-US,en;q=0.9' }
+ * ```
+ * @param headersMap The initial headers
+ * @param separator The separator used when we join the array of header's value
+ * @param lowerCaseKey Should put all keys in lowercase
+ */
+function getFlattenedHeadersMap(headersMap, separator = ',', lowerCaseKey = false) {
+    const commaDelimitedHeaders = {};
+    const headersMapEntries = Object.entries(headersMap);
+    for (const [headerKey, headerValue] of headersMapEntries) {
+        const newKey = lowerCaseKey ? headerKey.toLowerCase() : headerKey;
+        if (Array.isArray(headerValue))
+            commaDelimitedHeaders[newKey] = headerValue.join(separator);
+        else
+            commaDelimitedHeaders[newKey] = headerValue || '';
+    }
+    return commaDelimitedHeaders;
+}
+exports.getFlattenedHeadersMap = getFlattenedHeadersMap;
+/**
+ * Transforms a header map into a multi-value map header.
+ *
+ * @example```typescript
+ * const headers = { 'accept-encoding': 'gzip', 'connection': ['keep-alive'] };
+ * const multiValueHeaders = getMultiValueHeadersMap(headers);
+ * console.log(multiValueHeaders);
+ * // { 'accept-encoding': ['gzip'], 'connection': ['keep-alive'] }
+ * ```
+ * @param headersMap The initial headers
+ */
+function getMultiValueHeadersMap(headersMap) {
+    const multiValueHeaders = {};
+    const headersMapEntries = Object.entries(headersMap);
+    for (const [headerKey, headerValue] of headersMapEntries) {
+        multiValueHeaders[headerKey.toLowerCase()] = Array.isArray(headerValue)
+            ? headerValue.map(String)
+            : [String(headerValue)];
+    }
+    return multiValueHeaders;
+}
+exports.getMultiValueHeadersMap = getMultiValueHeadersMap;

package/lib/core/index.d.ts

@@ -0,0 +1,10 @@
+export * from './constants';
+export * from './current-invoke';
+export * from './event-body';
+export * from './headers';
+export * from './is-binary';
+export * from './logger';
+export * from './no-op';
+export * from './optional';
+export * from './path';
+export * from './stream';

package/lib/core/index.js

@@ -0,0 +1,22 @@
+"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("./constants"), exports);
+__exportStar(require("./current-invoke"), exports);
+__exportStar(require("./event-body"), exports);
+__exportStar(require("./headers"), exports);
+__exportStar(require("./is-binary"), exports);
+__exportStar(require("./logger"), exports);
+__exportStar(require("./no-op"), exports);
+__exportStar(require("./optional"), exports);
+__exportStar(require("./path"), exports);
+__exportStar(require("./stream"), exports);