allserver 2.2.1 → 2.4.0

package/README.md

@@ -361,8 +361,6 @@ app.use("/route-with-allsever", middleware);
 
 Doesn't require a dedicated client transport. Use the HTTP client below.
 
-NB: not yet tested in production.
-
 ```js
 const { Allserver, LambdaTransport } = require("allserver");
 
@@ -655,13 +653,11 @@ import { Lambda } from "@aws-sdk/client-lambda";
 const invocationResponse = await new Lambda().invoke({
   FunctionName: "my-lambda-name",
   Payload: JSON.stringify({
+    _: { procedureName: "updateUser" },
     id: "123412341234123412341234",
     firstName: "Fred",
     lastName: "Flinstone",
   }),
-  ClientContext: JSON.stringify({
-    procedureName: "updateUser",
-  }),
 });
 const { success, code, message, user } = JSON.parse(invocationResponse.Payload);
 ```
@@ -669,7 +665,7 @@ const { success, code, message, user } = JSON.parse(invocationResponse.Payload);
 Alternatively, you can call the same procedure using the `aws` CLI:
 
 ```shell
-aws lambda invoke --function-name my-lambda-name --client-context '{"procedureName":"updateUser"}' --payload '{"id":"123412341234123412341234","firstName":"Fred","lastName":"Flinstone"}'
+aws lambda invoke --function-name my-lambda-name --payload '{"_":{"procedureName":"updateUser"},"id":"123412341234123412341234","firstName":"Fred","lastName":"Flinstone"}}'
 ```
 
 ## `AllserverClient` options
@@ -913,7 +909,7 @@ const client = AllserverClient({
     ctx.http.headers.authorization = "Basic my-token";
   },
   async after(ctx) {
-    if (ctx.error) console.error(ctx.error) else console.log(ctx.result);
+    if (ctx.error) console.error(ctx.error); else console.log(ctx.result);
   },
 });
 ```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "allserver",
-  "version": "2.2.1",
+  "version": "2.4.0",
   "description": "Multi-protocol simple RPC server and [optional] client. Boilerplate-less. Opinionated. Minimalistic. DX-first.",
   "main": "src/index.js",
   "scripts": {
@@ -65,6 +65,7 @@
     "@grpc/grpc-js": "^1.1.7",
     "@grpc/proto-loader": "^0.7.5",
     "bullmq": "^3.10.1",
+    "cls-hooked": "^4.2.2",
     "eslint": "^8.55.0",
     "express": "^4.18.2",
     "lambda-local": "^1.7.3",

package/src/client/AllserverClient.js

@@ -213,40 +213,55 @@ module.exports = require("stampit")({
             const defaultCtx = { client: this, isIntrospection: true };
             const ctx = transport.createCallContext(defaultCtx);
 
-            await this._callMiddlewares(ctx, "before");
-
-            if (!ctx.result) {
-                try {
-                    // This is supposed to be executed only once (per uri) unless it throws.
-                    // There are only 3 situations when this throws:
-                    // * the "introspect" method not found on server,
-                    // * the network request is malformed,
-                    // * couldn't connect to the remote host.
-                    ctx.result = await transport.introspect(ctx);
-                } catch (err) {
-                    ctx.result = {
-                        success: false,
-                        code: "ALLSERVER_CLIENT_INTROSPECTION_FAILED",
-                        message: `Couldn't introspect ${transport.uri} due to: ${err.message}`,
-                        noNetToServer: Boolean(err.noNetToServer),
-                        error: err,
-                    };
+            await this._callMiddlewares(ctx, "before", async () => {
+                if (!ctx.result) {
+                    try {
+                        // This is supposed to be executed only once (per uri) unless it throws.
+                        // There are only 3 situations when this throws:
+                        // * the "introspect" method not found on server,
+                        // * the network request is malformed,
+                        // * couldn't connect to the remote host.
+                        ctx.result = await transport.introspect(ctx);
+                    } catch (err) {
+                        ctx.result = {
+                            success: false,
+                            code: "ALLSERVER_CLIENT_INTROSPECTION_FAILED",
+                            message: `Couldn't introspect ${transport.uri} due to: ${err.message}`,
+                            noNetToServer: Boolean(err.noNetToServer),
+                            error: err,
+                        };
+                    }
                 }
-            }
 
-            await this._callMiddlewares(ctx, "after");
+                await this._callMiddlewares(ctx, "after");
+            });
 
             return ctx.result;
         },
 
