@h4ad/serverless-adapter 2.16.0 → 3.0.0

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

@@ -1,55 +0,0 @@
-/// <reference types="node" />
-import { IncomingMessage, ServerResponse } from 'http';
-import { FrameworkContract } from '../../contracts';
-import { ILogger } from '../../core';
-/**
- * The framework that asynchronously instantiates your application and forwards the request to the framework as quickly as possible.
- *
- * @example
- * ```typescript
- * import express from 'express';
- * import { ServerlessAdapter } from '@h4ad/serverless-adapter';
- * import { ExpressFramework } from '@h4ad/serverless-adapter/lib/frameworks/express';
- * import { LazyFramework } from '@h4ad/serverless-adapter/lib/frameworks/lazy';
- *
- * const expressFramework = new ExpressFramework();
- * const factory = async () => {
- *   const app = express();
- *
- *   // do some asynchronous stuffs like create the database;
- *   await new Promise(resolve => setTimeout(resolve, 100);
- *
- *   return app;
- * };
- * const framework = new LazyFramework(expressFramework, factory);
- *
- * export const handler = ServerlessAdapter.new(null)
- *   .setFramework(framework)
- *   // set other configurations and then build
- *   .build();
- * ```
- *
- * @breadcrumb Frameworks / LazyFramework
- * @public
- */
-export declare class LazyFramework<TApp> implements FrameworkContract<null> {
-    protected readonly framework: FrameworkContract<TApp>;
-    protected readonly factory: () => Promise<TApp>;
-    protected readonly logger: ILogger;
-    /**
-     * Default Constructor
-     */
-    constructor(framework: FrameworkContract<TApp>, factory: () => Promise<TApp>, logger?: ILogger);
-    /**
-     * The cached version of the app
-     */
-    protected cachedApp?: TApp;
-    /**
-     * The delayed factory to create an instance of the app
-     */
-    protected readonly delayedFactory: Promise<void>;
-    /**
-     * {@inheritDoc}
-     */
-    sendRequest(app: null, request: IncomingMessage, response: ServerResponse): void;
-}

package/lib/frameworks/trpc/index.d.ts

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

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

