@h4ad/serverless-adapter 2.0.1 → 2.1.0

package/README.md

@@ -19,7 +19,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 +56,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 +70,6 @@ export const handler = ServerlessAdapter.new(app)
   .addAdapter(new SQSAdapter())
   .addAdapter(new SNSAdapter())
   .build();
-
-export { handler };
 ```
 
 Too fast? Ok, I can explain.
@@ -140,9 +138,14 @@ 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): Work in progress.
 - 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 +157,66 @@ 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, currently we only added support to FunctionGraphV2 with Http Function type.
+
+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
+
+Work in progress.
 
 # Architecture
 
@@ -207,6 +270,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/adapters/aws/api-gateway-v2.adapter.js

@@ -69,6 +69,7 @@ class ApiGatewayV2Adapter {
      */
     getResponse({ headers: responseHeaders, body, isBase64Encoded, statusCode, response, }) {
         const headers = (0, core_1.getFlattenedHeadersMap)(responseHeaders);
+        const multiValueHeaders = (0, core_1.getMultiValueHeadersMap)(responseHeaders);
         const transferEncodingHeader = headers['transfer-encoding'];
         const hasTransferEncodingChunked = transferEncodingHeader && transferEncodingHeader.includes('chunked');
         if (hasTransferEncodingChunked) {
@@ -77,16 +78,15 @@ class ApiGatewayV2Adapter {
         if (response === null || response === void 0 ? void 0 : response.chunkedEncoding) {
             throw new Error('chunked encoding in response is not supported by API Gateway V1');
         }
-        const cookies = headers['set-cookie'];
-        if (cookies) {
-            headers.cookies = cookies;
+        const cookies = multiValueHeaders['set-cookie'];
+        if (headers)
             delete headers['set-cookie'];
-        }
         return {
             statusCode,
             body,
             headers,
             isBase64Encoded,
+            cookies,
         };
     }
     /**

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/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/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.1",
+  "version": "2.1.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"