@h4ad/serverless-adapter 1.0.1

package/lib/core/is-binary.d.ts

@@ -0,0 +1,55 @@
+import { BinarySettings, BothValueHeaders } from '../@types';
+/**
+ * The function that determines by the content encoding whether the response should be treated as binary
+ *
+ * @example```typescript
+ * const headers = { 'Content-Encoding': 'gzip' };
+ * const isBinary = isContentEncodingBinary(headers, ['gzip']);
+ * console.log(isBinary);
+ * // true
+ * ```
+ *
+ * @param headers The headers of the response
+ * @param binaryEncodingTypes The list of content encodings that will be treated as binary
+ */
+export declare function isContentEncodingBinary(headers: BothValueHeaders, binaryEncodingTypes: string[]): boolean;
+/**
+ * The function that returns the content type of headers
+ *
+ * @example```typescript
+ * const headers = { 'Content-Type': 'application/json' };
+ * const contentType = getContentType(headers);
+ * console.log(contentType);
+ * // application/json
+ * ```
+ *
+ * @param headers The headers of the response
+ */
+export declare function getContentType(headers: BothValueHeaders): string;
+/**
+ * The function that determines by the content type whether the response should be treated as binary
+ *
+ * @example```typescript
+ * const headers = { 'Content-Type': 'image/png' };
+ * const isBinary = isContentTypeBinary(headers, [new RegExp('^image/.*$')]);
+ * console.log(isBinary);
+ * // true
+ * ```
+ *
+ * @param headers The headers of the response
+ * @param binaryContentTypes The list of content types that will be treated as binary
+ */
+export declare function isContentTypeBinary(headers: BothValueHeaders, binaryContentTypes: (string | RegExp)[]): boolean;
+/**
+ * The function used to determine from the headers and the binary settings if a response should be encoded or not
+ *
+ * @example```typescript
+ * const headers = { 'Content-Type': 'image/png', 'Content-Encoding': 'gzip' };
+ * const isContentBinary = isBinary(headers, { contentEncodings: ['gzip'], contentTypes: [new RegExp('^image/.*$')] });
+ * console.log(isContentBinary);
+ * // true
+ *
+ * @param headers The headers of the response
+ * @param binarySettings The settings for the validation
+ */
+export declare function isBinary(headers: BothValueHeaders, binarySettings: BinarySettings): boolean;

package/lib/core/is-binary.js

@@ -0,0 +1,91 @@
+"use strict";
+// ATTRIBUTION: https://github.com/dougmoscrop/serverless-http
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isBinary = exports.isContentTypeBinary = exports.getContentType = exports.isContentEncodingBinary = void 0;
+const headers_1 = require("./headers");
+//#endregion
+/**
+ * The function that determines by the content encoding whether the response should be treated as binary
+ *
+ * @example```typescript
+ * const headers = { 'Content-Encoding': 'gzip' };
+ * const isBinary = isContentEncodingBinary(headers, ['gzip']);
+ * console.log(isBinary);
+ * // true
+ * ```
+ *
+ * @param headers The headers of the response
+ * @param binaryEncodingTypes The list of content encodings that will be treated as binary
+ */
+function isContentEncodingBinary(headers, binaryEncodingTypes) {
+    const multiValueHeaders = (0, headers_1.getMultiValueHeadersMap)(headers);
+    const contentEncodings = multiValueHeaders['content-encoding'];
+    if (!Array.isArray(contentEncodings))
+        return false;
+    return contentEncodings.some(value => binaryEncodingTypes.some(binaryEncoding => value.includes(binaryEncoding)));
+}
+exports.isContentEncodingBinary = isContentEncodingBinary;
+/**
+ * The function that returns the content type of headers
+ *
+ * @example```typescript
+ * const headers = { 'Content-Type': 'application/json' };
+ * const contentType = getContentType(headers);
+ * console.log(contentType);
+ * // application/json
+ * ```
+ *
+ * @param headers The headers of the response
+ */
+function getContentType(headers) {
+    const flattenedHeaders = (0, headers_1.getFlattenedHeadersMap)(headers, ';', true);
+    const contentTypeHeader = flattenedHeaders['content-type'] || '';
+    // only compare mime type; ignore encoding part
+    return contentTypeHeader.split(';')[0];
+}
+exports.getContentType = getContentType;
+/**
+ * The function that determines by the content type whether the response should be treated as binary
+ *
+ * @example```typescript
+ * const headers = { 'Content-Type': 'image/png' };
+ * const isBinary = isContentTypeBinary(headers, [new RegExp('^image/.*$')]);
+ * console.log(isBinary);
+ * // true
+ * ```
+ *
+ * @param headers The headers of the response
+ * @param binaryContentTypes The list of content types that will be treated as binary
+ */
+function isContentTypeBinary(headers, binaryContentTypes) {
+    const binaryContentTypesRegexes = binaryContentTypes.map(binaryContentType => binaryContentType instanceof RegExp
+        ? binaryContentType
+        : new RegExp(`${binaryContentType}`));
+    const contentType = getContentType(headers);
+    if (!contentType)
+        return false;
+    return binaryContentTypesRegexes.some(binaryContentType => binaryContentType.test(contentType));
+}
+exports.isContentTypeBinary = isContentTypeBinary;
+/**
+ * The function used to determine from the headers and the binary settings if a response should be encoded or not
+ *
+ * @example```typescript
+ * const headers = { 'Content-Type': 'image/png', 'Content-Encoding': 'gzip' };
+ * const isContentBinary = isBinary(headers, { contentEncodings: ['gzip'], contentTypes: [new RegExp('^image/.*$')] });
+ * console.log(isContentBinary);
+ * // true
+ *
+ * @param headers The headers of the response
+ * @param binarySettings The settings for the validation
+ */
+function isBinary(headers, binarySettings) {
+    if ('isBinary' in binarySettings) {
+        if (binarySettings.isBinary === false)
+            return false;
+        return binarySettings.isBinary(headers);
+    }
+    return (isContentEncodingBinary(headers, binarySettings.contentEncodings) ||
+        isContentTypeBinary(headers, binarySettings.contentTypes));
+}
+exports.isBinary = isBinary;