@@ -1,154 +0,0 @@
-/// <reference types="node" />
-import { IncomingMessage, ServerResponse } from 'http';
-import type { AnyRouter, DataTransformer } from '@trpc/server';
-import { NodeHTTPCreateContextFnOptions, NodeHTTPHandlerOptions } from '@trpc/server/adapters/node-http';
-import { SingleValueHeaders } from '../../@types';
-import { FrameworkContract } from '../../contracts';
-/**
- * The transformer that is responsible to transform buffer's input to javascript objects
- *
- * @breadcrumb Frameworks / TrpcFramework
- * @public
- */
-export declare class BufferToJSObjectTransformer implements DataTransformer {
-    /**
-     * Deserialize unknown values to javascript objects
-     *
-     * @param value - The value to be deserialized
-     */
-    deserialize(value?: unknown): any;
-    /**
-     * The value to be serialized, do nothing because tRPC can handle.
-     *
-     * @param value - The value to be serialized
-     */
-    serialize(value: any): any;
-}
-/**
- * The context created by this library that allows getting some information from the request and setting the status and header of the response.
- *
- * @breadcrumb Frameworks / TrpcFramework
- * @public
- */
-export interface TrpcAdapterBaseContext {
-    /**
-     * The request object that will be forward to your app
-     */
-    request: IncomingMessage;
-    /**
-     * The response object that will be forward to your app to output the response
-     */
-    response: ServerResponse;
-    /**
-     * The method to set response status.
-     *
-     * @param statusCode - The response status that you want
-     */
-    setStatus(statusCode: number): void;
-    /**
-     * The method to set some header in the response
-     *
-     * @param name - The name of the header
-     * @param value - The value to be set in the header
-     */
-    setHeader(name: string, value: number | string): void;
-    /**
-     * The method to remove some header from the response
-     *
-     * @param name - The name of the header
-     */
-    removeHeader(name: string): void;
-    /**
-     * The method to return the value of some header from the request
-     *
-     * @param name - The name of the header
-     */
-    getHeader(name: string): string | undefined;
-    /**
-     * The method to return the request headers
-     */
-    getHeaders(): SingleValueHeaders;
-    /**
-     * The method to return user's address
-     */
-    getIp(): string | undefined;
-    /**
-     * The method to return the URL called
-     */
-    getUrl(): string | undefined;
-    /**
-     * The method to return the HTTP Method in the request
-     */
-    getMethod(): string | undefined;
-}
-/**
- * This is the context merged between {@link TrpcAdapterBaseContext} and the {@link TContext} that you provided.
- *
- * This context will be merged with the context you created with `createContext` inside {@link TrpcFrameworkOptions}.
- * So to make the type work, just send the properties you've added inside {@link TContext}.
- *
- * @example
- * ```typescript
- * type MyCustomContext = { user: { name: string } };
- * type TrpcContext = TrpcAdapterContext<MyCustomContext>; // your final context type to put inside trpc.router
- * ```
- *
- * @breadcrumb Frameworks / TrpcFramework
- * @public
- */
-export declare type TrpcAdapterContext<TContext> = TContext & TrpcAdapterBaseContext;
-/**
- * The options to customize the {@link TrpcFramework}
- *
- * @breadcrumb Frameworks / TrpcFramework
- * @public
- */
-export declare type TrpcFrameworkOptions<TContext> = Omit<NodeHTTPHandlerOptions<AnyRouter<TContext>, IncomingMessage, ServerResponse>, 'router' | 'createContext'> & {
-    createContext?: (opts: NodeHTTPCreateContextFnOptions<IncomingMessage, ServerResponse>) => Omit<TContext, keyof TrpcAdapterBaseContext> | Promise<Omit<TContext, keyof TrpcAdapterBaseContext>>;
-};
-/**
- * The framework that forwards requests to TRPC handler
- *
- * @breadcrumb Frameworks / TrpcFramework
- * @public
- */
-export declare class TrpcFramework<TContext extends TrpcAdapterBaseContext> implements FrameworkContract<AnyRouter<TContext>> {
-    protected readonly options?: TrpcFrameworkOptions<TContext> | undefined;
-    /**
-     * Default constructor
-     */
-    constructor(options?: TrpcFrameworkOptions<TContext> | undefined);
-    /**
-     * {@inheritDoc}
-     */
-    sendRequest(app: AnyRouter<TContext>, request: IncomingMessage, response: ServerResponse): void;
-    /**
-     * Get safe url that can be used inside Trpc.
-     *
-     * @example
-     * ```typescript
-     * const url = getSafeUrlForTrpc('/users?input=hello');
-     * console.log(url); // users
-     * ```
-     *
-     * @param request - The request object that will be forward to your app
-     */
-    protected getSafeUrlForTrpc(request: IncomingMessage): string;
-    /**
-     * Merge the default context ({@link TrpcAdapterContext}) with the context created by the user.
-     *
-     * @param createContextOptions - The options sent by trpc to create the context
-     */
-    protected mergeDefaultContextWithOptionsContext(createContextOptions: NodeHTTPCreateContextFnOptions<IncomingMessage, ServerResponse>): TContext | Promise<TContext>;
-    /**
-     * Wraps the resolved context from the {@link TrpcFrameworkOptions} created with `createContext` and merge
-     * with the {@link TrpcAdapterContext} generated by the library.
-     *
-     * @param resolvedContext - The context created with `createContext` inside {@link TrpcFrameworkOptions}
-     * @param createContextOptions - The options sent by trpc to create the context
-     */
-    protected wrapResolvedContextWithDefaultContext(resolvedContext: TContext, createContextOptions: NodeHTTPCreateContextFnOptions<IncomingMessage, ServerResponse>): TContext;
-}
-export declare type __ΩTrpcAdapterBaseContext = any[];
-export declare type __ΩTrpcAdapterContext = any[];
-export declare type __ΩTrpcFrameworkOptions = any[];

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

