allserver 2.0.1 → 2.2.0-0

package/README.md

@@ -176,7 +176,10 @@ npm i allserver
 
 #### Client
 
-Same as the HTTP protocol client above.
+Two ways:
+
+- Same as the HTTP protocol client above.
+- Direct invocation via AWS SDK or AWS CLI.
 
 ### gRPC protocol
 
@@ -369,15 +372,16 @@ exports.handler = Allserver({
 }).start();
 ```
 
-Or, if you want each individual procedure to be the Lambda handler, pass `mapProceduresToExports: true`.
+### Server in Bare AWS Lambda
+
+Invoke directly via AWS SDK or AWS CLI. But better use the LambdaClientTransport (aka `"lambda://"` scheme) below.
 
 ```js
 const { Allserver, LambdaTransport } = require("allserver");
 
-// Note! No `handler` here.
-exports = Allserver({
+exports.handler = Allserver({
   procedures,
-  transport: LambdaTransport({ mapProceduresToExports: true }),
+  transport: LambdaTransport(),
 }).start();
 ```
 
@@ -588,6 +592,86 @@ const data = await job.waitUntilFinished(queueEvents, 30_000);
 const { success, code, message, user } = data;
 ```
 
+### In memory
+
+Sometimes you need to unit test your procedures via the `AllserverClient`. For that we have `MemoryTransport`.
+
+```js
+const { Allserver, MemoryTransport } = require("allserver");
+
+const memoryServer = Allserver({
+  procedures,
+  transport: MemoryTransport(),
+});
+
+const client = memoryServer.start();
+
+const { success, code, message, user } = await client.updateUser({
+  id: "123412341234123412341234",
+  firstName: "Fred",
+  lastName: "Flinstone",
+});
+
+assert(success === true);
+```
+
+### Bare AWS Lambda invocation
+
+First you need to install any of the AWS SDK versions.
+
+```shell
+npm i allserver aws-sdk
+```
+
+or
+
+```shell
+npm i allserver @aws-sdk/client-lambda
+```
+
+The invoke the lambda this way:
+
+```js
+const { AllserverClient } = require("allserver");
+// or
+const AllserverClient = require("allserver/Client");
+
+const client = AllserverClient({ uri: "lambda://my-lambda-name" });
+
+const { success, code, message, user } = await client.updateUser({
+  id: "123412341234123412341234",
+  firstName: "Fred",
+  lastName: "Flinstone",
+});
+```
+
+#### Using AWS SDK
+
+As usual, the client side does not require the Allserver packages at all.
+
+```js
+import { Lambda } from "@aws-sdk/client-lambda";
+
+const invocationResponse = await new Lambda().invoke({
+  FunctionName: "my-lambda-name",
+  Payload: JSON.stringify({
+    id: "123412341234123412341234",
+    firstName: "Fred",
+    lastName: "Flinstone",
+  }),
+  ClientContext: JSON.stringify({
+    procedureName: "updateUser",
+  }),
+});
+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"}'
+```
+
 ## `AllserverClient` options
 
 **All the arguments are optional.** But either `uri` or `transport` must be provided. We are trying to keep the highest possible DX here.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "allserver",
-  "version": "2.0.1",
+  "version": "2.2.0-0",
   "description": "Multi-protocol simple RPC server and [optional] client. Boilerplate-less. Opinionated. Minimalistic. DX-first.",
   "main": "src/index.js",
   "scripts": {
@@ -9,6 +9,8 @@
     "cov": "nyc --reporter=html npm run test"
   },
   "keywords": [
+    "simple",
+    "rpc",
     "http",
     "grpc",
     "websocket",
@@ -63,7 +65,7 @@
     "@grpc/grpc-js": "^1.1.7",
     "@grpc/proto-loader": "^0.7.5",
     "bullmq": "^3.10.1",
-    "eslint": "^7.9.0",
+    "eslint": "^8.55.0",
     "express": "^4.18.2",
     "lambda-local": "^1.7.3",
     "micro": "^10.0.1",
@@ -77,7 +79,7 @@
   },
   "eslintConfig": {
     "parserOptions": {
-      "ecmaVersion": 2019
+      "ecmaVersion": 2022
     },
     "env": {
       "es6": true,

package/src/client/AllserverClient.js

@@ -165,6 +165,7 @@ module.exports = require("stampit")({
             https() { return require("./HttpClientTransport"); },
             grpc() { return require("./GrpcClientTransport"); },
             bullmq() { return require("./BullmqClientTransport"); },
+            lambda() { return require("./LambdaClientTransport"); },
         },
     },
 

package/src/client/LambdaClientTransport.js

@@ -0,0 +1,58 @@
+module.exports = require("./ClientTransport").compose({
+    name: "LambdaClientTransport",
+
+    props: {
+        awsSdkLambdaClient: null,
+    },
+
+    init() {
+        if (!this.awsSdkLambdaClient) {
+            let Lambda;
+            try {
+                Lambda = require("aws-sdk").Lambda; // AWS SDK v2 adoption
+            } catch {
+                Lambda = require("@aws-sdk/client-lambda").Lambda;
+            }
+
+            this.awsSdkLambdaClient = new Lambda();
+        }
+    },
+
+    methods: {
+        async introspect(ctx) {
+            ctx.procedureName = "";
+            const result = await this.call(ctx);
+            // The server-side Transport will not have the call result if introspection is not available on the server side,
+            // but the server itself is up and running processing calls.
+            if (!result.procedures) throw Error("The lambda introspection call returned nothing"); // The ClientTransport expects us to throw if call fails
+            return result;
+        },
+
+        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"),
+            });
+            if (typeof promise.promise === "function") promise = promise.promise(); // AWS SDK v2 adoption
+            const invocationResponse = await promise;
+            return JSON.parse(invocationResponse.Payload);
+        },
+
+        createCallContext(defaultCtx) {
+            return {
+                ...defaultCtx,
+                lambda: {
+                    clientContext: {},
+                    payload: defaultCtx.arg,
+                },
+            };
+        },
+    },
+});

package/src/client/MemoryClientTransport.js

@@ -0,0 +1,29 @@
+module.exports = require("./ClientTransport").compose({
+    name: "MemoryClientTransport",
+
+    props: {
+        _allserverContext: null,
+        uri: "memory",
+    },
+
+    init({ allserverContext }) {
+        this._allserverContext = allserverContext || this._allserverContext;
+    },
+
+    methods: {
+        async introspect(ctx) {
+            ctx.procedureName = "";
+            const result = await this.call(ctx);
+            if (!result) throw Error(); // The ClientTransport expects us to throw if call fails
+            return result;
+        },
+
+        async call(ctx) {
+            return this._allserverContext.allserver.handleCall(ctx);
+        },
+
+        createCallContext(defaultCtx) {
+            return { ...defaultCtx, ...this._allserverContext, memory: {} };
+        },
+    },
+});

package/src/index.js

@@ -23,6 +23,9 @@ module.exports = {
     get BullmqTransport() {
         return require("./server/BullmqTransport");
     },
+    get MemoryTransport() {
+        return require("./server/MemoryTransport");
+    },
 
     // client
 
@@ -41,4 +44,10 @@ module.exports = {
     get BullmqClientTransport() {
         return require("./client/BullmqClientTransport");
     },
+    get MemoryClientTransport() {
+        return require("./client/MemoryClientTransport");
+    },
+    get LambdaClientTransport() {
+        return require("./client/LambdaClientTransport");
+    },
 };

package/src/server/LambdaTransport.js

@@ -1,30 +1,26 @@
 module.exports = require("./Transport").compose({
     name: "LambdaTransport",
 
-    props: {
-        _mapProceduresToExports: false,
-    },
-
-    init({ mapProceduresToExports }) {
-        this._mapProceduresToExports = mapProceduresToExports || this._mapProceduresToExports;
-    },
-
     methods: {
-        async deserializeRequest(ctx) {
-            const body = ctx.lambda.event.body;
-            let arg = ctx.lambda.query;
-            try {
-                // If there is no body we will use request query (aka search params)
-                if (body) arg = JSON.parse(body);
-                ctx.arg = arg;
+        async deserializeEvent(ctx) {
+            if (ctx.lambda.isHttp) {
+                const body = ctx.lambda.event.body;
+                let query = ctx.lambda.query;
+                try {
+                    // If there is no body we will use request query (aka search params)
+                    ctx.arg = body ? JSON.parse(body) : query;
+                    return true;
+                } catch (err) {
+                    return false;
+                }
+            } else {
+                ctx.arg = ctx.lambda.event || {};
                 return true;
-            } catch (err) {
-                return false;
             }
         },
 
         async _handleRequest(ctx) {
-            if (await this.deserializeRequest(ctx)) {
+            if (await this.deserializeEvent(ctx)) {
                 await ctx.allserver.handleCall(ctx);
             } else {
                 // HTTP protocol request was malformed (not expected structure).
@@ -36,37 +32,21 @@ module.exports = require("./Transport").compose({
         },
 
         startServer(defaultCtx) {
-            if (this._mapProceduresToExports) {
-                const exports = {};
-                for (const procedureName of Object.keys(defaultCtx.allserver.procedures)) {
-                    exports[procedureName] = async (event) =>
-                        new Promise((resolve) => {
-                            const path = "/" + procedureName;
-                            const ctx = {
-                                ...defaultCtx,
-                                lambda: { event, resolve, path, query: { ...(event.queryStringParameters || {}) } },
-                            };
-
-                            this._handleRequest(ctx);
-                        });
-                }
-                return exports;
-            }
-
-            return async (event) => {
+            return async (event, context) => {
                 return new Promise((resolve) => {
-                    const ctx = {
-                        ...defaultCtx,
-                        lambda: { event, resolve, path: event.path, query: { ...(event.queryStringParameters || {}) } },
-                    };
+                    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 };
 
-                    this._handleRequest(ctx);
+                    this._handleRequest({ ...defaultCtx, lambda });
                 });
             };
         },
 
-        getProcedureName(ctx) {
-            return ctx.lambda.path.substr(1);
+        getProcedureName({ lambda: { procedureName } }) {
+            return procedureName;
         },
 
         isIntrospection(ctx) {
@@ -85,12 +65,16 @@ module.exports = require("./Transport").compose({
         },
 
         reply(ctx) {
-            if (!ctx.lambda.statusCode) ctx.lambda.statusCode = 200;
-            ctx.lambda.resolve({
-                statusCode: ctx.lambda.statusCode,
-                headers: { "content-type": "application/json" },
-                body: JSON.stringify(ctx.result),
-            });
+            if (ctx.lambda.isHttp) {
+                if (!ctx.lambda.statusCode) ctx.lambda.statusCode = 200;
+                ctx.lambda.resolve({
+                    statusCode: ctx.lambda.statusCode,
+                    headers: { "content-type": "application/json" },
+                    body: JSON.stringify(ctx.result),
+                });
+            } else {
+                ctx.lambda.resolve(ctx.result);
+            }
         },
     },
 });

package/src/server/MemoryTransport.js

@@ -0,0 +1,28 @@
+module.exports = require("./Transport").compose({
+    name: "MemoryTransport",
+
+    props: {
+        AllserverClient: require("../client/AllserverClient"),
+        MemoryClientTransport: require("../client/MemoryClientTransport"),
+    },
+
+    methods: {
+        startServer(defaultCtx) {
+            return this.AllserverClient({
+                transport: this.MemoryClientTransport({ allserverContext: { ...defaultCtx, memory: {} } }),
+            });
+        },
+
+        reply(ctx) {
+            return ctx.result;
+        },
+
+        getProcedureName(ctx) {
+            return ctx.procedureName;
+        },
+
+        isIntrospection(ctx) {
+            return this.getProcedureName(ctx) === "";
+        },
+    },
+});