@h4ad/serverless-adapter 2.17.0 → 3.0.0

package/lib/network/request.d.ts

@@ -1,44 +0,0 @@
-/// <reference types="node" />
-/// <reference types="node" />
-import { IncomingMessage } from 'http';
-import { SingleValueHeaders } from '../@types';
-/**
- * The properties to create a {@link ServerlessRequest}
- *
- * @breadcrumb Network / ServerlessRequest
- * @public
- */
-export interface ServerlessRequestProps {
-    /**
-     * The HTTP Method of the request
-     */
-    method: string;
-    /**
-     * The URL requested
-     */
-    url: string;
-    /**
-     * The headers from the event source
-     */
-    headers: SingleValueHeaders;
-    /**
-     * The body from the event source
-     */
-    body?: Buffer | Uint8Array;
-    /**
-     * The IP Address from caller
-     */
-    remoteAddress?: string;
-}
-/**
- * The class that represents an {@link http#IncomingMessage} created by the library to represent an actual request to the framework.
- *
- * @breadcrumb Network / ServerlessRequest
- * @public
- */
-export declare class ServerlessRequest extends IncomingMessage {
-    constructor({ method, url, headers, body, remoteAddress, }: ServerlessRequestProps);
-    ip?: string;
-    body?: Buffer | Uint8Array;
-}
-export declare type __ΩServerlessRequestProps = any[];

package/lib/network/response-stream.d.ts

@@ -1,41 +0,0 @@
-/// <reference types="node" />
-/// <reference types="node" />
-import { ServerResponse } from 'http';
-import { Writable } from 'stream';
-import { BothValueHeaders } from '../@types';
-import { ILogger } from '../core';
-/**
- * The properties to create a {@link ServerlessStreamResponse}.
- *
- * @breadcrumb Network / ServerlessStreamResponse
- * @public
- */
-export interface ServerlessStreamResponseProps {
-    /**
-     * The HTTP Method from request
-     */
-    method?: string;
-    /**
-     * The callback to receive the headers when they are written to the stream
-     * You need to return a writable stream be able to continue writing the response
-     *
-     * @param statusCode - The status code of the response
-     * @param headers - The headers of the response
-     */
-    onReceiveHeaders: (statusCode: number, headers: BothValueHeaders) => Writable;
-    /**
-     * Instance of the logger
-     */
-    log: ILogger;
-}
-/**
- * The class that represents a response instance used to send to the framework and wait until the framework finishes processing the request.
- * This response is specially built to deal with transfer-encoding: chunked
- *
- * @breadcrumb Network / ServerlessStreamResponse
- * @public
- */
-export declare class ServerlessStreamResponse extends ServerResponse {
-    constructor({ method, onReceiveHeaders, log, }: ServerlessStreamResponseProps);
-}
-export declare type __ΩServerlessStreamResponseProps = any[];

package/lib/network/response.d.ts

@@ -1,48 +0,0 @@
-/// <reference types="node" />
-/// <reference types="node" />
-import { IncomingMessage, ServerResponse } from 'http';
-declare const BODY: unique symbol;
-declare const HEADERS: unique symbol;
-/**
- * The properties to create a {@link ServerlessResponse}.
- *
- * @breadcrumb Network / ServerlessResponse
- * @public
- */
-export interface ServerlessResponseProps {
-    /**
-     * The HTTP Method from request
-     */
-    method?: string;
-}
-/**
- * The class that represents a response instance used to send to the framework and wait until the framework finishes processing the request.
- * Once it's happens, we use the properties from this response to built the response to the cloud.
- *
- * @breadcrumb Network / ServerlessResponse
- * @public
- */
-export declare class ServerlessResponse extends ServerResponse {
-    constructor({ method }: ServerlessResponseProps);
-    _header: string;
-    _headers?: Record<any, any>;
-    _wroteHeader?: boolean;
-    [BODY]: any[];
-    [HEADERS]: Record<any, any>;
-    get headers(): Record<any, any>;
-    static from(res: IncomingMessage): ServerlessResponse;
-    static body(res: ServerlessResponse): Buffer;
-    static headers(res: ServerlessResponse): import("http").OutgoingHttpHeaders & Record<any, any>;
-    setHeader(key: string, value: number | string | readonly string[]): any;
-    writeHead(statusCode: number, statusMessage?: string | any | any[], obj?: any | any[]): any;
-    /**
-     * I use ignore here because in nodejs 12.x, statusMessage can be string | OutgoingHttpHeaders
-     * But in nodejs \>=14.x, statusMessage can also be OutgoingHttpHeaders[]
-     * I take care of these cases above, but here I can't handle it well, so I give up
-     * nodejs 12.x ref: https://github.com/DefinitelyTyped/DefinitelyTyped/blob/master/types/node/v12/http.d.ts#L229
-     * nodejs 14.x ref: https://github.com/DefinitelyTyped/DefinitelyTyped/blob/master/types/node/v14/http.d.ts#L263
-     */
-    protected callNativeWriteHead(statusCode: number, statusMessage?: string | any | any[], obj?: any | any[]): this;
-}
-export {};
-export declare type __ΩServerlessResponseProps = any[];

