@h4ad/serverless-adapter 2.17.0 → 3.0.0

package/lib/adapters/dummy/dummy.adapter.d.ts

@@ -1,30 +0,0 @@
-import { AdapterContract, AdapterRequest, OnErrorProps } from '../../contracts';
-import { IEmptyResponse } from '../../core';
-/**
- * The class that represents a dummy adapter that does nothing and can be used by the cloud that doesn't use adapters.
- *
- * @breadcrumb Adapters / DummyAdapter
- * @public
- */
-export declare class DummyAdapter implements AdapterContract<any, any, void> {
-    /**
-     * {@inheritDoc}
-     */
-    canHandle(): boolean;
-    /**
-     * {@inheritDoc}
-     */
-    getAdapterName(): string;
-    /**
-     * {@inheritDoc}
-     */
-    getRequest(): AdapterRequest;
-    /**
-     * {@inheritDoc}
-     */
-    getResponse(): IEmptyResponse;
-    /**
-     * {@inheritDoc}
-     */
-    onErrorWhileForwarding(props: OnErrorProps<any, void>): void;
-}

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

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

package/lib/adapters/huawei/huawei-api-gateway.adapter.d.ts

@@ -1,66 +0,0 @@
-import { HuaweiApiGatewayEvent, HuaweiApiGatewayResponse, HuaweiContext } from '../../@types/huawei';
-import { AdapterContract, AdapterRequest, GetResponseAdapterProps, OnErrorProps } from '../../contracts';
-/**
- * The options to customize the {@link HuaweiApiGatewayAdapter}
- *
- * @breadcrumb Adapters / Huawei / HuaweiApiGatewayAdapter
- * @public
- */
-export interface HuaweiApiGatewayOptions {
-    /**
-     * Strip base path for custom domains
-     *
-     * @defaultValue ''
-     */
-    stripBasePath?: string;
-}
-/**
- * The adapter to handle requests from Huawei Api Gateway
- *
- * @example
- * ```typescript
- * const stripBasePath = '/any/custom/base/path'; // default ''
- * const adapter = new ApiGatewayAdapter({ stripBasePath });
- * ```
- *
- * @breadcrumb Adapters / Huawei / HuaweiApiGatewayAdapter
- * @public
- *
- * {@link https://support.huaweicloud.com/intl/en-us/devg-functiongraph/functiongraph_02_0102.html#functiongraph_02_0102__li5178638110137 | Event Reference}
- */
-export declare class HuaweiApiGatewayAdapter implements AdapterContract<HuaweiApiGatewayEvent, HuaweiContext, HuaweiApiGatewayResponse> {
-    protected readonly options?: HuaweiApiGatewayOptions | undefined;
-    /**
-     * Default constructor
-     *
-     * @param options - The options to customize the {@link HuaweiApiGatewayAdapter}
-     */
-    constructor(options?: HuaweiApiGatewayOptions | undefined);
-    /**
-     * {@inheritDoc}
-     */
-    getAdapterName(): string;
-    /**
-     * {@inheritDoc}
-     */
-    canHandle(event: unknown): event is HuaweiApiGatewayEvent;
-    /**
-     * {@inheritDoc}
-     */
-    getRequest(event: HuaweiApiGatewayEvent): AdapterRequest;
-    /**
-     * {@inheritDoc}
-     */
-    getResponse({ headers: responseHeaders, body, isBase64Encoded, statusCode, }: GetResponseAdapterProps<HuaweiApiGatewayEvent>): HuaweiApiGatewayResponse;
-    /**
-     * {@inheritDoc}
-     */
-    onErrorWhileForwarding({ error, delegatedResolver, respondWithErrors, event, log, }: OnErrorProps<HuaweiApiGatewayEvent, HuaweiApiGatewayResponse>): void;
-    /**
-     * Get path from event with query strings
-     *
-     * @param event - The event sent by serverless
-     */
-    protected getPathFromEvent(event: HuaweiApiGatewayEvent): string;
-}
-export declare type __ΩHuaweiApiGatewayOptions = any[];

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