@@ -1,45 +0,0 @@
-import type { Context } from '@azure/functions';
-import { BinarySettings } from '../../@types';
-import { AdapterContract, FrameworkContract, ResolverContract, ServerlessHandler } from '../../contracts';
-import { ILogger } from '../../core';
-import { DefaultHandler } from '../default';
-/**
- * The options to customize {@link AzureHandler}
- *
- * @breadcrumb Handlers / AzureHandler
- * @public
- */
-export interface AzureHandlerOptions {
-    /**
-     * Indicates to use the context log instead console.log when logger is internal (created by the library)
-     *
-     * @defaultValue true
-     */
-    useContextLogWhenInternalLogger: boolean;
-}
-/**
- * The class that implements a serverless handler for Azure Function.
- *
- * When you don't specify a custom logger, the {@link Context} logger is used instead.
- *
- * @breadcrumb Handlers / AzureHandler
- * @public
- */
-export declare class AzureHandler<TApp, TEvent, TCallback, TResponse, TReturn> extends DefaultHandler<TApp, TEvent, Context, TCallback, TResponse, TReturn> {
-    protected readonly options?: AzureHandlerOptions | undefined;
-    /**
-     * Default Constructor
-     */
-    constructor(options?: AzureHandlerOptions | undefined);
-    /**
-     * {@inheritDoc}
-     */
-    getHandler(app: TApp, framework: FrameworkContract<TApp>, adapters: AdapterContract<TEvent, Context, TResponse>[], resolverFactory: ResolverContract<TEvent, Context, TCallback, TResponse, TReturn>, binarySettings: BinarySettings, respondWithErrors: boolean, log: ILogger): ServerlessHandler<TReturn>;
-    /**
-     * Get the {@link ILogger} instance from logger of the context
-     *
-     * @param context - The Azure Context
-     */
-    protected createLoggerFromContext(context: Context): ILogger;
-}
-export declare type __ΩAzureHandlerOptions = any[];

package/lib/handlers/azure/index.d.ts

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

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

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

package/lib/handlers/base/raw-request.d.ts

@@ -1,30 +0,0 @@
-/// <reference types="node" />
-import { IncomingMessage, ServerResponse } from 'http';
-import { FrameworkContract } from '../../contracts/index';
-import { ServerlessRequest } from '../../network/index';
-/**
- * The class that expose some methods to be used to get raw request from Express HTTP Request
- *
- * @breadcrumb Handlers / Base / RawRequest
- * @public
- */
-export declare abstract class RawRequest<TApp> {
-    /**
-     * The callback to when receive some request from external source
-     *
-     * @param app - The instance of the app
-     * @param framework - The framework for the app
-     */
-    protected onRequestCallback(app: TApp, framework: FrameworkContract<TApp>): (req: IncomingMessage, res: ServerResponse) => void | Promise<void>;
-    /**
-     * Not sure why they think using Express instance with prebuilt middlewares was a good idea, but Firebase/GCP
-     * decides to use `Express` and `body-parser` by default, so you don't get a raw request, instead, you get a modified version by
-     * Express and also with the body parsed by `body-parser`.
-     * If you use NestJS or Express it's awesome, but for the rest of the frameworks it's terrible!
-     * That's why I have this method, just to try and create a raw request to be used and passed to the frameworks so they can handle the request
-     * as if they received the request from the native http module.
-     *
-     * @param request - The Express request
-     */
-    protected getRequestFromExpressRequest(request: IncomingMessage): ServerlessRequest;
-}

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