package/lib/core/logger.d.ts

@@ -0,0 +1,38 @@
+/**
+ * The type representing the possible log levels to choose from.
+ */
+export declare type LogLevels = 'debug' | 'verbose' | 'info' | 'warn' | 'error' | 'none';
+/**
+ * The options to customize {@link ILogger}
+ */
+export declare type LoggerOptions = {
+    /**
+     * Select the log level, {@link LogLevels see more}.
+     *
+     * @default error
+     */
+    level: LogLevels;
+};
+/**
+ * The log function used in any level.
+ */
+export declare type LoggerFN = (message: any, ...additional: any[]) => void;
+/**
+ * The interface representing the logger, you can provide a custom logger by implementing this interface.
+ */
+export declare type ILogger = Record<Exclude<LogLevels, 'none'>, LoggerFN>;
+/**
+ * The method used to create a simple logger instance to use in this library.
+ *
+ * @note Behind the scenes, this simple logger sends the message to the `console` methods.
+ *
+ * @example```typescript
+ * const logger = createDefaultLogger();
+ *
+ * logger.error('An error happens.');
+ * // An error happens.
+ * ```
+ *
+ * @param level Select the level of the log
+ */
+export declare function createDefaultLogger({ level }?: LoggerOptions): ILogger;

package/lib/core/logger.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDefaultLogger = void 0;
+/**
+ * The method used to create a simple logger instance to use in this library.
+ *
+ * @note Behind the scenes, this simple logger sends the message to the `console` methods.
+ *
+ * @example```typescript
+ * const logger = createDefaultLogger();
+ *
+ * logger.error('An error happens.');
+ * // An error happens.
+ * ```
+ *
+ * @param level Select the level of the log
+ */
+function createDefaultLogger({ level } = { level: 'error' }) {
+    const errorLogLevel = ['debug', 'verbose', 'info', 'warn', 'error'];
+    const warnLogLevel = ['debug', 'verbose', 'info', 'warn'];
+    const infoLogLevel = ['debug', 'verbose', 'info'];
+    const verboseLogLevel = ['debug', 'verbose'];
+    return {
+        error: (message, ...additional) => {
+            if (!errorLogLevel.includes(level))
+                return;
+            console.error(message, ...additional);
+        },
+        warn: (message, ...additional) => {
+            if (!warnLogLevel.includes(level))
+                return;
+            console.warn(message, ...additional);
+        },
+        info: (message, ...additional) => {
+            if (!infoLogLevel.includes(level))
+                return;
+            console.info(message, ...additional);
+        },
+        verbose: (message, ...additional) => {
+            if (!verboseLogLevel.includes(level))
+                return;
+            console.debug(message, ...additional);
+        },
+        debug: (message, ...additional) => {
+            if (level !== 'debug')
+                return;
+            console.debug(message, ...additional);
+        },
+    };
+}
+exports.createDefaultLogger = createDefaultLogger;

