@h4ad/serverless-adapter 1.0.1

package/lib/handlers/base/base.handler.js

@@ -0,0 +1,52 @@
+"use strict";
+//#region Imports
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseHandler = void 0;
+const network_1 = require("../../network");
+//#endregion
+/**
+ * The abstract class that represents the base class for a handler
+ */
+class BaseHandler {
+    //#endregion
+    //#region Protected Methods
+    /**
+     * 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
+     */
+    getAdapterByEventAndContext(event, context, adapters, log) {
+        const resolvedAdapters = adapters.filter(adapter => adapter.canHandle(event, context, log));
+        if (resolvedAdapters.length === 0) {
+            throw new Error("SERVERLESS_ADAPTER: Couldn't find adapter to handle this event.");
+        }
+        if (resolvedAdapters.length > 1) {
+            throw new Error(`SERVERLESS_ADAPTER: Two or more adapters was resolved by the event, the adapters are: ${adapters
+                .map(adapter => adapter.getAdapterName())
+                .join(', ')}.`);
+        }
+        return resolvedAdapters[0];
+    }
+    /**
+     * Get serverless request and response frmo the adapter request
+     *
+     * @param requestValues The request values from adapter
+     */
+    getServerlessRequestResponseFromAdapterRequest(requestValues) {
+        const request = new network_1.ServerlessRequest({
+            method: requestValues.method,
+            headers: requestValues.headers,
+            body: requestValues.body,
+            remoteAddress: requestValues.remoteAddress,
+            url: requestValues.path,
+        });
+        const response = new network_1.ServerlessResponse({
+            method: requestValues.method,
+        });
+        return [request, response];
+    }
+}
+exports.BaseHandler = BaseHandler;

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

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

package/lib/handlers/base/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("./base.handler"), exports);

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

@@ -0,0 +1,85 @@
+import { BinarySettings, SingleValueHeaders } from '../@types';
+import { AdapterContract, AdapterRequest, FrameworkContract, ResolverContract, ServerlessHandler } from '../contracts';
+import { ILogger } from '../core';
+import { ServerlessResponse } from '../network';
+import { BaseHandler } from './base';
+/**
+ * The class that implements a default serverless handler consisting of a function with event, context and callback parameters respectively
+ */
+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.handler.js

@@ -0,0 +1,183 @@
+"use strict";
+//#region Imports
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefaultHandler = void 0;
+const util_1 = __importDefault(require("util"));
+const core_1 = require("../core");
+const network_1 = require("../network");
+const base_1 = require("./base");
+//#endregion
+/**
+ * The class that implements a default serverless handler consisting of a function with event, context and callback parameters respectively
+ */
+class DefaultHandler extends base_1.BaseHandler {
+    //#region Public Methods
+    /**
+     * @inheritDoc
+     */
+    getHandler(app, framework, adapters, resolverFactory, binarySettings, respondWithErrors, log) {
+        return (event, context, callback) => {
+            this.onReceiveRequest(log, event, context, binarySettings, respondWithErrors);
+            const adapter = this.getAdapterByEventAndContext(event, context, adapters, log);
+            this.onResolveAdapter(log, adapter);
+            (0, core_1.setCurrentInvoke)({ event, context });
+            const resolver = resolverFactory.createResolver({
+                event,
+                context,
+                callback,
+                log,
+                respondWithErrors,
+                adapter,
+            });
+            return resolver.run(() => this.forwardRequestToFramework(app, framework, event, context, adapter, binarySettings, log));
+        };
+    }
+    //#endregion
+    //#region Hooks
+    /**
+     * 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
+     */
+    onReceiveRequest(log, event, context, binarySettings, respondWithErrors) {
+        log.debug('SERVERLESS_ADAPTER:PROXY', {
+            event: util_1.default.inspect(event, { depth: null }),
+            context: util_1.default.inspect(context, { depth: null }),
+            binarySettings,
+            respondWithErrors,
+        });
+    }
+    /**
+     * 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
+     */
+    onResolveAdapter(log, adapter) {
+        log.debug('SERVERLESS_ADAPTER:RESOLVED_ADAPTER_NAME: ', adapter.getAdapterName());
+    }
+    /**
+     * 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
+     */
+    onResolveRequestValues(log, requestValues) {
+        var _a;
+        const body = (_a = requestValues.body) === null || _a === void 0 ? void 0 : _a.toString();
+        log.debug('SERVERLESS_ADAPTER:FORWARD_REQUEST_TO_FRAMEWORK:REQUEST_VALUES', {
+            requestValues: Object.assign(Object.assign({}, requestValues), { body }),
+        });
+    }
+    /**
+     * 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
+     */
+    onResolveForwardedResponseToFramework(log, response) {
+        log.debug('SERVERLESS_ADAPTER:FORWARD_REQUEST_TO_FRAMEWORK:RESPONSE', {
+            response,
+        });
+    }
+    /**
+     * 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
+     */
+    onForwardResponse(log, statusCode, body, headers, isBase64Encoded) {
+        log.debug('SERVERLESS_ADAPTER:FORWARD_RESPONSE:EVENT_SOURCE_RESPONSE_PARAMS', {
+            statusCode,
+            body,
+            headers,
+            isBase64Encoded,
+        });
+    }
+    /**
+     * 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
+     */
+    onForwardResponseAdapterResponse(log, successResponse, body) {
+        log.debug('SERVERLESS_ADAPTER:FORWARD_RESPONSE:EVENT_SOURCE_RESPONSE', {
+            successResponse: util_1.default.inspect(successResponse, { depth: null }),
+            body,
+        });
+    }
+    //#endregion
+    //#region Protected Methods
+    /**
+     * 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
+     */
+    forwardRequestToFramework(app, framework, event, context, adapter, binarySettings, log) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestValues = adapter.getRequest(event, context, log);
+            this.onResolveRequestValues(log, requestValues);
+            const [request, response] = this.getServerlessRequestResponseFromAdapterRequest(requestValues);
+            framework.sendRequest(app, request, response);
+            yield (0, core_1.waitForStreamComplete)(response);
+            this.onResolveForwardedResponseToFramework(log, response);
+            return this.forwardResponse(event, response, adapter, binarySettings, log);
+        });
+    }
+    /**
+     * 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
+     */
+    forwardResponse(event, response, adapter, binarySettings, log) {
+        const statusCode = response.statusCode;
+        const headers = network_1.ServerlessResponse.headers(response);
+        const isBase64Encoded = (0, core_1.isBinary)(headers, binarySettings);
+        const encoding = isBase64Encoded ? 'base64' : 'utf8';
+        const body = network_1.ServerlessResponse.body(response).toString(encoding);
+        const logBody = isBase64Encoded ? '[BASE64_ENCODED]' : body;
+        this.onForwardResponse(log, statusCode, logBody, headers, isBase64Encoded);
+        const successResponse = adapter.getResponse({
+            event,
+            statusCode,
+            body,
+            headers,
+            isBase64Encoded,
+            response,
+            log,
+        });
+        this.onForwardResponseAdapterResponse(log, successResponse, logBody);
+        return successResponse;
+    }
+}
+exports.DefaultHandler = DefaultHandler;