-        async _callMiddlewares(ctx, middlewareType) {
-            const middlewares = [].concat(this[p][middlewareType]).filter(isFunction);
-            for (const middleware of middlewares) {
-                try {
-                    const result = await middleware.call(this, ctx);
+        async _callMiddlewares(ctx, middlewareType, next) {
+            const runMiddlewares = async (middlewares) => {
+                if (!middlewares?.length) {
+                    // no middlewares to run
+                    if (next) return await next();
+                    return;
+                }
+                const middleware = middlewares[0];
+                async function handleMiddlewareResult(result) {
                     if (result !== undefined) {
                         ctx.result = result;
-                        break;
+                        // Do not call any more middlewares
+                    } else {
+                        await runMiddlewares(middlewares.slice(1));
+                    }
+                }
+                try {
+                    if (middleware.length > 1) {
+                        // This middleware accepts more than one argument
+                        await middleware.call(this, ctx, handleMiddlewareResult);
+                    } else {
+                        const result = await middleware.call(this, ctx);
+                        await handleMiddlewareResult(result);
                     }
                 } catch (err) {
                     if (!this[p].neverThrow) throw err;
@@ -257,34 +272,42 @@ module.exports = require("stampit")({
                         message = `The '${middlewareType}' middleware error while calling '${ctx.procedureName}' procedure: ${err.message}`;
                     }
                     ctx.result = { success: false, code, message, error: err };
-                    return;
+                    // Do not call any more middlewares
+                    if (next) return await next();
                 }
-            }
+            };
+
+            const middlewares = [].concat(this[p][middlewareType]).filter(isFunction);
+            return await runMiddlewares(middlewares);
         },
 
         async call(procedureName, arg) {
+            if (!arg) arg = {};
+            if (!arg._) arg._ = {};
+            arg._.procedureName = procedureName;
+
             const transport = this[p].transport;
             const defaultCtx = { procedureName, arg, client: this };
             const ctx = transport.createCallContext(defaultCtx);
 
-            await this._callMiddlewares(ctx, "before");
-
-            if (!ctx.result) {
-                try {
-                    ctx.result = await transport.call(ctx);
-                } catch (err) {
-                    if (!this[p].neverThrow) throw err;
-
-                    let { code, message } = err;
-                    if (!err.code || err.noNetToServer) {
-                        code = "ALLSERVER_CLIENT_PROCEDURE_UNREACHABLE";
-                        message = `Couldn't reach remote procedure ${ctx.procedureName} due to: ${err.message}`;
+            await this._callMiddlewares(ctx, "before", async () => {
+                if (!ctx.result) {
+                    try {
+                        ctx.result = await transport.call(ctx);
+                    } catch (err) {
+                        if (!this[p].neverThrow) throw err;
+
+                        let { code, message } = err;
+                        if (!err.code || err.noNetToServer) {
+                            code = "ALLSERVER_CLIENT_PROCEDURE_UNREACHABLE";
+                            message = `Couldn't reach remote procedure ${ctx.procedureName} due to: ${err.message}`;
+                        }
+                        ctx.result = { success: false, code, message, error: err };
                     }
-                    ctx.result = { success: false, code, message, error: err };
                 }
-            }
 
-            await this._callMiddlewares(ctx, "after");
+                await this._callMiddlewares(ctx, "after");
+            });
 
             return ctx.result;
         },

package/src/client/LambdaClientTransport.js

@@ -28,12 +28,15 @@ module.exports = require("./ClientTransport").compose({
             return result;
         },
 
-        async call({ procedureName, lambda }) {
+        async call(ctx) {
             let promise = this.awsSdkLambdaClient.invoke({
                 FunctionName: this.uri.substring("lambda://".length),
+                // TODO: change to this during the next major release:
+                //  Payload: JSON.stringify(ctx.arg),
                 Payload: JSON.stringify({
-                    callContext: { ...lambda.callContext, procedureName },
-                    callArg: lambda.callArg,
+                    callContext: { ...ctx.lambda.callContext, procedureName: ctx.procedureName },
+                    callArg: ctx.lambda.callArg,
+                    ...ctx.arg,
                 }),
             });
             if (typeof promise.promise === "function") promise = promise.promise(); // AWS SDK v2 adoption
@@ -44,6 +47,8 @@ module.exports = require("./ClientTransport").compose({
         createCallContext(defaultCtx) {
             return {
                 ...defaultCtx,
+                // TODO: change to this during the next major release:
+                //  lambda: {}
                 lambda: {
                     callContext: {},
                     callArg: defaultCtx.arg,

package/src/server/Allserver.js

@@ -50,6 +50,13 @@ module.exports = require("stampit")({
             await this.transport.prepareIntrospectionReply(ctx);
         },
 
+        /**
+         * This method does not throw.
+         * The `ctx.procedure` is the function to call.
+         * @param ctx
+         * @return {Promise<void>}
+         * @private
+         */
         async _callProcedure(ctx) {
             if (!isFunction(ctx.procedure)) {
                 ctx.result = {
@@ -91,16 +98,29 @@ module.exports = require("stampit")({
             }
         },
 
-        async _callMiddlewares(ctx, middlewareType) {
-            if (!this[middlewareType]) return;
-
-            const middlewares = [].concat(this[middlewareType]).filter(isFunction);
-            for (const middleware of middlewares) {
-                try {
-                    const result = await middleware.call(this, ctx);
+        async _callMiddlewares(ctx, middlewareType, next) {
+            const runMiddlewares = async (middlewares) => {
+                if (!middlewares?.length) {
+                    // no middlewares to run
+                    if (next) return await next();
+                    return;
+                }
+                const middleware = middlewares[0];
+                async function handleMiddlewareResult(result) {
                     if (result !== undefined) {
                         ctx.result = result;
-                        break;
+                        // Do not call any more middlewares
+                    } else {
+                        await runMiddlewares(middlewares.slice(1));
+                    }
+                }
+                try {
+                    if (middleware.length > 1) {
+                        // This middleware accepts more than one argument
+                        await middleware.call(this, ctx, handleMiddlewareResult);
+                    } else {
+                        const result = await middleware.call(this, ctx);
+                        await handleMiddlewareResult(result);
                     }
                 } catch (err) {
                     const code = err.code || "ALLSERVER_MIDDLEWARE_ERROR";
@@ -111,9 +131,14 @@ module.exports = require("stampit")({
                         code,
                         message: `'${err.message}' error in '${middlewareType}' middleware`,
                     };
-                    return;
+                    // Do not call any more middlewares
+                    if (next) return await next();
                 }
-            }
+            };
+
+            const middlewares = [].concat(this[middlewareType]).filter(isFunction);
+
+            return await runMiddlewares(middlewares);
         },
 
         async handleCall(ctx) {
@@ -123,18 +148,22 @@ module.exports = require("stampit")({
             ctx.isIntrospection = this.transport.isIntrospection(ctx);
             if (!ctx.isIntrospection && ctx.procedureName) ctx.procedure = this.procedures[ctx.procedureName];
 
-            await this._callMiddlewares(ctx, "before");
+            if (!ctx.arg) ctx.arg = {};
+            if (!ctx.arg._) ctx.arg._ = {};
+            if (!ctx.arg._.procedureName) ctx.arg._.procedureName = ctx.procedureName;
 
-            if (!ctx.result) {
-                if (ctx.isIntrospection) {
-                    await this._introspect(ctx);
-                } else {
-                    await this._callProcedure(ctx);
+            await this._callMiddlewares(ctx, "before", async () => {
+                if (!ctx.result) {
+                    if (ctx.isIntrospection) {
+                        await this._introspect(ctx);
+                    } else {
+                        await this._callProcedure(ctx);
+                    }
                 }
-            }
 
-            // Warning! This call might overwrite an existing result.
-            await this._callMiddlewares(ctx, "after");
+                // Warning! This call might overwrite an existing result.
+                await this._callMiddlewares(ctx, "after");
+            });
 
             return this.transport.reply(ctx);
         },

package/src/server/LambdaTransport.js

@@ -21,7 +21,9 @@ module.exports = require("./Transport").compose({
                     return false;
                 }
             } else {
-                ctx.arg = ctx.lambda.invoke.callArg || {};
+                // TODO: change to this during the next major release:
+                //  ctx.arg = ctx.lambda.invoke || {};
+                ctx.arg = ctx.lambda.invoke.callArg || ctx.lambda.invoke || {};
                 return true;
             }
         },
@@ -54,7 +56,11 @@ module.exports = require("./Transport").compose({
                             headers: event?.headers,
                         };
                     } else {
-                        lambda.invoke = { callContext: event?.callContext, callArg: event?.callArg };
+                        // TODO: change to this during the next major release:
+                        //  lambda.invoke = event || {};
+                        lambda.invoke = event?.callArg
+                            ? { callContext: event?.callContext, callArg: event?.callArg }
+                            : event || {};
                     }
 
                     this._handleRequest({ ...defaultCtx, lambda });
@@ -64,7 +70,9 @@ module.exports = require("./Transport").compose({
 
         getProcedureName(ctx) {
             const { isHttp, http, invoke } = ctx.lambda;
-            return isHttp ? http.path.substr(1) : invoke.callContext?.procedureName;
+            // TODO: change to this during the next major release:
+            //  return (isHttp ? http.path.substr(1) : invoke._?.procedureName) || ""; // if no procedureName then it's an introspection
+            return isHttp ? http.path.substr(1) : invoke.callContext?.procedureName || invoke._?.procedureName || ""; // if no procedureName then it's an introspection
         },
 
         isIntrospection(ctx) {