allserver 2.2.1 → 2.3.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");
 
@@ -913,7 +911,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.3.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

@@ -263,6 +263,10 @@ module.exports = require("stampit")({
         },
 
         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);

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) {