package/lib/network/utils.d.ts

@@ -1,7 +0,0 @@
-/// <reference types="node" />
-/**
- * Get the data from a buffer, string, or Uint8Array
- *
- * @param data - The data that was written inside the stream
- */
-export declare function getString(data: Buffer | string | unknown): string;

package/lib/resolvers/aws-context/aws-context.resolver.d.ts

@@ -1,18 +0,0 @@
-import type { Context } from 'aws-lambda';
-import { Resolver, ResolverContract, ResolverProps } from '../../contracts';
-/**
- * The class that implements the resolver by using the AWS Context object.
- *
- * @remarks To use this resolver, you MUST leave `{@link https://docs.aws.amazon.com/lambda/latest/dg/nodejs-context.html | callbackWaitsForEmptyEventLoop}` as true, otherwise, AWS will not wait for this resolver to resolve.
- *
- * @deprecated From the AWS Documentation, describing the functions used in this resolver: Functions for compatibility with earlier Node.js Runtime v0.10.42. No longer documented, so they are deprecated, but they still work as of the 12.x runtime, so they are not removed from the types.
- *
- * @breadcrumb Resolvers / AwsContextResolver
- * @public
- */
-export declare class AwsContextResolver<TEvent, TCallback, TResponse> implements ResolverContract<TEvent, Context, TCallback, TResponse, void> {
-    /**
-     * {@inheritDoc}
-     */
-    createResolver({ context, event, log, respondWithErrors, adapter, }: ResolverProps<any, Context, any, any>): Resolver<any, void>;
-}

package/lib/resolvers/aws-context/index.d.ts

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

package/lib/resolvers/callback/callback.resolver.d.ts

@@ -1,23 +0,0 @@
-import { Resolver, ResolverContract, ResolverProps } from '../../contracts';
-/**
- * The default signature of the callback sent by serverless
- *
- * @breadcrumb Resolvers / CallbackResolver
- * @public
- */
-export declare type ServerlessCallback<TResponse> = (error: Error | null, success: TResponse | null) => void;
-/**
- * The class that implements the resolver using the callback function sent by serverless
- *
- * @remarks To use this resolver on AWS, you MUST leave `{@link https://docs.aws.amazon.com/lambda/latest/dg/nodejs-context.html | callbackWaitsForEmptyEventLoop}` as true, otherwise, AWS will not wait for this resolver to resolve.
- *
- * @breadcrumb Resolvers / CallbackResolver
- * @public
- */
-export declare class CallbackResolver<TEvent, TContext, TResponse> implements ResolverContract<TEvent, TContext, ServerlessCallback<any>, TResponse, void> {
-    /**
-     * {@inheritDoc}
-     */
-    createResolver({ callback, event, log, respondWithErrors, adapter, }: ResolverProps<TEvent, TContext, ServerlessCallback<any>, TResponse>): Resolver<any, void>;
-}
-export declare type __ΩServerlessCallback = any[];

package/lib/resolvers/callback/index.d.ts

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

package/lib/resolvers/dummy/dummy.resolver.d.ts

@@ -1,13 +0,0 @@
-import { Resolver, ResolverContract } from '../../contracts';
-/**
- * The class that represents a dummy resolver that does nothing and can be used by the cloud that doesn't use resolvers.
- *
- * @breadcrumb Resolvers / DummyResolver
- * @public
- */
-export declare class DummyResolver implements ResolverContract<any, any, any, any, any> {
-    /**
-     * {@inheritDoc}
-     */
-    createResolver(): Resolver<any, void>;
-}

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

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

package/lib/resolvers/promise/index.d.ts

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

package/lib/resolvers/promise/promise.resolver.d.ts

@@ -1,13 +0,0 @@
-import { Resolver, ResolverContract, ResolverProps } from '../../contracts';
-/**
- * The class that implements the resolver using the promise object sent by this library
- *
- * @breadcrumb Resolvers / PromiseResolver
- * @public
- */
-export declare class PromiseResolver<TEvent, TContext, TCallback, TResponse, TReturn> implements ResolverContract<TEvent, TContext, TCallback, TResponse, Promise<any>> {
-    /**
-     * {@inheritDoc}
-     */
-    createResolver({ event, log, respondWithErrors, adapter, }: ResolverProps<TEvent, TContext, TCallback, TResponse>): Resolver<TResponse, Promise<TReturn>>;
-}

package/lib/serverless-adapter.d.ts