@@ -1,87 +0,0 @@
-import { BinarySettings, SingleValueHeaders } from '../../@types';
-import { AdapterContract, AdapterRequest, FrameworkContract, ResolverContract, ServerlessHandler } from '../../contracts';
-import { BaseHandler, ILogger } from '../../core';
-import { ServerlessResponse } from '../../network';
-/**
- * The class that implements a default serverless handler consisting of a function with event, context and callback parameters respectively
- *
- * @breadcrumb Handlers / DefaultHandler
- * @public
- */
-export declare class DefaultHandler<TApp, TEvent, TContext, TCallback, TResponse, TReturn> extends BaseHandler<TApp, TEvent, TContext, TCallback, TResponse, TReturn> {
-    /**
-     * {@inheritDoc}
-     */
-    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>;
-    /**
-     * The hook executed on receive a request, before the request is being processed
-     *
-     * @param log - The instance of logger
-     * @param event - The event sent by serverless
-     * @param context - The context sent by serverless
-     * @param binarySettings - The binary settings
-     * @param respondWithErrors - Indicates whether the error stack should be included in the response or not
-     */
-    protected onReceiveRequest(log: ILogger, event: TEvent, context: TContext, binarySettings: BinarySettings, respondWithErrors: boolean): void;
-    /**
-     * The hook executed after resolve the adapter that will be used to handle the request and response
-     *
-     * @param log - The instance of logger
-     * @param adapter - The adapter resolved
-     */
-    protected onResolveAdapter(log: ILogger, adapter: AdapterContract<TEvent, TContext, TResponse>): void;
-    /**
-     * The hook executed after resolves the request values that will be sent to the framework
-     *
-     * @param log - The instance of logger
-     * @param requestValues - The request values returned by the adapter
-     */
-    protected onResolveRequestValues(log: ILogger, requestValues: AdapterRequest): void;
-    /**
-     * The hook executed after handling the response sent by the framework
-     *
-     * @param log - The instance of logger
-     * @param response - The response sent by the framework
-     */
-    protected onResolveForwardedResponseToFramework(log: ILogger, response: ServerlessResponse): void;
-    /**
-     * The hook executed before sending response to the serverless
-     *
-     * @param log - The instance of logger
-     * @param statusCode - The status code of the response
-     * @param body - The body of the response
-     * @param headers - The headers of the response
-     * @param isBase64Encoded - Indicates whether the response was encoded as binary or not
-     */
-    protected onForwardResponse(log: ILogger, statusCode: number, body: string, headers: SingleValueHeaders, isBase64Encoded: boolean): void;
-    /**
-     * The hook executed before sending response to the serverless with response from adapter
-     *
-     * @param log - The instance of logger
-     * @param successResponse - The success response resolved by the adapter
-     * @param body - The body of the response sent by the framework
-     */
-    protected onForwardResponseAdapterResponse(log: ILogger, successResponse: TResponse, body: string): void;
-    /**
-     * The function to forward the event to the framework
-     *
-     * @param app - The instance of the app (express, hapi, etc...)
-     * @param framework - The framework that will process requests
-     * @param event - The event sent by serverless
-     * @param context - The context sent by serverless
-     * @param adapter - The adapter resolved to this event
-     * @param log - The instance of logger
-     * @param binarySettings - The binary settings
-     */
-    protected forwardRequestToFramework(app: TApp, framework: FrameworkContract<TApp>, event: TEvent, context: TContext, adapter: AdapterContract<TEvent, TContext, TResponse>, binarySettings: BinarySettings, log: ILogger): Promise<TResponse>;
-    /**
-     * The function to forward the response back to the serverless
-     *
-     * @param event - The event sent by serverless
-     * @param response - The response of the framework
-     * @param adapter - The adapter resolved to this event
-     * @param binarySettings - The binary settings
-     * @param log - The instance of logger
-     */
-    protected forwardResponse(event: TEvent, response: ServerlessResponse, adapter: AdapterContract<TEvent, TContext, TResponse>, binarySettings: BinarySettings, log: ILogger): TResponse;
-}

package/lib/handlers/default/index.d.ts

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

package/lib/handlers/digital-ocean/digital-ocean.handler.d.ts