package/lib/core/no-op.d.ts

@@ -0,0 +1,4 @@
+/**
+ * No operation function is used when we need to pass a function, but we don't want to specify any behavior.
+ */
+export declare const NO_OP: (...args: any[]) => any;

package/lib/core/no-op.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NO_OP = void 0;
+/**
+ * No operation function is used when we need to pass a function, but we don't want to specify any behavior.
+ */
+const NO_OP = () => void 0;
+exports.NO_OP = NO_OP;

package/lib/core/optional.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Return the defaultValue whether the value is undefined, otherwise, return the value.
+ *
+ * @example```typescript
+ * const value1 = getDefaultIfUndefined(undefined, true);
+ * const value2 = getDefaultIfUndefined(false, true);
+ *
+ * console.log(value1);
+ * // true
+ * console.log(value2);
+ * // false
+ * ```
+ *
+ * @param value The value to be checked
+ * @param defaultValue The default value when value is undefined
+ */
+export declare function getDefaultIfUndefined<T>(value: T | undefined, defaultValue: T): T;

package/lib/core/optional.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDefaultIfUndefined = void 0;
+/**
+ * Return the defaultValue whether the value is undefined, otherwise, return the value.
+ *
+ * @example```typescript
+ * const value1 = getDefaultIfUndefined(undefined, true);
+ * const value2 = getDefaultIfUndefined(false, true);
+ *
+ * console.log(value1);
+ * // true
+ * console.log(value2);
+ * // false
+ * ```
+ *
+ * @param value The value to be checked
+ * @param defaultValue The default value when value is undefined
+ */
+function getDefaultIfUndefined(value, defaultValue) {
+    if (typeof value === 'undefined')
+        return defaultValue;
+    return value;
+}
+exports.getDefaultIfUndefined = getDefaultIfUndefined;

package/lib/core/path.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Transform the path and a map of query params to a string with formatted query params
+ *
+ * @example```typescript
+ * const path = '/pets/search';
+ * const queryParams = { batata: undefined, petType: [ 'dog', 'fish' ] };
+ * const result = getPathWithQueryStringParams(path, queryParams);
+ * console.log(result);
+ * // /pets/search?batata=&petType=dog&petType=fish
+ * ```
+ *
+ * @param path The path
+ * @param queryParams The query params
+ */
+export declare function getPathWithQueryStringParams(path: string, queryParams: string | Record<string, string | string[] | undefined> | undefined | null): string;
+/**
+ * Map query params to a string with formatted query params
+ *
+ * @example```typescript
+ * const queryParams = { batata: undefined, petType: [ 'dog', 'fish' ] };
+ * const result = getQueryParamsStringFromRecord(queryParams);
+ * console.log(result);
+ * // batata=&petType=dog&petType=fish
+ * ```
+ *
+ * @param queryParamsRecord The query params record
+ */
+export declare function getQueryParamsStringFromRecord(queryParamsRecord: Record<string, string | string[] | undefined> | undefined | null): string;

package/lib/core/path.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getQueryParamsStringFromRecord = exports.getPathWithQueryStringParams = void 0;
+/**
+ * Transform the path and a map of query params to a string with formatted query params
+ *
+ * @example```typescript
+ * const path = '/pets/search';
+ * const queryParams = { batata: undefined, petType: [ 'dog', 'fish' ] };
+ * const result = getPathWithQueryStringParams(path, queryParams);
+ * console.log(result);
+ * // /pets/search?batata=&petType=dog&petType=fish
+ * ```
+ *
+ * @param path The path
+ * @param queryParams The query params
+ */
+function getPathWithQueryStringParams(path, queryParams) {
+    if (String(queryParams || '').length === 0)
+        return path;
+    if (typeof queryParams === 'string')
+        return `${path}?${queryParams}`;
+    const queryParamsString = getQueryParamsStringFromRecord(queryParams);
+    if (!queryParamsString)
+        return path;
+    return `${path}?${queryParamsString}`;
+}
+exports.getPathWithQueryStringParams = getPathWithQueryStringParams;
+/**
+ * Map query params to a string with formatted query params
+ *
+ * @example```typescript
+ * const queryParams = { batata: undefined, petType: [ 'dog', 'fish' ] };
+ * const result = getQueryParamsStringFromRecord(queryParams);
+ * console.log(result);
+ * // batata=&petType=dog&petType=fish
+ * ```
+ *
+ * @param queryParamsRecord The query params record
+ */
+function getQueryParamsStringFromRecord(queryParamsRecord) {
+    const searchParams = new URLSearchParams();
+    const multiValueHeadersEntries = Object.entries(queryParamsRecord || {});
+    if (multiValueHeadersEntries.length === 0)
+        return '';
+    for (const [key, value] of multiValueHeadersEntries) {
+        if (!Array.isArray(value)) {
+            searchParams.append(key, value || '');
+            continue;
+        }
+        for (const arrayValue of value)
+            searchParams.append(key, arrayValue);
+    }
+    return searchParams.toString();
+}
+exports.getQueryParamsStringFromRecord = getQueryParamsStringFromRecord;