package/lib/handlers/index.d.ts

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

package/lib/handlers/index.js

@@ -0,0 +1,14 @@
+"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("./base"), exports);
+__exportStar(require("./default.handler"), exports);

package/lib/index.d.ts

@@ -0,0 +1,9 @@
+export * from './@types';
+export * from './adapters';
+export * from './contracts';
+export * from './core';
+export * from './frameworks';
+export * from './handlers';
+export * from './network';
+export * from './resolvers';
+export * from './serverless-adapter';

package/lib/index.js

@@ -0,0 +1,21 @@
+"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("./@types"), exports);
+__exportStar(require("./adapters"), exports);
+__exportStar(require("./contracts"), exports);
+__exportStar(require("./core"), exports);
+__exportStar(require("./frameworks"), exports);
+__exportStar(require("./handlers"), exports);
+__exportStar(require("./network"), exports);
+__exportStar(require("./resolvers"), exports);
+__exportStar(require("./serverless-adapter"), exports);

package/lib/network/index.d.ts

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

package/lib/network/index.js

@@ -0,0 +1,14 @@
+"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("./request"), exports);
+__exportStar(require("./response"), exports);

package/lib/network/request.d.ts

@@ -0,0 +1,15 @@
+/// <reference types="node" />
+import http from 'http';
+import { SingleValueHeaders } from '../@types';
+export interface ServerlessRequestProps {
+    method: string;
+    url: string;
+    headers: SingleValueHeaders;
+    body?: Buffer;
+    remoteAddress?: string;
+}
+export declare class ServerlessRequest extends http.IncomingMessage {
+    constructor({ method, url, headers, body, remoteAddress, }: ServerlessRequestProps);
+    ip?: string;
+    body?: Buffer;
+}

package/lib/network/request.js

@@ -0,0 +1,40 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ServerlessRequest = void 0;
+// ATTRIBUTION: https://github.com/dougmoscrop/serverless-http
+const http_1 = __importDefault(require("http"));
+const core_1 = require("../core");
+const HTTPS_PORT = 443;
+class ServerlessRequest extends http_1.default.IncomingMessage {
+    constructor({ method, url, headers, body, remoteAddress, }) {
+        super({
+            encrypted: true,
+            readable: false,
+            remoteAddress,
+            address: () => ({ port: HTTPS_PORT }),
+            end: core_1.NO_OP,
+            destroy: core_1.NO_OP,
+        });
+        this.statusCode = 200;
+        this.statusMessage = 'OK';
+        this.complete = true;
+        this.httpVersion = '1.1';
+        this.httpVersionMajor = 1;
+        this.httpVersionMinor = 1;
+        this.method = method;
+        this.headers = headers;
+        this.body = body;
+        this.url = url;
+        this.ip = remoteAddress;
+        // ref: https://github.com/nodejs/node/blob/master/lib/internal/streams/readable.js#L1278
+        this._readableState.endEmitted = true;
+        this._read = () => {
+            this.push(body);
+            this.push(null);
+        };
+    }
+}
+exports.ServerlessRequest = ServerlessRequest;

