@h4ad/serverless-adapter 2.0.2 → 2.2.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,7 +57,7 @@ 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';
@@ -70,8 +71,6 @@ export const handler = ServerlessAdapter.new(app)
   .addAdapter(new SQSAdapter())
   .addAdapter(new SNSAdapter())
   .build();
-
-export { handler };
 ```
 
 Too fast? Ok, I can explain.
@@ -140,9 +139,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 +159,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 +300,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/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/lib/serverless-adapter.d.ts

@@ -29,7 +29,7 @@ export declare class ServerlessAdapter<TApp, TEvent, TContext, TCallback, TRespo
     /**
      * Settings for whether the response should be treated as binary or not
      *
-     * @default `contentEncodings` and `contentTypes` are set with {@link DEFAULT_BINARY_ENCODINGS} and {@link DEFAULT_BINARY_ENCODINGS}, respectively.
+     * @default `contentEncodings` and `contentTypes` are set with {@link DEFAULT_BINARY_ENCODINGS} and {@link DEFAULT_BINARY_CONTENT_TYPES}, respectively.
      */
     protected binarySettings: BinarySettings;
     /**

package/lib/serverless-adapter.js

@@ -31,11 +31,11 @@ class ServerlessAdapter {
         /**
          * Settings for whether the response should be treated as binary or not
          *
-         * @default `contentEncodings` and `contentTypes` are set with {@link DEFAULT_BINARY_ENCODINGS} and {@link DEFAULT_BINARY_ENCODINGS}, respectively.
+         * @default `contentEncodings` and `contentTypes` are set with {@link DEFAULT_BINARY_ENCODINGS} and {@link DEFAULT_BINARY_CONTENT_TYPES}, respectively.
          */
         this.binarySettings = {
             contentEncodings: core_1.DEFAULT_BINARY_ENCODINGS,
-            contentTypes: core_1.DEFAULT_BINARY_ENCODINGS,
+            contentTypes: core_1.DEFAULT_BINARY_CONTENT_TYPES,
         };
         /**
          * Indicates whether the error stack should be included in the response or not

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@h4ad/serverless-adapter",
-  "version": "2.0.2",
+  "version": "2.2.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"