@architect/inventory 3.4.4-RC.0 → 3.5.0-RC.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@architect/inventory",
-  "version": "3.4.4-RC.0",
+  "version": "3.5.0-RC.1",
   "description": "Architect project resource enumeration utility",
   "main": "src/index.js",
   "scripts": {

package/src/config/pragmas/plugins.js

@@ -4,9 +4,12 @@ let { is, pragmas, tidyError, validationPatterns } = require('../../lib')
 let { lambdas } = pragmas
 let nonLambdaSetters = [ 'customLambdas', 'env', 'proxy', 'runtimes', 'shared', 'static', 'views', 'tables', 'tables-indexes' ]
 let setters = [ ...lambdas, ...nonLambdaSetters ]
-let pluginMethods = [ 'deploy', 'hydrate', 'sandbox' ]
+let pluginMethods = [ 'deploy', 'create', 'hydrate', 'sandbox' ]
 let reservedNames = [ '_methods' ]
 
+// Exceptions to the rule where plugin hooks must be functions
+let stringOrArrayHooks = { create: { register: true } }
+
 module.exports = async function getPluginModules ({ arc, inventory, errors }) {
   if (!arc?.plugins?.length && !arc?.macros?.length) return null
   let plugins = {}
@@ -92,8 +95,18 @@ module.exports = async function getPluginModules ({ arc, inventory, errors }) {
           // Command hooks
           else if (pluginMethods.includes(method)) {
             Object.entries(item).forEach(([ hook, fn ]) => {
-              if (!is.fn(fn)) {
-                let msg = `Invalid plugin, must be a function: plugin: ${name}, method: ${method}.${hook}`
+              let isStringOrArrayHook = stringOrArrayHooks?.[method]?.[hook]
+              if (isStringOrArrayHook) {
+                if (!(is.string(fn) || is.array(fn))) {
+                  let msg = `Invalid plugin, property must be a string or array: plugin: ${name}, property: ${method}.${hook}`
+                  errors.push(msg)
+                  return
+                }
+                // Normalize strings to arrays
+                if (is.string(fn)) plugins[name][method][hook] = fn = [ fn ]
+              }
+              else if (!isStringOrArrayHook && !is.fn(fn)) {
+                let msg = `Invalid plugin, method must be a function: plugin: ${name}, method: ${method}.${hook}`
                 errors.push(msg)
                 return
               }

package/src/config/project/plugins/runtimes.js

@@ -12,18 +12,18 @@ module.exports = function setRuntimePlugins (params, project) {
   if (runtimePlugins?.length) {
     let runtimes = {
       runtimes: [],
+      runtimePlugins: {}, // Map runtimes to their corresponding plugins
     }
     // inventory._project is not yet built, so provide as much as we can to plugins for now
     let inv = deepFrozenCopy({ ...inventory, _project: project })
     let build
     runtimePlugins.forEach(fn => {
-      let errType = `plugin: ${fn.plugin}, method: set.runtimes`
+      let errType = `plugin: ${fn._plugin}, method: set.runtimes`
       try {
         var result = fn({ arc: inv._project.arc, inventory: { inv } })
       }
       catch (err) {
-        err.message = `Runtime plugin exception: ${errType}`
-                      + `\n` + err.message
+        err.message = `Runtime plugin exception: ${errType}\n` + err.message
         throw err
       }
       // Accept one or more results, then loop through them
@@ -55,13 +55,14 @@ module.exports = function setRuntimePlugins (params, project) {
           if (is.string(runtime.build)) build = runtime.build
         }
         if (type === 'transpiled' && !allRuntimes.includes(baseRuntime)) {
-          return errors.push(`Runtime '${name}' must include a valid baseRuntime property corresponding to a valid Lambda runtime (e.g. 'nodejs16.x')`)
+          return errors.push(`Runtime '${name}' must include a valid baseRuntime property corresponding to a valid Lambda runtime (e.g. 'nodejs18.x')`)
         }
         runtimes.runtimes.push(name)
+        runtimes.runtimePlugins[name] = fn._plugin
         runtimes[name] = runtime
       })
     })
-    return { build, runtimes }
+    return { build, runtimes, runtimePlugins }
   }
   return {}
 }