@@ -1,16 +0,0 @@
-import { BinarySettings } from '../../@types';
-import { AdapterContract, FrameworkContract, ResolverContract, ServerlessHandler } from '../../contracts';
-import { ILogger } from '../../core';
-import { DefaultHandler } from '../default';
-/**
- * The class that implements a serverless handler for Digital Ocean Functions.
- *
- * @breadcrumb Handlers / DigitalOceanHandler
- * @public
- */
-export declare class DigitalOceanHandler<TApp, TEvent, TResponse, TReturn> extends DefaultHandler<TApp, TEvent, void, void, TResponse, TReturn> {
-    /**
-     * {@inheritDoc}
-     */
-    getHandler(app: TApp, framework: FrameworkContract<TApp>, adapters: AdapterContract<TEvent, void, TResponse>[], resolverFactory: ResolverContract<TEvent, void, void, TResponse, TReturn>, binarySettings: BinarySettings, respondWithErrors: boolean, log: ILogger): ServerlessHandler<TReturn>;
-}

package/lib/handlers/digital-ocean/index.d.ts

@@ -1 +0,0 @@
-export * from './digital-ocean.handler';

package/lib/handlers/firebase/http-firebase-v2.handler.d.ts

@@ -1,26 +0,0 @@
-import { https } from 'firebase-functions/v2';
-import { FrameworkContract, HandlerContract } from '../../contracts';
-import { RawRequest } from '../base';
-/**
- * The class that implements a handler for Firebase Https Events
- *
- * @remarks Read more about Https Events {@link https://firebase.google.com/docs/functions/http-events | here}
- *
- * @breadcrumb Handlers / HttpFirebaseHandler
- * @public
- */
-export declare class HttpFirebaseV2Handler<TApp> extends RawRequest<TApp> implements HandlerContract<TApp, never, never, never, void, void | Promise<void>> {
-    protected readonly options?: https.HttpsOptions | undefined;
-    /**
-     * Construtor padrão
-     */
-    constructor(options?: https.HttpsOptions | undefined);
-    /**
-     * {@inheritDoc}
-     */
-    getHandler(app: TApp, framework: FrameworkContract<TApp>): ReturnType<HttpFirebaseV2Handler<TApp>['onRequestCallback']>;
-    /**
-     * Wrapper method around onRequest for better testability
-     */
-    protected onRequestWithOptions(options: https.HttpsOptions, callback: ReturnType<HttpFirebaseV2Handler<TApp>['onRequestCallback']>): ReturnType<HttpFirebaseV2Handler<TApp>['onRequestCallback']>;
-}

package/lib/handlers/firebase/http-firebase.handler.d.ts

@@ -1,18 +0,0 @@
-/// <reference types="node" />
-import { IncomingMessage, ServerResponse } from 'http';
-import { FrameworkContract, HandlerContract } from '../../contracts';
-import { RawRequest } from '../base';
-/**
- * The class that implements a handler for Firebase Https Events
- *
- * @remarks Read more about Https Events {@link https://firebase.google.com/docs/functions/http-events | here}
- *
- * @breadcrumb Handlers / HttpFirebaseHandler
- * @public
- */
-export declare class HttpFirebaseHandler<TApp> extends RawRequest<TApp> implements HandlerContract<TApp, never, never, never, void, void | Promise<void>> {
-    /**
-     * {@inheritDoc}
-     */
-    getHandler(app: TApp, framework: FrameworkContract<TApp>): (req: IncomingMessage, res: ServerResponse) => void | Promise<void>;
-}

package/lib/handlers/firebase/index.d.ts

@@ -1,2 +0,0 @@
-export * from './http-firebase.handler';
-export * from './http-firebase-v2.handler';

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