@@ -1 +0,0 @@
-export * from './huawei-api-gateway.adapter';

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

@@ -1,155 +0,0 @@
-/// <reference types="node" />
-import { BothValueHeaders, SingleValueHeaders } from '../@types';
-import { ILogger } from '../core';
-import { ServerlessResponse } from '../network';
-import { DelegatedResolver } from './resolver.contract';
-/**
- * The request interface used to bridge any event source to the framework.
- *
- * @breadcrumb Contracts / AdapterContract
- * @public
- */
-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;
-    /**
-     * 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)
-     *
-     * @deprecated It is no longer used in the library and will be removed in the next major release.
-     */
-    host?: string;
-    /**
-     * The address of the event source (used in Lambda\@edge)
-     *
-     * @deprecated It is no longer used in the library and will be removed in the next major release.
-     */
-    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
- *
- * @breadcrumb Contracts / AdapterContract
- * @public
- */
-export interface GetResponseAdapterProps<TEvent> {
-    /**
-     * The event sent by the serverless
-     */
-    event: TEvent;
-    /**
-     * The framework {@link ServerlessResponse | response}.
-     *
-     * @remarks 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
- *
- * @breadcrumb Contracts / AdapterContract
- * @public
- */
-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.
- *
- * @breadcrumb Contracts / AdapterContract
- * @public
- */
-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
-     *
-     * @remarks You must call resolver.fail or resolver.succeed when implementing this method.
-     */
-    onErrorWhileForwarding(props: OnErrorProps<TEvent, TResponse>): void;
-}
-export declare type __ΩAdapterRequest = any[];
-export declare type __ΩGetResponseAdapterProps = any[];
-export declare type __ΩOnErrorProps = any[];
-export declare type __ΩAdapterContract = any[];

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

@@ -1,19 +0,0 @@
-/// <reference types="node" />
-import { IncomingMessage, ServerResponse } from 'http';
-/**
- * The interface that represents a contract between the framework and the framework implementation
- *
- * @breadcrumb Contracts
- * @public
- */
-export interface FrameworkContract<TApp> {
-    /**
-     * Send the request and response objects to the framework
-     *
-     * @param app - The instance of your app (Express, Fastify, Koa, etc...)
-     * @param request - The request object that will be forward to your app
-     * @param response - The response object that will be forward to your app to output the response
-     */
-    sendRequest(app: TApp, request: IncomingMessage, response: ServerResponse): void;
-}
-export declare type __ΩFrameworkContract = any[];

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

@@ -1,26 +0,0 @@
-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
- *
- * @breadcrumb Contracts / HandlerContract
- * @public
- */
-export declare type ServerlessHandler<TReturn> = (...args: any[]) => TReturn;
-/**
- * The interface that represents the contract between the handler and the real implementation
- *
- * @breadcrumb Contracts / HandlerContract
- * @public
- */
-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>;
-}
-export declare type __ΩServerlessHandler = any[];
-export declare type __ΩHandlerContract = any[];

package/lib/contracts/index.d.ts

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

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

@@ -1,86 +0,0 @@
-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
- *
- * @breadcrumb Contracts / ResolverContract
- * @public
- */
-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.
- *
- * @breadcrumb Contracts / ResolverContract
- * @public
- */
-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
- *
- * @breadcrumb Contracts / ResolverContract
- * @public
- */
-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
- *
- * @breadcrumb Contracts / ResolverContract
- * @public
- */
-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>;
-}
-export declare type __ΩResolver = any[];
-export declare type __ΩDelegatedResolver = any[];
-export declare type __ΩResolverProps = any[];
-export declare type __ΩResolverContract = any[];

package/lib/core/base-handler.d.ts