package/lib/network/response.d.ts

@@ -0,0 +1,22 @@
+/// <reference types="node" />
+import http, { IncomingMessage, OutgoingHttpHeaders } from 'http';
+declare const BODY: unique symbol;
+declare const HEADERS: unique symbol;
+export interface ServerlessResponseProps {
+    method?: string;
+}
+export declare class ServerlessResponse extends http.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): Record<any, any>;
+    setHeader(key: string, value: number | string | readonly string[]): any;
+    writeHead(statusCode: number, reason?: string | OutgoingHttpHeaders, obj?: OutgoingHttpHeaders): any;
+}
+export {};

package/lib/network/response.js

@@ -0,0 +1,104 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ServerlessResponse = void 0;
+// ATTRIBUTION: https://github.com/dougmoscrop/serverless-http
+const http_1 = __importDefault(require("http"));
+const core_1 = require("../core");
+const headerEnd = '\r\n\r\n';
+const BODY = Symbol('Response body');
+const HEADERS = Symbol('Response headers');
+function getString(data) {
+    if (Buffer.isBuffer(data))
+        return data.toString('utf8');
+    else if (typeof data === 'string')
+        return data;
+    else
+        throw new Error(`response.write() of unexpected type: ${typeof data}`);
+}
+function addData(stream, data) {
+    if (Buffer.isBuffer(data) || typeof data === 'string')
+        stream[BODY].push(Buffer.from(data));
+    else
+        throw new Error(`response.write() of unexpected type: ${typeof data}`);
+}
+class ServerlessResponse extends http_1.default.ServerResponse {
+    constructor({ method }) {
+        super({ method });
+        this[BODY] = [];
+        this[HEADERS] = {};
+        this.useChunkedEncodingByDefault = false;
+        this.chunkedEncoding = false;
+        this._header = '';
+        const socket = {
+            _writableState: {},
+            writable: true,
+            on: core_1.NO_OP,
+            removeListener: core_1.NO_OP,
+            destroy: core_1.NO_OP,
+            cork: core_1.NO_OP,
+            uncork: core_1.NO_OP,
+            write: (data, encoding, cb) => {
+                if (typeof encoding === 'function') {
+                    cb = encoding;
+                    encoding = null;
+                }
+                if (this._header === '' || this._wroteHeader)
+                    addData(this, data);
+                else {
+                    const string = getString(data);
+                    const index = string.indexOf(headerEnd);
+                    if (index !== -1) {
+                        const remainder = string.slice(index + headerEnd.length);
+                        if (remainder)
+                            addData(this, remainder);
+                        this._wroteHeader = true;
+                    }
+                }
+                if (typeof cb === 'function')
+                    cb();
+            },
+        };
+        this.assignSocket(socket);
+    }
+    get headers() {
+        return this[HEADERS];
+    }
+    static from(res) {
+        const response = new ServerlessResponse({ method: res.method });
+        response.statusCode = res.statusCode || 0;
+        response[HEADERS] = res.headers;
+        response[BODY] = res.body ? [Buffer.from(res.body)] : [];
+        response.end();
+        return response;
+    }
+    static body(res) {
+        return Buffer.concat(res[BODY]);
+    }
+    static headers(res) {
+        const headers = typeof res.getHeaders === 'function' ? res.getHeaders() : res._headers;
+        return Object.assign(headers, res[HEADERS]);
+    }
+    setHeader(key, value) {
+        if (this._wroteHeader)
+            this[HEADERS][key] = value;
+        else
+            super.setHeader(key, value);
+    }
+    writeHead(statusCode, reason, obj) {
+        const headers = typeof reason === 'string' ? obj : reason;
+        for (const name in headers) {
+            this.setHeader(name, headers[name]);
+            if (!this._wroteHeader) {
+                // we only need to initiate super.headers once
+                // writeHead will add the other headers itself
+                break;
+            }
+        }
+        // @ts-ignore
+        super.writeHead(statusCode, reason, obj);
+    }
+}
+exports.ServerlessResponse = ServerlessResponse;

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

@@ -0,0 +1,21 @@
+import type { Context } from 'aws-lambda';
+import { Resolver, ResolverContract, ResolverProps } from '../contracts';
+/**
+ * The class that implements the resolver by using the AWS Context object.
+ *
+ * @note 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.
+ *
+ * ```md
+ * 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.
+ * ```
+ * @deprecated
+ */
+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>;
+}