@@ -1,118 +0,0 @@
-import { BinarySettings } from './@types';
-import { AdapterContract, FrameworkContract, HandlerContract, ResolverContract, ServerlessHandler } from './contracts';
-import { ILogger } from './core';
-/**
- * The class used to build the serverless handler.
- *
- * @example
- * ```typescript
- * const app = express();
- * export const handler = ServerlessAdapter.new(app)
- *   .setFramework(new ExpressFramework())
- *   .setHandler(new DefaultHandler())
- *   .setResolver(new PromiseResolver())
- *   .setRespondWithErrors(true)
- *   .addAdapter(new AlbAdapter())
- *   .addAdapter(new SQSAdapter())
- *   .addAdapter(new SNSAdapter())
- *   .build();
- * ```
- *
- * @breadcrumb ServerlessAdapter
- * @public
- */
-export declare class ServerlessAdapter<TApp, TEvent, TContext, TCallback, TResponse, TReturn> {
-    /**
-     * Default constructor
-     */
-    private constructor();
-    /**
-     * The instance of the app (express, hapi, koa, etc...)
-     */
-    protected app: TApp;
-    /**
-     * Settings for whether the response should be treated as binary or not
-     *
-     * @defaultValue `contentEncodings` and `contentTypes` are set with {@link DEFAULT_BINARY_ENCODINGS} and {@link DEFAULT_BINARY_CONTENT_TYPES}, respectively.
-     */
-    protected binarySettings: BinarySettings;
-    /**
-     * Indicates whether the error stack should be included in the response or not
-     *
-     * @remarks These errors will only be included when an error occurs while forwarding the event to the framework
-     * @defaultValue True when NODE_ENV is equal to `development`
-     */
-    protected respondWithErrors: boolean;
-    /**
-     * The instance of the logger service
-     */
-    protected log: ILogger;
-    /**
-     * The list of adapters used to handle an event's request and response
-     */
-    protected adapters: AdapterContract<TEvent, TContext, TResponse>[];
-    /**
-     * The framework that will process requests
-     */
-    protected framework?: FrameworkContract<TApp>;
-    /**
-     * The resolver that aims to resolve the response to serverless and stop its execution when the request ends
-     */
-    protected resolver?: ResolverContract<TEvent, TContext, TCallback, TResponse, TReturn>;
-    /**
-     * The handler that will get the event, context and callback and pass it to the adapter and framework
-     */
-    protected handler?: HandlerContract<TApp, TEvent, TContext, TCallback, TResponse, TReturn>;
-    /**
-     * Creates a new instance of the builder with app (express, hapi, koa, etc...)
-     *
-     * @param app - The instance of the app
-     */
-    static new<TApp, TEvent, TContext = any, TCallback = any, TResponse = any, TReturn = any>(app: TApp): ServerlessAdapter<TApp, TEvent, TContext, TCallback, TResponse, TReturn>;
-    /**
-     * Defines the handler that will get the event, context and callback and pass it to the adapter and framework
-     *
-     * @param handler - The implementation of the handler contract
-     */
-    setHandler(handler: HandlerContract<TApp, TEvent, TContext, TCallback, TResponse, TReturn>): Omit<this, 'setHandler'>;
-    /**
-     * Defines the resolver that aims to resolve the response to serverless and stop its execution when the request ends
-     *
-     * @param resolver - The implementation of the resolver contract
-     */
-    setResolver(resolver: ResolverContract<TEvent, TContext, TCallback, TResponse, TReturn>): Omit<this, 'setResolver'>;
-    /**
-     * Defines the framework that will process requests
-     *
-     * @param framework - The implementation of the framework contract
-     */
-    setFramework(framework: FrameworkContract<TApp>): Omit<this, 'setFramework'>;
-    /**
-     * Defines the logger service used during the execution of the handler
-     *
-     * @param logger - The implementation of the logger
-     */
-    setLogger(logger: ILogger): Omit<this, 'setLogger'>;
-    /**
-     * Defines the binary settings for whether the response should be treated as binary or not
-     *
-     * @param binarySettings - The binary settings
-     */
-    setBinarySettings(binarySettings: BinarySettings): Omit<this, 'setBinarySettings'>;
-    /**
-     * Defines the responseWithErrors, a property that indicates whether the error stack should be included in the response or not
-     *
-     * @param respondWithErrors - Should include or not the errors in response
-     */
-    setRespondWithErrors(respondWithErrors: boolean): Omit<this, 'setRespondWithErrors'>;
-    /**
-     * Add an adapter to the adapters list to handle the event coming from any serverless event source
-     *
-     * @param adapter - The implementation of the adapter contract
-     */
-    addAdapter(adapter: AdapterContract<TEvent, TContext, TResponse>): Pick<this, 'addAdapter' | 'build'>;
-    /**
-     * The builder method that returns the handler function to be exported for serverless consumption
-     */
-    build(): ServerlessHandler<TReturn>;
-}