allserver 1.2.0 → 1.3.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
+```shell
 npm i allserver micro
 ```
 
+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": "1.3.0",
   "description": "Multi-protocol simple RPC server and [optional] client. Boilerplate-less. Opinionated. Minimalistic. DX-first.",
   "main": "src/index.js",
   "scripts": {
@@ -36,6 +36,7 @@
     "@grpc/proto-loader": "^0.5.5",
     "bullmq": "^3.5.7",
     "eslint": "^7.9.0",
+    "express": "^4.18.2",
     "lambda-local": "^1.7.3",
     "micro": "^9.3.4",
     "mocha": "^10.2.0",

package/src/client/HttpClientTransport.js

@@ -6,7 +6,9 @@ module.exports = require("./ClientTransport").compose({
     props: {
         // eslint-disable-next-line no-undef
         fetch: (typeof self !== "undefined" && self.fetch) || require("node-fetch"),
-        headers: {},
+        headers: {
+            "Content-Type": "application/json; charset=utf-8",
+        },
     },
 
     init({ headers, fetch }) {

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);
+        },
+    },
+});