allserver 1.2.0 → 2.0.0

package/README.md

@@ -12,6 +12,7 @@ Superpowers the `Allserver` gives you:
 - Run your HTTP server as gRPC with a single line change (almost).
 - Serve same logic via HTTP and gRPC (or more) simultaneously in the same node.js process.
 - Deploy and run your HTTP server on AWS Lambda with no code changes.
+- Embed same exact code into your existing Express.js, no need to implement any handlers/middleware.
 - Use Redis-backed job queue [BullMQ](https://docs.bullmq.io) to call remote procedures reliably.
 - And moar!
 
@@ -143,15 +144,21 @@ Please note, that Allserver depends only on a single tiny npm module [`stampit`]
 
 The default `HttpTransport` is using the [`micro`](http://npmjs.com/package/micro) npm module as an optional dependency.
 
-```shell script
-npm i allserver micro
+```shell
+npm i allserver micro@10
+```
+
+Alternatively, you can embed Allserver into your existing Express.js application:
+
+```shell
+npm i allserver express
 ```
 
 #### Client
 
 Optionally, you can use Allserver's built-in client:
 
-```shell script
+```shell
 npm i allserver node-fetch
 ```
 
@@ -163,7 +170,7 @@ Or do HTTP requests using any module you like.
 
 No dependencies other than `allserver` itself.
 
-```shell script
+```shell
 npm i allserver
 ```
 
@@ -177,7 +184,7 @@ Same as the HTTP protocol client above.
 
 The default `GrpcTransport` is using the standard the [`@grpc/grpc-js`](https://www.npmjs.com/package/@grpc/grpc-js) npm module as an optional dependency.
 
-```shell script
+```shell
 npm i allserver @grpc/grpc-js@1 @grpc/proto-loader@0.5
 ```
 
@@ -187,7 +194,7 @@ Note, with gRPC server and client you'd need to have your own `.proto` file. See
 
 Optionally, you can use Allserver's built-in client:
 
-```shell script
+```shell
 npm i allserver @grpc/grpc-js@1 @grpc/proto-loader@0.5
 ```
 
@@ -199,7 +206,7 @@ Or do gRPC requests using any module you like.
 
 The default `BullmqTransport` is using the [`bullmq`](https://www.npmjs.com/package/bullmq) module as a dependency, connects to Redis using `Worker` class.
 
-```shell script
+```shell
 npm i allserver bullmq
 ```
 
@@ -207,7 +214,7 @@ npm i allserver bullmq
 
 Optionally, you can use Allserver's built-in client:
 
-```shell script
+```shell
 npm i allserver bullmq
 ```
 
@@ -332,6 +339,23 @@ const procedures = {
 
 More info can be found in the [`micro`](http://npmjs.com/package/micro) NPM module docs.
 
+### HTTP server in Express.js
+
+Doesn't require a dedicated client transport. Use the HTTP client below.
+
+NB: not yet tested in production.
+
+```js
+const { Allserver, ExpressTransport } = require("allserver");
+
+const middleware = Allserver({
+  procedures,
+  transport: ExpressTransport(),
+}).start();
+
+app.use("/route-with-allsever", middleware);
+```
+
 ### HTTP server in AWS Lambda
 
 Doesn't require a dedicated client transport. Use the HTTP client below.
@@ -365,7 +389,7 @@ exports = Allserver({
 
 You'd need to install `node-fetch` optional dependency.
 
-```shell script
+```shell
 npm i allserver node-fetch
 ```
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "allserver",
-  "version": "1.2.0",
+  "version": "2.0.0",
   "description": "Multi-protocol simple RPC server and [optional] client. Boilerplate-less. Opinionated. Minimalistic. DX-first.",
   "main": "src/index.js",
   "scripts": {
@@ -31,15 +31,44 @@
   "homepage": "https://github.com/flash-oss/allserver",
   "author": "Vasyl Boroviak",
   "license": "MIT",
+  "peerDependencies": {
+    "@grpc/grpc-js": "^1.1.7",
+    "@grpc/proto-loader": "^0.7.5",
+    "bullmq": "^3.10.1",
+    "express": "^4.18.2",
+    "micro": "^10.0.1",
+    "node-fetch": "^2.6.9"
+  },
+  "peerDependenciesMeta": {
+    "@grpc/grpc-js": {
+      "optional": true
+    },
+    "@grpc/proto-loader": {
+      "optional": true
+    },
+    "bullmq": {
+      "optional": true
+    },
+    "express": {
+      "optional": true
+    },
+    "micro": {
+      "optional": true
+    },
+    "node-fetch": {
+      "optional": true
+    }
+  },
   "devDependencies": {
     "@grpc/grpc-js": "^1.1.7",
-    "@grpc/proto-loader": "^0.5.5",
-    "bullmq": "^3.5.7",
+    "@grpc/proto-loader": "^0.7.5",
+    "bullmq": "^3.10.1",
     "eslint": "^7.9.0",
+    "express": "^4.18.2",
     "lambda-local": "^1.7.3",
-    "micro": "^9.3.4",
+    "micro": "^10.0.1",
     "mocha": "^10.2.0",
-    "node-fetch": "^2.6.1",
+    "node-fetch": "^2.6.9",
     "nyc": "^15.1.0",
     "prettier": "^2.1.1"
   },

package/src/client/HttpClientTransport.js

@@ -5,8 +5,10 @@ module.exports = require("./ClientTransport").compose({
 
     props: {
         // eslint-disable-next-line no-undef
-        fetch: (typeof self !== "undefined" && self.fetch) || require("node-fetch"),
-        headers: {},
+        fetch: (typeof globalThis !== "undefined" && globalThis.fetch) || require("node-fetch"),
+        headers: {
+            "Content-Type": "application/json; charset=utf-8",
+        },
     },
 
     init({ headers, fetch }) {
@@ -29,7 +31,8 @@ module.exports = require("./ClientTransport").compose({
                 response = await this.fetch(this.uri + procedureName, http);
                 http.response = response;
             } catch (err) {
-                if (err.code === "ECONNREFUSED") err.noNetToServer = true;
+                if (err.code === "ECONNREFUSED" || (err.cause && err.cause.code === "ECONNREFUSED"))
+                    err.noNetToServer = true;
                 throw err;
             }
 

package/src/index.js

@@ -11,6 +11,9 @@ module.exports = {
     get HttpTransport() {
         return require("./server/HttpTransport");
     },
+    get ExpressTransport() {
+        return require("./server/ExpressTransport");
+    },
     get LambdaTransport() {
         return require("./server/LambdaTransport");
     },

package/src/server/ExpressTransport.js

@@ -0,0 +1,74 @@
+const { parse: parseUrl } = require("url");
+
+module.exports = require("./Transport").compose({
+    name: "ExpressTransport",
+
+    props: {
+        _express: require("express"),
+    },
+
+    methods: {
+        async deserializeRequest(ctx) {
+            if (ctx.http.req.deserializationFailed) return false;
+            // If there is no body we will use request query (aka search params)
+            let arg = ctx.http.query;
+            if (ctx.http.req.body && Object.keys(ctx.http.req.body).length > 0) arg = ctx.http.req.body;
+            ctx.arg = arg;
+            return true;
+        },
+
+        async _handleRequest(ctx) {
+            if (await this.deserializeRequest(ctx)) {
+                await ctx.allserver.handleCall(ctx);
+            } else {
+                // HTTP protocol request was malformed (not expected structure).
+                // We are not going to process it.
+                ctx.result = { success: false, code: "ALLSERVER_BAD_REQUEST", message: "Can't parse JSON" };
+                ctx.http.statusCode = 400;
+                this.reply(ctx);
+            }
+        },
+
+        startServer(defaultCtx) {
+            return [
+                this._express.json(),
+                (err, req, res, next) => {
+                    if (err.statusCode) req.deserializationFailed = err; // overriding the error, processing the request as normal
+                    next();
+                },
+                async (req, res) => {
+                    const ctx = {
+                        ...defaultCtx,
+                        http: { req, res, query: req.query || {} },
+                    };
+
+                    await this._handleRequest(ctx);
+                },
+            ];
+        },
+
+        getProcedureName(ctx) {
+            return parseUrl(ctx.http.req.url).pathname.substr(1);
+        },
+
+        isIntrospection(ctx) {
+            return this.getProcedureName(ctx) === "";
+        },
+
+        prepareNotFoundReply(ctx) {
+            ctx.http.statusCode = 404;
+        },
+        prepareProcedureErrorReply(ctx) {
+            // Generic exception.
+            ctx.http.statusCode = 500;
+
+            // nodejs assert() exception. In HTTP world this likely means 400 "Bad Request".
+            if (ctx.error.code === "ERR_ASSERTION") ctx.http.statusCode = 400;
+        },
+
+        reply(ctx) {
+            if (!ctx.http.statusCode) ctx.http.statusCode = 200;
+            ctx.http.res.status(ctx.http.statusCode).json(ctx.result);
+        },
+    },
+});

package/src/server/HttpTransport.js

@@ -1,3 +1,4 @@
+const http = require("http");
 const { parse: parseUrl, URLSearchParams } = require("url");
 
 module.exports = require("./Transport").compose({
@@ -39,22 +40,27 @@ module.exports = require("./Transport").compose({
         },
 
         startServer(defaultCtx) {
-            this.server = this.micro(async (req, res) => {
-                const ctx = { ...defaultCtx, http: { req, res, url: parseUrl(req.url) } };
+            this.server = new http.Server(
+                this.micro.serve(async (req, res) => {
+                    const ctx = { ...defaultCtx, http: { req, res, url: parseUrl(req.url) } };
 
-                ctx.http.query = {};
-                if (ctx.http.url.query) {
-                    for (const [key, value] of new URLSearchParams(ctx.http.url.query).entries()) {
-                        ctx.http.query[key] = value;
+                    ctx.http.query = {};
+                    if (ctx.http.url.query) {
+                        for (const [key, value] of new URLSearchParams(ctx.http.url.query).entries()) {
+                            ctx.http.query[key] = value;
+                        }
                     }
-                }
 
-                await this._handleRequest(ctx);
-            });
+                    await this._handleRequest(ctx);
+                })
+            );
             return new Promise((r) => this.server.listen(this.port, r));
         },
         stopServer() {
-            return new Promise((r) => this.server.close(r));
+            return new Promise((r) => {
+                if (this.server.closeIdleConnections) this.server.closeIdleConnections();
+                this.server.close(r);
+            });
         },
 
         getProcedureName(ctx) {