@@ -1,25 +0,0 @@
-/// <reference types="node" />
-import { IncomingMessage, ServerResponse } from 'http';
-import { FrameworkContract, HandlerContract } from '../../contracts';
-import { RawRequest } from '../base/index';
-/**
- * The class that implements a handler for GCP Http Functions
- *
- * @remarks Read more about Http Cloud Function {@link https://cloud.google.com/functions/docs/create-deploy-http-nodejs | here}
- *
- * @breadcrumb Handlers / GCPHandler
- * @public
- */
-export declare class GCPHandler<TApp> extends RawRequest<TApp> implements HandlerContract<TApp, never, never, never, void, void | Promise<void>> {
-    protected readonly name: string;
-    /**
-     * Default Constructor
-     *
-     * @param name - The name of this function, should be the during deploy.
-     */
-    constructor(name: string);
-    /**
-     * {@inheritDoc}
-     */
-    getHandler(app: TApp, framework: FrameworkContract<TApp>): (req: IncomingMessage, res: ServerResponse) => void | Promise<void>;
-}

package/lib/handlers/gcp/index.d.ts

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

package/lib/handlers/huawei/http-huawei.handler.d.ts

@@ -1,59 +0,0 @@
-/// <reference types="node" />
-import * as http from 'http';
-import { RequestListener } from 'http';
-import { BinarySettings } from '../../@types';
-import { AdapterContract, FrameworkContract, HandlerContract, ResolverContract, ServerlessHandler } from '../../contracts';
-import { ILogger } from '../../core';
-/**
- * The default port that huawei will proxy the request to your framework
- *
- * {@link https://support.huaweicloud.com/intl/en-us/ae-ad-1-usermanual-functiongraph/functiongraph_01_1442.html#functiongraph_01_1442__li194597302096 | Reference}
- *
- * @breadcrumb Handlers / HttpHuaweiHandler
- * @public
- */
-export declare const DEFAULT_HUAWEI_LISTEN_PORT: number;
-/**
- * The options to customize {@link HttpHuaweiHandler}
- *
- * @breadcrumb Handlers / HttpHuaweiHandler
- * @public
- */
-export declare type HttpHuaweiHandlerOptions = {
-    /**
-     * @defaultValue {@link DEFAULT_HUAWEI_LISTEN_PORT}
-     */
-    port?: number;
-    /**
-     * The factory to create a http server to use to listen huawei requests
-     */
-    httpServerFactory?: (requestListener: RequestListener) => http.Server;
-};
-/**
- * The class that implements a huawei serverless handler with http function that exposes a http server in specific port.
- *
- * In this Handler, you don't need to specific resolver and adapter, so you can use DummyAdapter and DummyResolver instead.
- *
- * @see https://support.huaweicloud.com/intl/en-us/ae-ad-1-usermanual-functiongraph/functiongraph_01_1442.html#functiongraph_01_1442__li194597302096
- *
- * @breadcrumb Handlers / HttpHuaweiHandler
- * @public
- */
-export declare class HttpHuaweiHandler<TApp> implements HandlerContract<TApp, void, void, void, void, Promise<void>> {
-    protected readonly options?: HttpHuaweiHandlerOptions | undefined;
-    /**
-     * Construtor padrão
-     */
-    constructor(options?: HttpHuaweiHandlerOptions | undefined);
-    /**
-     * {@inheritDoc}
-     */
-    getHandler(app: TApp, framework: FrameworkContract<TApp>, _: AdapterContract<void, void, void>[], __: ResolverContract<void, void, void, void, void>, binarySettings: BinarySettings, respondWithErrors: boolean, log: ILogger): ServerlessHandler<Promise<void>>;
-    /**
-     * The method that creates the instance of http server
-     *
-     * @param requestListener - O método que lidará com as requisições recebidas
-     */
-    protected createHttpServer(requestListener: RequestListener): http.Server;
-}
-export declare type __ΩHttpHuaweiHandlerOptions = any[];

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

@@ -1 +0,0 @@
-export * from './http-huawei.handler';

package/lib/index.d.ts

@@ -1,5 +0,0 @@
-export * from './@types';
-export * from './contracts';
-export * from './core';
-export * from './network';
-export * from './serverless-adapter';

package/lib/network/index.d.ts

@@ -1,2 +0,0 @@
-export * from './request';
-export * from './response';

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.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[];