allserver 2.2.0-0 → 2.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "allserver",
-  "version": "2.2.0-0",
+  "version": "2.2.0",
   "description": "Multi-protocol simple RPC server and [optional] client. Boilerplate-less. Opinionated. Minimalistic. DX-first.",
   "main": "src/index.js",
   "scripts": {

package/src/client/LambdaClientTransport.js

@@ -31,14 +31,10 @@ module.exports = require("./ClientTransport").compose({
         async call({ procedureName, lambda }) {
             let promise = this.awsSdkLambdaClient.invoke({
                 FunctionName: this.uri.substring("lambda://".length),
-                // InvocationType: "RequestResponse",
-                Payload: lambda.payload && JSON.stringify(lambda.payload),
-                ClientContext: Buffer.from(
-                    JSON.stringify({
-                        ...lambda.clientContext,
-                        procedureName,
-                    })
-                ).toString("base64"),
+                Payload: JSON.stringify({
+                    callContext: { ...lambda.callContext, procedureName },
+                    callArg: lambda.callArg,
+                }),
             });
             if (typeof promise.promise === "function") promise = promise.promise(); // AWS SDK v2 adoption
             const invocationResponse = await promise;
@@ -49,8 +45,8 @@ module.exports = require("./ClientTransport").compose({
             return {
                 ...defaultCtx,
                 lambda: {
-                    clientContext: {},
-                    payload: defaultCtx.arg,
+                    callContext: {},
+                    callArg: defaultCtx.arg,
                 },
             };
         },

package/src/server/LambdaTransport.js

@@ -4,17 +4,24 @@ module.exports = require("./Transport").compose({
     methods: {
         async deserializeEvent(ctx) {
             if (ctx.lambda.isHttp) {
-                const body = ctx.lambda.event.body;
-                let query = ctx.lambda.query;
+                const { body, query } = ctx.lambda.http;
                 try {
                     // If there is no body we will use request query (aka search params)
-                    ctx.arg = body ? JSON.parse(body) : query;
+                    if (!body) {
+                        ctx.arg = query || {};
+                    } else {
+                        if ((typeof body === "string" && body[0] === "{") || Buffer.isBuffer(body)) {
+                            ctx.arg = JSON.parse(body);
+                        } else {
+                            return false;
+                        }
+                    }
                     return true;
                 } catch (err) {
                     return false;
                 }
             } else {
-                ctx.arg = ctx.lambda.event || {};
+                ctx.arg = ctx.lambda.invoke.callArg || {};
                 return true;
             }
         },
@@ -34,19 +41,30 @@ module.exports = require("./Transport").compose({
         startServer(defaultCtx) {
             return async (event, context) => {
                 return new Promise((resolve) => {
+                    const lambda = { event, context, resolve };
+
                     const path = (event && (event.path || event.requestContext?.http?.path)) || undefined;
-                    const isHttp = Boolean(path);
-                    const procedureName = isHttp ? path.substr(1) : context.clientContext?.procedureName;
-                    const query = { ...(event?.queryStringParameters || {}) };
-                    const lambda = { resolve, isHttp, event, context, path, query, procedureName };
+                    lambda.isHttp = Boolean(path);
+
+                    if (lambda.isHttp) {
+                        lambda.http = {
+                            path,
+                            query: event?.queryStringParameters,
+                            body: event?.body,
+                            headers: event?.headers,
+                        };
+                    } else {
+                        lambda.invoke = { callContext: event?.callContext, callArg: event?.callArg };
+                    }
 
                     this._handleRequest({ ...defaultCtx, lambda });
                 });
             };
         },
 
-        getProcedureName({ lambda: { procedureName } }) {
-            return procedureName;
+        getProcedureName(ctx) {
+            const { isHttp, http, invoke } = ctx.lambda;
+            return isHttp ? http.path.substr(1) : invoke.callContext?.procedureName;
         },
 
         isIntrospection(ctx) {