package/lib/core/stream.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="node" />
+import { Readable, Writable } from 'stream';
+/**
+ * Wait asynchronous the stream to complete
+ *
+ * @param stream The stream
+ */
+export declare function waitForStreamComplete<TStream extends Readable | Writable>(stream: TStream): Promise<TStream>;

package/lib/core/stream.js

@@ -0,0 +1,39 @@
+"use strict";
+//#region Imports
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.waitForStreamComplete = void 0;
+//#endregion
+/**
+ * Wait asynchronous the stream to complete
+ *
+ * @param stream The stream
+ */
+function waitForStreamComplete(stream) {
+    if ('readableEnded' in stream && stream.readableEnded)
+        return Promise.resolve(stream);
+    if ('writableEnded' in stream && stream.writableEnded)
+        return Promise.resolve(stream);
+    return new Promise((resolve, reject) => {
+        // Reading the {@link https://github.com/nodejs/node/blob/v12.22.9/lib/events.js#L262 emit source code},
+        // it's almost impossible to complete being called twice because the emit function runs synchronously and removes the other listeners,
+        // but I'll leave it at that because I didn't write that code, so I couldn't figure out what the author thought when he wrote this.
+        let isComplete = false;
+        function complete(err) {
+            /* istanbul ignore next */
+            if (isComplete)
+                return;
+            isComplete = true;
+            stream.removeListener('error', complete);
+            stream.removeListener('end', complete);
+            stream.removeListener('finish', complete);
+            if (err)
+                reject(err);
+            else
+                resolve(stream);
+        }
+        stream.once('error', complete);
+        stream.once('end', complete);
+        stream.once('finish', complete);
+    });
+}
+exports.waitForStreamComplete = waitForStreamComplete;

package/lib/frameworks/express.framework.d.ts

@@ -0,0 +1,13 @@
+/// <reference types="node" />
+import { IncomingMessage, ServerResponse } from 'http';
+import type { Express } from 'express';
+import { FrameworkContract } from '../contracts';
+/**
+ * The framework that forwards requests to express handler
+ */
+export declare class ExpressFramework implements FrameworkContract<Express> {
+    /**
+     * @inheritDoc
+     */
+    sendRequest(app: Express, request: IncomingMessage, response: ServerResponse): void;
+}

package/lib/frameworks/express.framework.js

@@ -0,0 +1,17 @@
+"use strict";
+//#region
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExpressFramework = void 0;
+//#endregion
+/**
+ * The framework that forwards requests to express handler
+ */
+class ExpressFramework {
+    /**
+     * @inheritDoc
+     */
+    sendRequest(app, request, response) {
+        app(request, response);
+    }
+}
+exports.ExpressFramework = ExpressFramework;

package/lib/frameworks/fastify.framework.d.ts

@@ -0,0 +1,13 @@
+/// <reference types="node" />
+import { IncomingMessage, ServerResponse } from 'http';
+import type { FastifyInstance } from 'fastify';
+import { FrameworkContract } from '../contracts';
+/**
+ * The framework that forwards requests to fastify handler
+ */
+export declare class FastifyFramework implements FrameworkContract<FastifyInstance> {
+    /**
+     * @inheritDoc
+     */
+    sendRequest(app: FastifyInstance, request: IncomingMessage, response: ServerResponse): void;
+}

package/lib/frameworks/fastify.framework.js