@@ -1,31 +0,0 @@
-import { BinarySettings } from '../@types';
-import { AdapterContract, AdapterRequest, FrameworkContract, HandlerContract, ResolverContract, ServerlessHandler } from '../contracts';
-import { ServerlessRequest, ServerlessResponse } from '../network';
-import { ILogger } from './index';
-/**
- * The abstract class that represents the base class for a handler
- *
- * @breadcrumb Core
- * @public
- */
-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];
-}

package/lib/core/constants.d.ts

@@ -1,31 +0,0 @@
-/**
- * Default encodings that are treated as binary, they are compared with the `Content-Encoding` header.
- *
- * @breadcrumb Core / Constants
- * @defaultValue ['gzip', 'deflate', 'br']
- * @public
- */
-export declare const DEFAULT_BINARY_ENCODINGS: string[];
-/**
- * Default content types that are treated as binary, they are compared with the `Content-Type` header.
- *
- * @breadcrumb Core / Constants
- * @defaultValue [new RegExp('^image/.*$'), new RegExp('^video/.*$'), 'application/pdf']
- * @public
- */
-export declare const DEFAULT_BINARY_CONTENT_TYPES: (string | RegExp)[];
-/**
- * Type alias for empty response and can be used on some adapters when the adapter does not need to return a response.
- *
- * @breadcrumb Core / Constants
- * @public
- */
-export declare type IEmptyResponse = {};
-/**
- * Constant for empty response and can be used on some adapters when the adapter does not need to return a response.
- *
- * @breadcrumb Core / Constants
- * @public
- */
-export declare const EmptyResponse: IEmptyResponse;
-export declare type __ΩIEmptyResponse = any[];

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

@@ -1,48 +0,0 @@
-/**
- * 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.
- *
- * @breadcrumb Core / Current Invoke
- * @public
- */
-export declare type CurrentInvoke<TEvent, TContext> = {
-    /**
-     * The event created by the serverless trigger
-     *
-     * @remarks It's only null when you call {@link getCurrentInvoke} outside this library's pipeline.
-     */
-    event: TEvent | null;
-    /**
-     * The context created by the serverless environment
-     *
-     * @remarks 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>();
- * ```
- *
- * @breadcrumb Core / Current Invoke
- * @public
- */
-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.
- *
- * @remarks 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
- *
- * @breadcrumb Core / Current Invoke
- * @public
- */
-export declare function setCurrentInvoke<TEvent = any, TContext = any>({ event, context, }: CurrentInvoke<TEvent, TContext>): void;
-export declare type __ΩCurrentInvoke = any[];

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

@@ -1,21 +0,0 @@
-/// <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
- *
- * @breadcrumb Core
- * @public
- */
-export declare function getEventBodyAsBuffer(body: string, isBase64Encoded: boolean): [body: Buffer, contentLength: number];

package/lib/core/headers.d.ts

@@ -1,47 +0,0 @@
-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
- *
- * @breadcrumb Core / Headers
- * @public
- */
-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
- *
- * @breadcrumb Core / Headers
- * @public
- */
-export declare function getMultiValueHeadersMap(headersMap: BothValueHeaders): Record<string, string[]>;
-/**
- * Parse HTTP Raw Headers
- * Attribution to {@link https://github.com/kesla/parse-headers/blob/master/parse-headers.js}
- *
- * @param headers - The raw headers
- *
- * @breadcrumb Core / Headers
- * @public
- */
-export declare function parseHeaders(headers: string): Record<string, string | string[]>;

package/lib/core/index.d.ts

@@ -1,11 +0,0 @@
-export * from './base-handler';
-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/is-binary.d.ts

@@ -1,72 +0,0 @@
-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
- *
- * @breadcrumb Core / isBinary
- * @public
- */
-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
- *
- * @breadcrumb Core / isBinary
- * @public
- */
-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
- *
- * @breadcrumb Core / isBinary
- * @public
- */
-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
- *
- * @breadcrumb Core / isBinary
- * @public
- */
-export declare function isBinary(headers: BothValueHeaders, binarySettings: BinarySettings): boolean;