fix serverless adapter, refactor wasm interop

Author: tysonrm

src/adapters/serverless/index.js

@@ -1,12 +1,13 @@
 import { makeServerlessAdapter } from './serverless-adapter'
 import * as localParsers from './parsers'
 
-const getRemoteParsers = async () => import('aegis-services/parsers')``
+//const getRemoteParsers = async () => import('aegis-services/parsers')``
 export const getParsers = async function () {
   try {
-    const remoteParsers = await getRemoteParsers()
-    if (!remoteParsers) return localParsers
-    return { ...localParsers, ...remoteParsers }
+    // const remoteParsers = await getRemoteParsers()
+    // if (!remoteParsers) return localParsers
+    // return { ...localParsers, ...remoteParsers }
+    return localParsers
   } catch (e) {
     console.error('serverless.parsers', e.message)
   }

src/adapters/serverless/parsers/aws-parser.js

@@ -42,6 +42,7 @@ export const aws = {
       query: args.queryStringParameters,
       params: args.pathParameters,
       body: handleMultiline(args.body),
+      headers: args.headers,
       all: { ...args }
     },
     res

src/adapters/webassembly/wasm-interop.js

@@ -29,18 +29,6 @@ exports.WasmInterop = function (wasmExports) {
     _exports
   } = wasmExports
 
-  function parse (v) {
-    return !isNaN(parseInt(v))
-      ? parseInt(v)
-      : !isNaN(parseFloat(v))
-      ? parseFloat(v)
-      : /true/i.test(v)
-      ? true
-      : /false/i.test(v)
-      ? false
-      : v
-  }
-
   /**
    *
    * @param {string} fn function name
@@ -58,8 +46,6 @@ exports.WasmInterop = function (wasmExports) {
       2,
       _exports[fn](kv) >>> 0
     )
-      .map(([k, v]) => ({ [k]: parse(v) }))
-      .reduce((a, b) => ({ ...a, ...b }))
   }
 
   /**
@@ -90,39 +76,81 @@ exports.WasmInterop = function (wasmExports) {
     )
   }
 
-  function clean (obj) {
-    const convert = obj =>
-      Object.entries(obj)
-        .filter(([k, v]) => ['string', 'number', 'boolean'].includes(typeof v))
-        .map(([k, v]) => [k, v.toString()])
+  /**
+   * 
+   * @param {string} v - value
+   * @returns {string|number|boolean}
+   */
+  function parseString (v) {
+    return !isNaN(parseFloat(v))
+      ? parseFloat(v)
+      : /^true$/i.test(v)
+      ? true
+      : /^false$/i.test(v)
+      ? false
+      : v
+  }
+
+  /**
+   * 
+   * @param {object} o 
+   * @returns {string[][]}
+   */
+  function parseObject (o) {
+    return Object.entries(o)
+      .filter(([k, v]) => ['string', 'number', 'boolean'].includes(typeof v))
+      .map(([k, v]) => [k, v.toString()])
+  }
 
+  /**
+   *
+   * @param {object} obj
+   * @returns {string[][]}
+   */
+  function toKeyValueArray (obj) {
     // handle custom port format
-    if (obj.port && obj.args) return convert(obj.args)
-    return convert(obj)
+    if (obj.port && obj.args) return parseObject(obj.args)
+    return parseObject(obj)
   }
 
   /**
-   * Parse the input object into a multidimensional array of key-value pairs
-   * and pass it as an argument to the exported wasm function. Do the reverse for
-   * the response. Consequently, any wasm port or command function must accept a
-   * multidemensional array of strings (numbers are converted to strings) and return
-   * a multidimensional array of strings. Before they can be called, they must be 
-   * registered in a modelspec, i.e. getPorts() and getCommands() must return 
-   * appropria metadata.
+   * 
+   * @param {string[][]} kv 
+   * @returns {object}
+   */
+  function fromKeyValueArray (kv) {
+    return kv
+      .map(([k, v]) => ({ [k]: parseString(v) }))
+      .reduce((a, b) => ({ ...a, ...b }))
+  }
 
-   * @param {string} fn exported wasm function name
-   * @param {object|number} [obj] object, see above
-   * @returns {object|number} object
+  /**
+   * Parse the input object into a multidimensional array of key-value string pairs
+   * and pass it as an argument to the exported wasm function. Do the reverse for
+   * the return value. The interface requires that any wasm port or command function 
+   * accept a multidemensional array of strings (numbers and booleans are converted 
+   * to strings) and return a multidimensional array of strings. These functions must 
+   * be defined in the ModelSpec, i.e. `getPorts()` and `getCommands()` list the names
+   * of functions to be exported from the wasm module that implement the interface, 
+   * ```js
+   * (string[][]) => string[][] 
+   * ```
+   * or
+   * ```js 
+   * () => string[][]
+   *```
+   * @param {string} fn name of exported function
+   * @param {object} [obj] object; see above
+   * @returns {object} object
    */
   function callWasmFunction (fn, obj) {
-    return lift(fn, lower(clean(obj)))
+    return fromKeyValueArray(lift(fn, lower(toKeyValueArray(obj))))
   }
 
   return Object.freeze({
     /**
      * For every command in {@link getCommands} create a
-     * an entry that will invoke one or more of the exported
-     * wasm functions.
+     * an entry that will invoke the exported wasm function.
      */
     importWasmCommands () {
       const commandNames = getCommands()
@@ -144,10 +172,9 @@ exports.WasmInterop = function (wasmExports) {
     },
 
     /**
-     * For every port in {@link getPorts} create a
-     * an entry that in the {@link ModelSpecification.ports}
-     * that will invoke one or more of the exported
-     * wasm functions.
+     * For every `port` in {@link getPorts} create a
+     * an entry in {@link ModelSpecification.ports}
+     * that will invoke the exported wasm function.
      */
     importWasmPorts () {
       const ports = getPorts()

src/aegis.js

@@ -215,9 +215,9 @@ async function handle (path, method, req, res) {
     return result
   } catch (error) {
     console.error({ fn: handle.name, error })
-    res.status(500).send(error.message)
+    if (!res.headersSent) res.status(500).send(error.message)
   } finally {
-    const msg = `exit context ${requestContext.getStore().get('id')}`
+    const msg = `exit context ${requestContext.getStore()?.get('id')}`
     requestContext.exit(() => console.log(msg))
   }
 }

src/domain/index.js

@@ -212,9 +212,11 @@
  *    "./models": "./src/domain",
  *    "./adapters": "./src/adapters",
  *    "./services": "./src/services",
- *   },
- * }),
+ *    "./ports": "./src/domain/ports"
+ *   }
+ * })
  * ```
+ * 
  * @property {string} [repo] if using github, name of the github repo
  * @property {string} [owner] if using gitbub, owner of the repo
  * @property {string} [filedir] if using gitub, path to the remoteEntry.js file
@@ -223,7 +225,7 @@
  * @property {string} [serviceName] optional name of the service to which the module belongs
  * - use to group model, adapaters and services together
  * at startup instead of waiting until a request for the model has been received
- * model, adapter or service
+ * modor serviceel, adapter 
  * @property {string} [worker] Creates a model that is controlled by a custom worker
  * instead of the system default worker. Developers can do whatever they want with the worker
  * and needn't use the associated model at all. That said, developers may want to make use of

src/services/cluster.js

@@ -75,11 +75,11 @@ function stopWorker () {
  * @param {number} waitms - Delay execution by `waitms`
  * milliseconds so your app has time to start
  */
-function continueReload (callback, waitms) {
+function handleReload (callback, waitms = 2000) {
   const failedWorker =
     !reloading &&
     workerList.length < numCores &&
-    callback.name.includes('start')
+    callback.name === startWorker.name
 
   if (reloading || failedWorker) {
     setTimeout(callback, failedWorker ? 60000 : waitms)
@@ -109,16 +109,16 @@ exports.startCluster = function (startService, waitms = 2000) {
     // Worker stopped. If reloading, start a new one.
     cluster.on('exit', function (worker) {
       console.log('worker down', worker.process.pid)
-      continueReload(startWorker, 0)
+      handleReload(startWorker, 0)
     })
 
     // Worker started. If reloading, stop the next one.
     cluster.on('online', function (worker) {
       console.log('worker up', worker.process.pid)
-      continueReload(stopWorker, waitms)
+      handleReload(stopWorker, waitms)
     })
 
-    setInterval(continueReload, 60000, startWorker, waitms)
+    setInterval(() => handleReload(startWorker, 0), 60000)
 
     console.log(`master starting ${numCores} workers 🌎`)
     // Run a copy of this program on each core