@@ -0,0 +1,18 @@
+"use strict";
+//#region Imports
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FastifyFramework = void 0;
+//#endregion
+/**
+ * The framework that forwards requests to fastify handler
+ */
+class FastifyFramework {
+    /**
+     * @inheritDoc
+     */
+    sendRequest(app, request, response) {
+        // ref: https://www.fastify.io/docs/latest/Guides/Serverless/#implement-and-export-the-function
+        app.ready().then(() => app.server.emit('request', request, response));
+    }
+}
+exports.FastifyFramework = FastifyFramework;

package/lib/frameworks/hapi.framework.d.ts

@@ -0,0 +1,13 @@
+/// <reference types="node" />
+import { IncomingMessage, ServerResponse } from 'http';
+import type { Server } from 'hapi';
+import { FrameworkContract } from '../contracts';
+/**
+ * The framework that forwards requests to hapi handler
+ */
+export declare class HapiFramework implements FrameworkContract<Server> {
+    /**
+     * @inheritDoc
+     */
+    sendRequest(app: Server, request: IncomingMessage, response: ServerResponse): void;
+}

package/lib/frameworks/hapi.framework.js

@@ -0,0 +1,18 @@
+"use strict";
+//#region Imports
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HapiFramework = void 0;
+//#endregion
+/**
+ * The framework that forwards requests to hapi handler
+ */
+class HapiFramework {
+    /**
+     * @inheritDoc
+     */
+    sendRequest(app, request, response) {
+        const httpServer = app.listener;
+        httpServer._events.request(request, response);
+    }
+}
+exports.HapiFramework = HapiFramework;

package/lib/frameworks/index.d.ts

@@ -0,0 +1,4 @@
+export * from './express.framework';
+export * from './fastify.framework';
+export * from './hapi.framework';
+export * from './koa.framework';

package/lib/frameworks/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("./express.framework"), exports);
+__exportStar(require("./fastify.framework"), exports);
+__exportStar(require("./hapi.framework"), exports);
+__exportStar(require("./koa.framework"), exports);

package/lib/frameworks/koa.framework.d.ts

@@ -0,0 +1,13 @@
+/// <reference types="node" />
+import { IncomingMessage, ServerResponse } from 'http';
+import type Application from 'koa';
+import { FrameworkContract } from '../contracts';
+/**
+ * The framework that forwards requests to koa handler
+ */
+export declare class KoaFramework implements FrameworkContract<Application> {
+    /**
+     * @inheritDoc
+     */
+    sendRequest(app: Application, request: IncomingMessage, response: ServerResponse): void;
+}

package/lib/frameworks/koa.framework.js

@@ -0,0 +1,17 @@
+"use strict";
+//#region Imports
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KoaFramework = void 0;
+//#endregion
+/**
+ * The framework that forwards requests to koa handler
+ */
+class KoaFramework {
+    /**
+     * @inheritDoc
+     */
+    sendRequest(app, request, response) {
+        app.callback()(request, response);
+    }
+}
+exports.KoaFramework = KoaFramework;

package/lib/handlers/base/base.handler.d.ts

@@ -0,0 +1,28 @@
+import { BinarySettings } from '../../@types';
+import { AdapterContract, AdapterRequest, FrameworkContract, HandlerContract, ResolverContract, ServerlessHandler } from '../../contracts';
+import { ILogger } from '../../core';
+import { ServerlessRequest, ServerlessResponse } from '../../network';
+/**
+ * The abstract class that represents the base class for a handler
+ */
+export declare abstract class BaseHandler<TApp, TEvent, TContext, TCallback, TResponse, TReturn> implements HandlerContract<TApp, TEvent, TContext, TCallback, TResponse, TReturn> {
+    /**
+     * Get the handler that will handle serverless requests
+     */
+    abstract 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>;
+    /**
+     * Get the adapter to handle a specific event and context
+     *
+     * @param event The event sent by serverless
+     * @param context The context sent by serverless
+     * @param adapters The list of adapters
+     * @param log The instance of logger
+     */
+    protected getAdapterByEventAndContext(event: TEvent, context: TContext, adapters: AdapterContract<TEvent, TContext, TResponse>[], log: ILogger): AdapterContract<TEvent, TContext, TResponse>;
+    /**
+     * Get serverless request and response frmo the adapter request
+     *
+     * @param requestValues The request values from adapter
+     */
+    protected getServerlessRequestResponseFromAdapterRequest(requestValues: AdapterRequest): [request: ServerlessRequest, response: ServerlessResponse];
+}