@h4ad/serverless-adapter 2.0.3 → 2.3.0

package/README.md

@@ -6,6 +6,7 @@
   <a href="#install">Install</a>&nbsp;&nbsp;&nbsp;|&nbsp;&nbsp;&nbsp;
   <a href="#usage">Usage</a>&nbsp;&nbsp;&nbsp;|&nbsp;&nbsp;&nbsp;
   <a href="#support">Support</a>&nbsp;&nbsp;&nbsp;|&nbsp;&nbsp;&nbsp;
+  <a href="#examples">Examples</a>&nbsp;&nbsp;&nbsp;|&nbsp;&nbsp;&nbsp;
   <a href="#architecture">Architecture</a>&nbsp;&nbsp;&nbsp;|&nbsp;&nbsp;&nbsp;
   <a href="#credits">Credits</a>
 </p>
@@ -19,7 +20,7 @@
 [![Semantic Release][semantic-release-img]][semantic-release-url]
 
 Run REST APIs and other web applications using your existing Node.js application framework (Express, Koa, Hapi and
-Fastify), on top of AWS Lambda, Amazon API Gateway and many other event sources.
+Fastify), on top of AWS Lambda, Huawei and many other clouds.
 
 This library was a refactored version of [@vendia/serverless-express](https://github.com/vendia/serverless-express), I
 created a new way to interact and extend event sources by creating contracts to abstract the integrations between each
@@ -56,12 +57,16 @@ You can quickly use this library as follows:
 
 ```ts
 import { ServerlessAdapter } from '@h4ad/serverless-adapter';
-import { ApiGatewayV2Adapter } from '@h4ad/serverless-adapter/lib/adapters/aws';
+import { ApiGatewayV2Adapter, AlbAdapter, SQSAdapter, SNSAdapter } from '@h4ad/serverless-adapter/lib/adapters/aws';
 import { ExpressFramework } from '@h4ad/serverless-adapter/lib/frameworks/express';
 import { DefaultHandler } from '@h4ad/serverless-adapter/lib/handlers/default';
 import { PromiseResolver } from '@h4ad/serverless-adapter/lib/resolvers/promise';
 import app from './app';
 
+// if you create your app asynchronously
+// check the docs about the LazyFramework.
+// ServerlessAdapter.new(null)
+// .setFramework(new LazyFramework(new ExpressFramework(), async () => createAsyncApp()))
 export const handler = ServerlessAdapter.new(app)
   .setFramework(new ExpressFramework())
   .setHandler(new DefaultHandler())
@@ -70,8 +75,6 @@ export const handler = ServerlessAdapter.new(app)
   .addAdapter(new SQSAdapter())
   .addAdapter(new SNSAdapter())
   .build();
-
-export { handler };
 ```
 
 Too fast? Ok, I can explain.
@@ -120,6 +123,9 @@ Currently, we support these frameworks:
 - [Fastify](https://www.fastify.io/) by using ([FastifyFramework](src/frameworks/fastify/fastify.framework.ts))
 - [Hapi](https://hapi.dev/) by using ([HapiFramework](src/frameworks/hapi/hapi.framework.ts))
 - [Koa](https://koajs.com/) by using ([KoaFramework](src/frameworks/koa/koa.framework.ts))
+- Async Initialization by using ([LazyFramework](src/frameworks/lazy/lazy.framework.ts))
+  - Use this framework to provide a way to create the instance of your app asynchronously.
+  - With him, you can create an instance of Express or Fastify asynchronously, [see the docs](src/frameworks/lazy/lazy.framework.ts).
 
 We support these event sources:
 
@@ -140,9 +146,15 @@ We support these event sources:
     using ([SNSAdapter](./src/adapters/aws/sns.adapter.ts))
   - [AWS SQS](https://docs.aws.amazon.com/pt_br/lambda/latest/dg/with-sqs.html) by
     using ([SQSAdapter](./src/adapters/aws/sqs.adapter.ts))
+- Huawei
+  - [Http Function](https://support.huaweicloud.com/intl/en-us/usermanual-functiongraph/functiongraph_01_1442.html): Look [this section](#huawei-http-function) about Huawei support for Http Function.
+  - [Event Function](https://support.huaweicloud.com/intl/en-us/usermanual-functiongraph/functiongraph_01_1441.html): 
+    - [Api Gateway](https://support.huaweicloud.com/intl/en-us/devg-functiongraph/functiongraph_02_0102.html#functiongraph_02_0102__li5178638110137) by using ([HuaweiApiGatewayAdapter](src/adapters/huawei/huawei-api-gateway.adapter.ts)).
 - Azure
+  - [The support is coming soon.](https://github.com/H4ad/serverless-adapter/issues/3)
+- Firebase
   - The support is coming soon.
-- Huawei
+- GCP
   - The support is coming soon.
 
 We support these resolvers:
@@ -154,6 +166,94 @@ We support these resolvers:
 We support these handlers:
 
 - Default by using ([DefaultHandler](src/handlers/default/default.handler.ts))
+- Huawei by using ([HttpHuaweiHandler](src/handlers/huawei/http-huawei.handler.ts)) and ([EventHuaweiHandler](#huawei-event-function))
+
+## Huawei
+
+In Huawei, we added support to FunctionGraphV2 with Http Function and Event Function.
+
+The difference between Http Function and Event Function is that in Http Function you must expose port 8000 and Huawei will proxy Api Gateway requests to your application.
+So, on implementation, this library will create an http server to listen on port 8000 and forward the request to your framework.
+
+In Event Function, you will receive the event from event source in the same way you receive in AWS, an object with some structure, you can see the supported event sources [here](https://support.huaweicloud.com/intl/en-us/devg-functiongraph/functiongraph_02_0102.html).
+
+### Huawei Http Function
+
+To integrate your app with Huawei FunctionGrapth with the Http Function type, you must do the following:
+
+```ts
+import { ServerlessAdapter } from '@h4ad/serverless-adapter';
+import { ExpressFramework } from '@h4ad/serverless-adapter/lib/frameworks/express';
+import { HttpHuaweiHandler } from '@h4ad/serverless-adapter/lib/handlers/huawei';
+import { DummyResolver } from '@h4ad/serverless-adapter/lib/resolvers/dummy';
+import { DummyAdapter } from '@h4ad/serverless-adapter/lib/adapters/dummy';
+import app from './app';
+
+// instead exposing handler, you have the dispose function
+// this dispose function is never called
+// but you can to close the http server created with him
+const dispose = ServerlessAdapter.new(app)
+    .setHandler(new HttpHuaweiHandler())
+    .setFramework(new ExpressFramework())
+    // dummy resolver and adapter is used because
+    // they are necessary in the core of the library to build
+    // but is optional to make huawei http function works.
+    .setResolver(new DummyResolver())
+    .addAdapter(new DummyAdapter())
+    .build();
+```
+
+> You don't need to expose a variable called `handler` when you choose Http Function, you just need to call build to the library create a http server.
+
+By the way of Huawei architecture in Http Function, they have no use for Resolvers and Adapters, so you need to use the dummy versions because the library requires it.
+
+#### ONE IMPORTANT THING
+
+You need to configure a file called `bootstrap` in the root of folder that you upload to Huawei, is like the file `Procfile` but for Huawei.
+
+In my setup, I configure like:
+```
+node /opt/function/code/index.js
+```
+
+The path `/opt/function/code` is where your code is uploaded when you deploy something and `index.js` is the file that contains the `ServerlessAdapter`.
+
+In the end, the structure of the zip file you upload looks like this:
+
+- `bootstrap`
+- `index.js`
+
+### Huawei Event Function
+
+With Http Function you need to use [HttpHuaweiHandler](src/handlers/huawei/http-huawei.handler.ts), 
+but with Event Function you should use [DefaultHandler](src/handlers/default/default.handler.ts).
+
+So, to add support to Api Gateway you do the following:
+
+```ts
+import { ServerlessAdapter } from '@h4ad/serverless-adapter';
+import { HuaweiApiGatewayAdapter } from '@h4ad/serverless-adapter/lib/adapters/huawei';
+import { ExpressFramework } from '@h4ad/serverless-adapter/lib/frameworks/express';
+import { DefaultHandler } from '@h4ad/serverless-adapter/lib/handlers/default';
+import { CallbackResolver } from '@h4ad/serverless-adapter/lib/resolvers/callback';
+import app from './app';
+
+export const handler = ServerlessAdapter.new(app)
+  .setFramework(new ExpressFramework())
+  .setHandler(new DefaultHandler())
+  .setResolver(new CallbackResolver())
+  .addAdapter(new HuaweiApiGatewayAdapter())
+  .build();
+```
+
+#### One important thing
+
+You must use the callback resolver because I couldn't get it to work with the PromiseResolver.
+Maybe it's a bug in the library or something specific in Huawei, if you have a tip please create an issue.
+
+# Examples
+
+You can see some examples of how to use this library [here](https://github.com/H4ad/serverless-adapter-examples).
 
 # Architecture
 
@@ -207,6 +307,12 @@ PR just to extend the library's functionality :)
 Honestly, I just refactored all the code that the @vendia team and many other contributors wrote, thanks so much to them
 for existing and giving us a brilliant library that is the core of my current company.
 
+# Sponsors
+
+| <a href="https://liga.facens.br/"><img height="50" src="https://mlogu6g7z5ex.i.optimole.com/yEwfkqo-4R0ttNtd/w:auto/h:auto/q:mauto/f:avif/http://liga.facens.br/wp-content/uploads/2020/03/logo-1.png" title="The LIGA logo" width="100"/></a> |
+|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+
+
 [build-img]:https://github.com/H4ad/serverless-adapter/actions/workflows/release.yml/badge.svg
 
 [build-url]:https://github.com/H4ad/serverless-adapter/actions/workflows/release.yml

package/lib/@types/huawei/huawei-api-gateway-event.d.ts

@@ -0,0 +1,19 @@
+import { BothValueHeaders } from '../index';
+export interface HuaweiApiGatewayEvent {
+    body: string;
+    headers: BothValueHeaders;
+    httpMethod: string;
+    isBase64Encoded: boolean;
+    path: string;
+    pathParameters: HuaweiRequestPathParameters;
+    queryStringParameters: HuaweiRequestQueryStringParameters;
+    requestContext: HuaweiRequestContext;
+    [key: string]: any;
+}
+export declare type HuaweiRequestPathParameters = Record<string, string>;
+export declare type HuaweiRequestQueryStringParameters = Record<string, string | string[]>;
+export interface HuaweiRequestContext {
+    apiId: string;
+    requestId: string;
+    stage: string;
+}

package/lib/@types/huawei/huawei-api-gateway-event.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/@types/huawei/huawei-api-gateway-response.d.ts

@@ -0,0 +1,7 @@
+import { MultiValueHeaders } from '../headers';
+export interface HuaweiApiGatewayResponse {
+    isBase64Encoded: boolean;
+    statusCode: number;
+    headers: MultiValueHeaders;
+    body: string;
+}

package/lib/@types/huawei/huawei-api-gateway-response.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/@types/huawei/huawei-context.d.ts

@@ -0,0 +1,31 @@
+export declare type GetRequestIDSecondsReturn = string;
+export declare type GetRemainingTimeInMilliSecondsReturn = number;
+export declare type GetAccessKeyReturn = string;
+export declare type GetSecretKeyReturn = string;
+export declare type GetUserDataKeyParameter = string;
+export declare type GetUserDataReturn = any;
+export declare type GetFunctionNameReturn = string;
+export declare type GetRunningTimeInSecondsReturn = number;
+export declare type GetVersionReturn = string;
+export declare type GetMemorySizeReturn = number;
+export declare type GetCPUNumberReturn = number;
+export declare type GetProjectIdReturn = number;
+export declare type GetPackageReturn = string;
+export declare type GetLoggerReturn = {
+    info(message: string): void;
+};
+export interface HuaweiContext {
+    getRequestID(): GetRequestIDSecondsReturn;
+    getRemainingTimeInMilliSeconds(): GetRemainingTimeInMilliSecondsReturn;
+    getAccessKey(): GetAccessKeyReturn;
+    getSecretKey(): GetSecretKeyReturn;
+    getUserData(key: GetUserDataKeyParameter): GetUserDataReturn;
+    getFunctionName(): GetFunctionNameReturn;
+    getRunningTimeInSeconds(): GetRunningTimeInSecondsReturn;
+    getVersion(): GetVersionReturn;
+    getMemorySize(): GetMemorySizeReturn;
+    getCPUNumber(): GetCPUNumberReturn;
+    getProjectID(): GetProjectIdReturn;
+    getPackage(): GetPackageReturn;
+    getLogger(): GetLoggerReturn;
+}

package/lib/@types/huawei/huawei-context.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/@types/huawei/index.d.ts

@@ -0,0 +1,3 @@
+export * from './huawei-context';
+export * from './huawei-api-gateway-event';
+export * from './huawei-api-gateway-response';

package/lib/@types/huawei/index.js

@@ -0,0 +1,15 @@
+"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("./huawei-context"), exports);
+__exportStar(require("./huawei-api-gateway-event"), exports);
+__exportStar(require("./huawei-api-gateway-response"), exports);

package/lib/adapters/aws/api-gateway-v2.adapter.js

@@ -73,10 +73,10 @@ class ApiGatewayV2Adapter {
         const transferEncodingHeader = headers['transfer-encoding'];
         const hasTransferEncodingChunked = transferEncodingHeader && transferEncodingHeader.includes('chunked');
         if (hasTransferEncodingChunked) {
-            throw new Error('chunked encoding in headers is not supported by API Gateway V1');
+            throw new Error('chunked encoding in headers is not supported by API Gateway V2');
         }
         if (response === null || response === void 0 ? void 0 : response.chunkedEncoding) {
-            throw new Error('chunked encoding in response is not supported by API Gateway V1');
+            throw new Error('chunked encoding in response is not supported by API Gateway V2');
         }
         const cookies = multiValueHeaders['set-cookie'];
         if (headers)

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

@@ -0,0 +1,27 @@
+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.
+ */
+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/dummy.adapter.js

@@ -0,0 +1,47 @@
+"use strict";
+//#region Imports
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DummyAdapter = void 0;
+const core_1 = require("../../core");
+//#endregion
+/**
+ * The class that represents a dummy adapter that does nothing and can be used by the cloud that doesn't use adapters.
+ */
+class DummyAdapter {
+    /**
+     * @inheritDoc
+     */
+    canHandle() {
+        return true;
+    }
+    /**
+     * @inheritDoc
+     */
+    getAdapterName() {
+        return DummyAdapter.name;
+    }
+    /**
+     * @inheritDoc
+     */
+    getRequest() {
+        return {
+            method: 'POST',
+            body: void 0,
+            path: '/dummy',
+            headers: {},
+        };
+    }
+    /**
+     * @inheritDoc
+     */
+    getResponse() {
+        return core_1.EmptyResponse;
+    }
+    /**
+     * @inheritDoc
+     */
+    onErrorWhileForwarding(props) {
+        props.delegatedResolver.succeed();
+    }
+}
+exports.DummyAdapter = DummyAdapter;

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

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

package/lib/adapters/dummy/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("./dummy.adapter"), exports);

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

@@ -0,0 +1,59 @@
+import { HuaweiApiGatewayEvent, HuaweiContext } from '../../@types/huawei';
+import { HuaweiApiGatewayResponse } from '../../@types/huawei/huawei-api-gateway-response';
+import { AdapterContract, AdapterRequest, GetResponseAdapterProps, OnErrorProps } from '../../contracts';
+/**
+ * The options to customize the {@link HuaweiApiGatewayAdapter}
+ */
+export interface HuaweiApiGatewayOptions {
+    /**
+     * Strip base path for custom domains
+     *
+     * @default ''
+     */
+    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 });
+ * ```
+ *
+ * {@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;
+}

package/lib/adapters/huawei/huawei-api-gateway.adapter.js

@@ -0,0 +1,113 @@
+"use strict";
+//#region Imports
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HuaweiApiGatewayAdapter = void 0;
+const core_1 = require("../../core");
+/**
+ * The adapter to handle requests from Huawei Api Gateway
+ *
+ * @example```typescript
+ * const stripBasePath = '/any/custom/base/path'; // default ''
+ * const adapter = new ApiGatewayAdapter({ stripBasePath });
+ * ```
+ *
+ * {@link https://support.huaweicloud.com/intl/en-us/devg-functiongraph/functiongraph_02_0102.html#functiongraph_02_0102__li5178638110137 Event Reference}
+ */
+class HuaweiApiGatewayAdapter {
+    //#region Constructor
+    /**
+     * Default constructor
+     *
+     * @param options The options to customize the {@link HuaweiApiGatewayAdapter}
+     */
+    constructor(options) {
+        this.options = options;
+    }
+    //#endregion
+    //#region Public Methods
+    /**
+     * @inheritDoc
+     */
+    getAdapterName() {
+        return HuaweiApiGatewayAdapter.name;
+    }
+    /**
+     * @inheritDoc
+     */
+    canHandle(event) {
+        const apiGatewayEvent = event;
+        return !!(apiGatewayEvent &&
+            apiGatewayEvent.httpMethod &&
+            apiGatewayEvent.requestContext &&
+            apiGatewayEvent.requestContext.apiId &&
+            apiGatewayEvent.requestContext.stage &&
+            apiGatewayEvent.requestContext.requestId &&
+            // to avoid conflict with api gateway v1 of aws
+            !('multiValueQueryStringParameters' in apiGatewayEvent));
+    }
+    /**
+     * @inheritDoc
+     */
+    getRequest(event) {
+        const method = event.httpMethod;
+        const path = this.getPathFromEvent(event);
+        const headers = (0, core_1.getFlattenedHeadersMap)(event.headers, ',', true);
+        let body;
+        if (event.body) {
+            const [bufferBody, contentLength] = (0, core_1.getEventBodyAsBuffer)(event.body, event.isBase64Encoded);
+            body = bufferBody;
+            headers['content-length'] = String(contentLength);
+        }
+        const remoteAddress = headers['x-real-ip'];
+        return {
+            method,
+            headers,
+            body,
+            remoteAddress,
+            path,
+        };
+    }
+    /**
+     * @inheritDoc
+     */
+    getResponse({ headers: responseHeaders, body, isBase64Encoded, statusCode, }) {
+        const headers = (0, core_1.getMultiValueHeadersMap)(responseHeaders);
+        return {
+            statusCode,
+            body,
+            headers,
+            isBase64Encoded,
+        };
+    }
+    /**
+     * @inheritDoc
+     */
+    onErrorWhileForwarding({ error, delegatedResolver, respondWithErrors, event, log, }) {
+        const body = respondWithErrors ? error.stack : '';
+        const errorResponse = this.getResponse({
+            event,
+            statusCode: 500,
+            body: body || '',
+            headers: {},
+            isBase64Encoded: false,
+            log,
+        });
+        delegatedResolver.succeed(errorResponse);
+    }
+    //#endregion
+    //#region Protected Methods
+    /**
+     * Get path from event with query strings
+     *
+     * @param event The event sent by serverless
+     */
+    getPathFromEvent(event) {
+        var _a;
+        const stripBasePath = (0, core_1.getDefaultIfUndefined)((_a = this.options) === null || _a === void 0 ? void 0 : _a.stripBasePath, '');
+        const replaceRegex = new RegExp(`^${stripBasePath}`);
+        const path = event.path.replace(replaceRegex, '');
+        const queryParams = event.queryStringParameters;
+        return (0, core_1.getPathWithQueryStringParams)(path, queryParams);
+    }
+}
+exports.HuaweiApiGatewayAdapter = HuaweiApiGatewayAdapter;

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

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

package/lib/adapters/huawei/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("./huawei-api-gateway.adapter"), exports);

package/lib/frameworks/lazy/index.js

@@ -0,0 +1 @@
+"use strict";

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

@@ -0,0 +1,51 @@
+/// <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();
+ * ```
+ */
+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/lazy/lazy.framework.js

@@ -0,0 +1,70 @@
+"use strict";
+//#region Imports
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LazyFramework = void 0;
+const core_1 = require("../../core");
+//#endregion
+/**
+ * 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();
+ * ```
+ */
+class LazyFramework {
+    //#region Constructor
+    /**
+     * Default Constructor
+     */
+    constructor(framework, factory, logger = (0, core_1.createDefaultLogger)()) {
+        this.framework = framework;
+        this.factory = factory;
+        this.logger = logger;
+        this.delayedFactory = Promise.resolve()
+            .then(() => factory())
+            .then(app => {
+            this.cachedApp = app;
+        })
+            .catch((error) => {
+            // deal with the error only when receive some request
+            // to be able to return some message to user
+            this.logger.error('SERVERLESS_ADAPTER:LAZY_FRAMEWORK: An error occours during the creation of your app.');
+            this.logger.error(error);
+        });
+    }
+    //#endregion
+    //#region Public Methods
+    /**
+     * @inheritDoc
+     */
+    sendRequest(app, request, response) {
+        if (this.cachedApp)
+            return this.framework.sendRequest(this.cachedApp, request, response);
+        this.delayedFactory.then(() => {
+            if (!this.cachedApp) {
+                return response.emit('error', new Error('SERVERLESS_ADAPTER:LAZY_FRAMEWORK: The instance of the app returned by the factory is not valid, see the logs to learn more.'));
+            }
+            return this.framework.sendRequest(this.cachedApp, request, response);
+        });
+    }
+}
+exports.LazyFramework = LazyFramework;

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

@@ -1,7 +1,6 @@
 import { BinarySettings, SingleValueHeaders } from '../../@types';
 import { AdapterContract, AdapterRequest, FrameworkContract, ResolverContract, ServerlessHandler } from '../../contracts';
-import { ILogger } from '../../core';
-import { BaseHandler } from '../../core/base-handler';
+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

package/lib/handlers/default/default.handler.js

@@ -16,13 +16,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.DefaultHandler = void 0;
 const util_1 = __importDefault(require("util"));
 const core_1 = require("../../core");
-const base_handler_1 = require("../../core/base-handler");
 const network_1 = require("../../network");
 //#endregion
 /**
  * The class that implements a default serverless handler consisting of a function with event, context and callback parameters respectively
  */
-class DefaultHandler extends base_handler_1.BaseHandler {
+class DefaultHandler extends core_1.BaseHandler {
     //#region Public Methods
     /**
      * @inheritDoc

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

@@ -0,0 +1,49 @@
+/// <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}
+ */
+export declare const DEFAULT_HUAWEI_LISTEN_PORT: number;
+/**
+ * The options to customize {@link HttpHuaweiHandler}
+ */
+export declare type HttpHuaweiHandlerOptions = {
+    /**
+     * @default {@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
+ */
+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;
+}

package/lib/handlers/huawei/http-huawei.handler.js

@@ -0,0 +1,82 @@
+"use strict";
+//#region Imports
+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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpHuaweiHandler = exports.DEFAULT_HUAWEI_LISTEN_PORT = void 0;
+const http = __importStar(require("http"));
+const core_1 = require("../../core");
+//#endregion
+/**
+ * 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}
+ */
+exports.DEFAULT_HUAWEI_LISTEN_PORT = 8000;
+/**
+ * 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
+ */
+class HttpHuaweiHandler {
+    //#region Constructor
+    /**
+     * Construtor padrão
+     */
+    constructor(options) {
+        this.options = options;
+    }
+    //#endregion
+    //#region Public Methods
+    /**
+     * @inheritDoc
+     */
+    getHandler(app, framework, _, __, binarySettings, respondWithErrors, log) {
+        var _a, _b;
+        const requestListener = (req, res) => {
+            framework.sendRequest(app, req, res);
+        };
+        const server = (0, core_1.getDefaultIfUndefined)((_a = this.options) === null || _a === void 0 ? void 0 : _a.httpServerFactory, this.createHttpServer.bind(this))(requestListener);
+        const port = (0, core_1.getDefaultIfUndefined)((_b = this.options) === null || _b === void 0 ? void 0 : _b.port, exports.DEFAULT_HUAWEI_LISTEN_PORT);
+        server.listen(port, () => {
+            log.debug('SERVERLESS_ADAPTER:PROXY: Server started.');
+            log.debug(`SERVERLESS_ADAPTER:PROXY: Listening the Huawei Requests in port ${port}`);
+        });
+        return () => {
+            log.debug('SERVERLESS_ADAPTER:PROXY: Disposing the server');
+            return new Promise((resolve, reject) => {
+                server.close(err => (err ? reject(err) : resolve()));
+            });
+        };
+    }
+    //#endregion
+    //#region Protected Methods
+    /**
+     * The method that creates the instance of http server
+     *
+     * @param requestListener O método que lidará com as requisições recebidas
+     */
+    createHttpServer(requestListener) {
+        return http.createServer(requestListener);
+    }
+}
+exports.HttpHuaweiHandler = HttpHuaweiHandler;

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

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

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

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

@@ -0,0 +1,10 @@
+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.
+ */
+export declare class DummyResolver implements ResolverContract<any, any, any, any, any> {
+    /**
+     * @inheritDoc
+     */
+    createResolver(): Resolver<any, void>;
+}

package/lib/resolvers/dummy/dummy.resolver.js

@@ -0,0 +1,19 @@
+"use strict";
+//#region Imports
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DummyResolver = void 0;
+//#endregion
+/**
+ * The class that represents a dummy resolver that does nothing and can be used by the cloud that doesn't use resolvers.
+ */
+class DummyResolver {
+    /**
+     * @inheritDoc
+     */
+    createResolver() {
+        return {
+            run: () => Promise.resolve(),
+        };
+    }
+}
+exports.DummyResolver = DummyResolver;

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

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

package/lib/resolvers/dummy/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("./dummy.resolver"), exports);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@h4ad/serverless-adapter",
-  "version": "2.0.3",
+  "version": "2.3.0",
   "description": "This library enables you to utilize any Cloud or Event Source to respond to web and API requests using your existing Node.js application framework.",
   "main": "./lib/index.js",
   "files": [
@@ -46,7 +46,9 @@
     "hapi",
     "fastify",
     "node.js",
-    "http"
+    "http",
+    "huawei",
+    "functiongraph"
   ],
   "bugs": {
     "url": "https://github.com/H4ad/serverless-adapter/issues"
@@ -57,6 +59,7 @@
     "@types/body-parser": "^1.19.2",
     "@types/jest": "^27.4.0",
     "@types/node": "12.20.43",
+    "@types/supertest": "^2.0.12",
     "@typescript-eslint/eslint-plugin": "^5.12.1",
     "@typescript-eslint/parser": "^5.12.1",
     "body-parser": "^1.19.1",
@@ -75,6 +78,7 @@
     "prettier": "^2.5.1",
     "semantic-release": "^19.0.2",
     "stream-mock": "^2.0.5",
+    "supertest": "^6.2.3",
     "ts-jest": "^27.1.3",
     "ts-node": "^10.4.0",
     "typescript": "^4.5.5"