@architect/inventory 2.2.0 → 3.0.0-RC.1

package/changelog.md

@@ -2,6 +2,46 @@
 
 ---
 
+## [3.0.0] 2022-01-04
+
+### Added
+
+- Added `inv|get.plugins` tree + methods
+  - What used to be `plugins` in the plugins beta is now `customLambdas` (see next item)
+- Added `inv|get.customLambdas`
+  - Formerly `inv|get.plugins`
+- Added `inv._project.customRuntimes`
+- Added the concept of a `build` destination (currently only available via plugin)
+- Added `handlerModuleSystem` property for `nodejs14.x` Lambdas, with a value of `cjs` or `esm` based on Lambda + Node.js conventions
+- Added `handlerFile` detection for `nodejs14.x` + `deno` Lambdas
+
+
+### Changed
+
+- Breaking change: changed `_project.src`, added `_project.cwd`, making both the pair significantly more literal and descriptive
+  - `_project.src` is now the default source tree folder (eg `$cwd/src`)
+  - `_project.cwd` refers to the current working directory of the project
+- Breaking change: AWS region prioritizes a region passed via param over `AWS_REGION` env var; this should realistically have little or no effect in practice
+- Breaking change: legacy `@tables-streams` folders (`src/tables/...` and `src/streams/...`) are now deprecated
+  - Existing functions can be simply moved to `src/tables-streams/{name}` (or use a custom `src` property)
+- Breaking change: renamed `lambda.handlerFunction` to `lambda.handlerMethod`
+- Breaking change: prioritize mod.ts|js in Deno
+- Internal change: performance improvements to building `inv.shared` + `inv.views`
+- Improved memory footprint of Inventory object by preserving references in `lambdaSrcDirs`, `lambdasBySrcDir`
+  - Added `pragma` property to all Lambdas to preserve references
+- Tidy up order of enumerated properties in each Lambda
+
+---
+
+## [2.2.1] 2021-11-22
+
+### Fixed
+
+- Fixed HTTP route sorting; however you've organized your `@http` pragma, Sandbox should now behave much more like API Gateway; fixes #977
+- Fixed overly strict path parameter validation; allow `_`, `.`, `-`; thanks @jkarsrud!
+
+---
+
 ## [2.2.0] 2021-11-16
 
 ### Added

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@architect/inventory",
-  "version": "2.2.0",
+  "version": "3.0.0-RC.1",
   "description": "Architect project resource enumeration utility",
   "main": "src/index.js",
   "scripts": {
@@ -23,14 +23,14 @@
     "@architect/asap": "~4.1.0",
     "@architect/parser": "~5.0.2",
     "@architect/utils": "~3.0.4",
-    "lambda-runtimes": "~1.1.0"
+    "lambda-runtimes": "~1.1.1"
   },
   "devDependencies": {
     "@architect/eslint-config": "~2.0.1",
     "aws-sdk": "2.880.0",
-    "aws-sdk-mock": "~5.4.0",
+    "aws-sdk-mock": "~5.5.0",
     "cross-env": "~7.0.3",
-    "eslint": "~8.2.0",
+    "eslint": "~8.5.0",
     "mock-fs": "~5.1.2",
     "mock-require": "~3.0.3",
     "nyc": "~15.1.0",
@@ -40,7 +40,7 @@
   "eslintConfig": {
     "extends": "@architect/eslint-config"
   },
-  "nyc": {
+  "_nyc": {
     "check-coverage": true,
     "branches": 100,
     "lines": 100,

package/src/config/_upsert.js

@@ -1,4 +1,4 @@
-let is = require('../lib/is')
+let { is } = require('../lib')
 
 /**
  * Overlay / append properties onto an existing config object

package/src/config/pragmas/app.js

@@ -1,5 +1,5 @@
 let { validate } =  require('./validate')
-let is = require('../../lib/is')
+let { is } = require('../../lib')
 
 module.exports = function configureApp ({ arc, errors }) {
   if (!is.array(arc.app) ||

package/src/config/pragmas/events.js

@@ -2,9 +2,10 @@ let populate = require('./populate-lambda')
 let validate = require('./validate')
 
 module.exports = function configureEvents ({ arc, inventory, errors }) {
-  if (!arc.events || !arc.events.length) return null
+  let eventsPlugins = inventory.plugins?._methods?.set?.events
+  if (!arc?.events?.length && !eventsPlugins?.length) return null
 
-  let events = populate.events(arc.events, inventory, errors)
+  let events = populate.events({ arc, inventory, errors })
 
   validate.events(events, '@events', errors)
 

package/src/config/pragmas/http.js

@@ -1,14 +1,16 @@
 let { join } = require('path')
 let populate = require('./populate-lambda')
-let asapSrc = require('../../lib/asap-src')
+let { asapSrc } = require('../../lib')
 let validate = require('./validate')
+let sort = require('./sort/http')
 
 module.exports = function configureHTTP ({ arc, inventory, errors }) {
-  if (!arc.http) return null
+  let httpPlugins = inventory.plugins?._methods?.set?.http
+  if (!arc.http && !httpPlugins?.length) return null
 
   // Populate normally returns null on an empty Lambda pragma
   // However, @http is special because it gets the Architect Static Asset Proxy (ASAP), so fall back to an empty array
-  let http = populate.http(arc.http, inventory, errors) || []
+  let http = populate.http({ arc, inventory, errors }) || []
 
   // Attempt to determine specifically what is handling requests to the root
   // This should probably just be replaced by proper route ordering
@@ -52,7 +54,7 @@ module.exports = function configureHTTP ({ arc, inventory, errors }) {
       config: { ...inventory._arc.defaultFunctionConfig },
       src,
       handlerFile: join(src, 'index.js'),
-      handlerFunction: 'handler',
+      handlerMethod: 'handler',
       configFile: null,
       arcStaticAssetProxy: true,
       method: 'get',
@@ -67,7 +69,9 @@ module.exports = function configureHTTP ({ arc, inventory, errors }) {
   // Impure but it's way less complicated to just do this
   inventory._project.rootHandler = rootHandler
 
+  // Final steps: validate, then ensure the route order works as API Gateway would
   validate.http(http, errors)
+  http = sort(http)
 
   return http
 }

package/src/config/pragmas/index.js

@@ -1,23 +1,27 @@
-let { all: allPragmas } = require('../../lib/pragmas')
+let { pragmas } = require('../../lib')
+let { all: allPragmas } = pragmas
 
 // Get all pragmas except special cases
-let isSpecial = p => [ 'shared', 'views' ].includes(p)
+let isSpecial = p => [ 'plugins', 'shared', 'views' ].includes(p)
 let visitors = allPragmas.map(p => {
   // eslint-disable-next-line
   if (!isSpecial(p)) return require(`./${p}`)
 }).filter(Boolean)
 
-// Special order-dependent visitors that run in a second pass
-let srcDirs = require('./src-dirs')
+// Special order-dependent visitors
+let customLambdas = require('./meta/custom-lambdas')
+let srcDirs = require('./meta/src-dirs')
 let shared = require('./shared')
 let views = require('./views')
 
-module.exports = function configureArcPragmas ({ arc, inventory }, errors) {
+function configureArcPragmas ({ arc, inventory, errors }) {
   if (inventory._project.type !== 'aws') {
     throw ReferenceError('Inventory can only configure pragmas for AWS projects')
   }
 
   let pragmas = {}
+
+  // All the main pragma visitors
   visitors.forEach(visitor => {
     // Expects pragma visitors to have function name of: `configure${pragma}`
     let name = visitor.name.replace('configure', '').toLowerCase()
@@ -27,6 +31,9 @@ module.exports = function configureArcPragmas ({ arc, inventory }, errors) {
     pragmas[name] = visitor({ arc, inventory, errors })
   })
 
+  // Custom Lambdas from @plugins
+  pragmas.customLambdas = customLambdas({ arc, inventory, errors })
+
   // Lambda source directory list
   let dirs = srcDirs({ pragmas, errors })
   pragmas.lambdaSrcDirs = dirs.lambdaSrcDirs
@@ -40,3 +47,7 @@ module.exports = function configureArcPragmas ({ arc, inventory }, errors) {
 
   return pragmas
 }
+
+// Plugins get run early so visitors can rely on the plugin method tree
+configureArcPragmas.plugins = require('./plugins')
+module.exports = configureArcPragmas

package/src/config/pragmas/meta/custom-lambdas.js

@@ -0,0 +1,10 @@
+let populate = require('../populate-lambda')
+
+module.exports = function configureCustomLambdas ({ arc, inventory, errors }) {
+  let customLambdaPlugins = inventory.plugins?._methods?.set?.customLambdas
+  if (!customLambdaPlugins?.length) return null
+
+  let customLambdas = populate.customLambdas({ arc, inventory, errors })
+
+  return customLambdas
+}

package/src/config/pragmas/{src-dirs.js → meta/src-dirs.js}

@@ -1,23 +1,27 @@
-let { lambdas } = require('../../lib/pragmas')
-let is = require('../../lib/is')
+let { is, pragmas } = require('../../../lib')
+let { lambdas } = pragmas
 
 module.exports = function collectSourceDirs ({ pragmas, errors }) {
   let lambdaSrcDirs = []
   let unsortedBySrcDir = {}
   Object.entries(pragmas).forEach(([ pragma, values ]) => {
-    let mayHaveSrcDirs = lambdas.includes(pragma)
+    let mayHaveSrcDirs = lambdas.includes(pragma) || pragma === 'customLambdas'
     if (mayHaveSrcDirs && is.array(values)) {
       pragmas[pragma].forEach(item => {
         if (item.arcStaticAssetProxy === true) return // Special exception for ASAP
         else if (is.string(item.src)) {
           lambdaSrcDirs.push(item.src)
           // Multiple Lambdae may map to a single dir
-          if (unsortedBySrcDir[item.src]) {
-            unsortedBySrcDir[item.src] = is.array(unsortedBySrcDir[item.src])
-              ? [ ...unsortedBySrcDir[item.src], { ...item, pragma } ]
-              : [ unsortedBySrcDir[item.src], { ...item, pragma } ]
+          // >2 Lambdas found with same src dir
+          if (is.array(unsortedBySrcDir[item.src])) {
+            unsortedBySrcDir[item.src].push(item)
           }
-          else unsortedBySrcDir[item.src] = { ...item, pragma }
+          // 2 Lambdas found with same src dir
+          else if (is.object(unsortedBySrcDir[item.src])) {
+            unsortedBySrcDir[item.src] = [ unsortedBySrcDir[item.src], item ]
+          }
+          // 1 Lambda found
+          else unsortedBySrcDir[item.src] = item
         }
         else errors.push(`Lambda is missing source directory: ${JSON.stringify(item, null, 2)}`)
       })
@@ -29,8 +33,7 @@ module.exports = function collectSourceDirs ({ pragmas, errors }) {
 
   // Sort the object for human readability
   let lambdasBySrcDir = null
-  unsortedBySrcDir = Object.keys(unsortedBySrcDir).length ? unsortedBySrcDir : null
-  if (unsortedBySrcDir) {
+  if (Object.keys(unsortedBySrcDir).length) {
     lambdasBySrcDir = {}
     lambdaSrcDirs.forEach(d => lambdasBySrcDir[d] = unsortedBySrcDir[d])
   }

package/src/config/pragmas/plugins.js

@@ -1,9 +1,109 @@
-let populate = require('./populate-lambda')
+let { join } = require('path')
+let { existsSync } = require('fs')
+let { is, normalizeSrc, pragmas } = require('../../lib')
+let { lambdas } = pragmas
+let nonLambdaSetters = [ 'customLambdas', 'env', 'runtimes' ]
+let setters = [ ...lambdas, ...nonLambdaSetters ]
+let pluginMethods = [ 'deploy', 'sandbox' ] // TODO add more!
 
-module.exports = function configurePlugins ({ arc, inventory, errors }) {
-  if (!arc.plugins || !arc.plugins.length) return null
+module.exports = function getPluginModules ({ arc, inventory, errors }) {
+  if (!arc?.plugins?.length && !arc?.macros?.length) return null
+  let plugins = {}
+  let methods = {}
+  let { cwd } = inventory._project
 
-  let plugins = populate.plugins(arc.plugins, inventory, errors)
+  let pluginItems = []
+  let tagPlugins = (arr, type) => pluginItems.push(...arr.map(p => ({ plugin: p, type })))
+  if (arc?.plugins?.length) tagPlugins(arc.plugins, 'plugin')
+  if (arc?.macros?.length) tagPlugins(arc.macros, 'macro')
 
+  for (let pluginItem of pluginItems) {
+    let { plugin, type } = pluginItem
+    let name
+    let pluginPath
+
+    if (is.string(plugin)) {
+      name = plugin
+      pluginPath = getPath(cwd, type + 's', name)
+    }
+    else if (is.object(plugin)) {
+      name = Object.keys(plugin)[0]
+      pluginPath = plugin[name].src
+        ? normalizeSrc(cwd, plugin[name].src)
+        : join(cwd, 'src', type + 's', name)
+    }
+
+    if (name === '_methods') {
+      errors.push('Plugin name _methods is reserved, please rename your plugin')
+      continue
+    }
+    if (pluginPath) {
+      try {
+        if (type === 'plugin') {
+          // eslint-disable-next-line
+          plugins[name] = require(pluginPath)
+        }
+        // Remap @macros to deploy.start
+        if (type === 'macro') {
+          // eslint-disable-next-line
+          plugins[name] = { deploy: { start: require(pluginPath) } }
+        }
+        // Walk each plugin and build the method tree
+        Object.entries(plugins[name]).forEach(([ method, item ]) => {
+          // Primitive setters
+          if (method === 'set') {
+            if (!methods.set) methods.set = {}
+            setters.forEach(setter => {
+              if (item[setter]) {
+                let fn = item[setter]
+                if (!is.fn(fn) || fn.constructor.name === 'AsyncFunction') {
+                  let msg = `Invalid plugin, setters must be synchronous functions: plugin: ${name}, method: set.${setter}`
+                  errors.push(msg)
+                  return
+                }
+                if (!methods.set[setter]) methods.set[setter] = []
+                fn.plugin = name
+                fn.type = type
+                methods.set[setter].push(fn)
+              }
+            })
+          }
+          // 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}`
+                errors.push(msg)
+                return
+              }
+              if (!methods[method]) methods[method] = {}
+              if (!methods[method][hook]) methods[method][hook] = []
+              fn.plugin = name
+              fn.type = type
+              methods[method][hook].push(fn)
+            })
+          }
+        })
+      }
+      catch (err) {
+        errors.push(`Unable to load plugin '${name}': ${err.message.split('\n')[0]}`)
+      }
+    }
+    else errors.push(`Cannot find plugin '${name || plugin}'! Are you sure you have installed or created it correctly?`)
+  }
+  plugins._methods = methods
   return plugins
 }
+
+function getPath (cwd, srcDir, name) {
+  let paths = [
+    join(cwd, 'src', srcDir, `${name}.js`),
+    join(cwd, 'src', srcDir, name),
+    join(cwd, 'node_modules', name),
+    join(cwd, 'node_modules', `@${name}`),
+  ]
+  if (existsSync(paths[0]))      return paths[0]
+  else if (existsSync(paths[1])) return paths[1]
+  else if (existsSync(paths[2])) return paths[2]
+  else if (existsSync(paths[3])) return paths[3]
+}

package/src/config/pragmas/populate-lambda/_custom-lambdas.js

@@ -0,0 +1,10 @@
+let { getLambdaDirs } = require('../../../lib')
+
+module.exports = function populateCustomLambdas (params) {
+  let { item, errors } = params
+  let { name, src } = item
+  if (name && src) {
+    return { ...item, ...getLambdaDirs(params, { plugin: true }) }
+  }
+  errors.push(`Invalid plugin-generated custom Lambda: name: ${name}, src: ${src}`)
+}

package/src/config/pragmas/populate-lambda/_events.js

@@ -1,18 +1,24 @@
-let { join } = require('path')
-let is = require('../../../lib/is')
+let { is, getLambdaDirs } = require('../../../lib')
 
-module.exports = function populateEvents ({ item, dir, cwd, errors }) {
-  if (is.string(item)) {
+module.exports = function populateEvents (params) {
+  let { type, item, errors, plugin } = params
+  if (plugin) {
+    let { name, src } = item
+    if (name && src) {
+      return { ...item, ...getLambdaDirs(params, { plugin }) }
+    }
+    errors.push(`Invalid plugin-generated @${type} item: name: ${name}, src: ${src}`)
+    return
+  }
+  else if (is.string(item)) {
     let name = item
-    let src = join(cwd, dir, name)
-    return { name, src }
+    let dirs = getLambdaDirs(params, { name })
+    return { name, ...dirs }
   }
   else if (is.object(item)) {
     let name = Object.keys(item)[0]
-    let src = item[name].src
-      ? join(cwd, item[name].src)
-      : join(cwd, dir, name)
-    return { name, src }
+    let dirs = getLambdaDirs(params, { name, customSrc: item[name].src })
+    return { name, ...dirs }
   }
-  errors.push(`Invalid @events or @queues item: ${item}`)
+  errors.push(`Invalid @${type} item: ${item}`)
 }

package/src/config/pragmas/populate-lambda/_http.js

@@ -1,15 +1,25 @@
-let { join } = require('path')
 let { getLambdaName } = require('@architect/utils')
-let is = require('../../../lib/is')
+let { is, getLambdaDirs } = require('../../../lib')
 
-module.exports = function populateHTTP ({ item, dir, cwd, errors }) {
-  if (is.array(item) && item.length === 2) {
+module.exports = function populateHTTP (params) {
+  let { item, errors, plugin } = params
+  if (plugin) {
+    let { method, path, src } = item
+    if (method && path && src) {
+      let name = `${method} ${path}`
+      let route = { name, ...item, ...getLambdaDirs(params, { plugin }) }
+      return route
+    }
+    errors.push(`Invalid plugin-generated @http route: method: ${method}, path: ${path}, src: ${src}`)
+    return
+  }
+  else if (is.array(item) && item.length === 2) {
     let method = item[0].toLowerCase()
     let path = item[1]
     let name = `${method} ${path}`
     let lambdaName = `${method}${getLambdaName(path)}`
-    let src = join(cwd, dir, lambdaName)
-    let route = { name, method, path, src }
+    let dirs = getLambdaDirs(params, { name: lambdaName })
+    let route = { name, method, path, ...dirs }
     return route
   }
   else if (is.object(item)) {
@@ -17,10 +27,8 @@ module.exports = function populateHTTP ({ item, dir, cwd, errors }) {
     let method = item[path].method.toLowerCase()
     let name = `${method} ${path}`
     let lambdaName = `${method}${getLambdaName(path)}`
-    let src = item[path].src
-      ? join(cwd, item[path].src)
-      : join(cwd, dir, lambdaName)
-    let route = { name, method, path, src }
+    let dirs = getLambdaDirs(params, { name: lambdaName, customSrc: item[path].src })
+    let route = { name, method, path, ...dirs }
     return route
   }
   errors.push(`Invalid @http route: ${item}`)

package/src/config/pragmas/populate-lambda/_scheduled.js

@@ -1,5 +1,4 @@
-let { join } = require('path')
-let is = require('../../../lib/is')
+let { is, getLambdaDirs } = require('../../../lib')
 
 let coerceNumbers = str => !isNaN(Number(str)) ? Number(str) : str
 
@@ -30,10 +29,21 @@ let get = {
   }
 }
 
-module.exports = function populateScheduled ({ item, dir, cwd, errors }) {
+module.exports = function populateScheduled (params) {
+  let { item, errors, plugin } = params
   let rate = null
   let cron = null
-  if (is.array(item)) {
+  if (plugin) {
+    let { name, src } = item
+    if (name && src && (item.rate || item.cron)) {
+      if (item.rate) rate = get.rate(item.rate)
+      if (item.cron) cron = get.cron(item.cron)
+      return { ...item, rate, cron, ...getLambdaDirs(params, { plugin }) }
+    }
+    errors.push(`Invalid plugin-generated @scheduled item: name: ${name}, rate: ${item.rate}, cron: ${item.cron}, src: ${src}`)
+    return
+  }
+  else if (is.array(item)) {
     let name = item[0]
 
     // Hacky but it works
@@ -46,8 +56,8 @@ module.exports = function populateScheduled ({ item, dir, cwd, errors }) {
     if (isRate) rate = get.rate(clean(isRate))
     if (isCron) cron = get.cron(clean(isCron))
 
-    let src = join(cwd, dir, name)
-    return { name, src, rate, cron }
+    let dirs = getLambdaDirs(params, { name })
+    return { name, rate, cron, ...dirs }
   }
   else if (is.object(item)) {
     let name = Object.keys(item)[0]
@@ -64,10 +74,8 @@ module.exports = function populateScheduled ({ item, dir, cwd, errors }) {
       cron = get.cron(exp)
     }
 
-    let src = item[name].src
-      ? join(cwd, item[name].src)
-      : join(cwd, dir, name)
-    return { name, src, rate, cron }
+    let dirs = getLambdaDirs(params, { name, customSrc: item[name].src })
+    return { name, rate, cron, ...dirs }
   }
   errors.push(`Invalid @scheduled item: ${item}`)
 }

package/src/config/pragmas/populate-lambda/_tables-streams.js

@@ -1,38 +1,35 @@
-let { join } = require('path')
-let { existsSync } = require('fs')
-let is = require('../../../lib/is')
+let { is, getLambdaDirs } = require('../../../lib')
+let ts = 'tables-streams'
 
-module.exports = function populateTablesStreams ({ type, item, dir, cwd, errors }) {
+module.exports = function populateTablesStreams (params) {
+  let { type, item, errors, plugin } = params
   if (type === 'tables' && is.object(item)) {
     let name = Object.keys(item)[0]
-    // Check for the legacy dir from before `@tables tablename stream true` generated a @tables-streams item
-    let legacySrc = join(cwd, dir, name)
-    let streamSrc = join(cwd, 'src', 'streams', name)
-    let tablesStreamsSrc = join(cwd, 'src', 'tables-streams', name)
-
-    let src
-    if      (existsSync(legacySrc)) src = legacySrc
-    else if (existsSync(streamSrc)) src = streamSrc // TODO [remove] in 10.0
-    else                            src = tablesStreamsSrc
-
     let table = name
-    return { name, src, table }
+    let dirs = getLambdaDirs({ ...params, type: ts }, { name })
+    return { name, table, ...dirs }
+  }
+  else if (type === ts && plugin) {
+    let { name, src, table } = item
+    if (name && src && table) {
+      return { ...item, ...getLambdaDirs(params, { plugin }) }
+    }
+    errors.push(`Invalid plugin-generated @${type} item: name: ${name}, table: ${table}, src: ${src}`)
+    return
   }
-  else if (type === 'tables-streams' && is.string(item)) {
+  else if (type === ts && is.string(item)) {
     let name = item
-    let src = join(cwd, dir, name)
     let table = name
-    return { name, src, table }
+    let dirs = getLambdaDirs(params, { name })
+    return { name, table, ...dirs }
   }
-  else if (type === 'tables-streams' && is.object(item)) {
+  else if (type === ts && is.object(item)) {
     let name = Object.keys(item)[0]
-    let src = item[name].src
-      ? join(cwd, item[name].src)
-      : join(cwd, dir, name)
     let table = item[name].table
       ? item[name].table
       : name
-    return { name, src, table }
+    let dirs = getLambdaDirs(params, { name, customSrc: item[name].src })
+    return { name, table, ...dirs }
   }
   errors.push(`Invalid @${type} item: ${item}`)
 }

package/src/config/pragmas/populate-lambda/_ws.js

@@ -0,0 +1,26 @@
+let { is, getLambdaDirs } = require('../../../lib')
+
+module.exports = function populateWebSockets (params) {
+  let { item, errors, plugin } = params
+  if (plugin) {
+    let { name, src } = item
+    if (name && src) {
+      return { ...item, route: name, ...getLambdaDirs(params, { plugin }) }
+    }
+    errors.push(`Invalid plugin-generated @ws item: name: ${name}, src: ${src}`)
+    return
+  }
+  else if (is.string(item)) {
+    let name = item
+    let route = name // Same as name, just what AWS calls it
+    let dirs = getLambdaDirs(params, { name })
+    return { name, route, ...dirs }
+  }
+  else if (is.object(item)) {
+    let name = Object.keys(item)[0]
+    let route = name
+    let dirs = getLambdaDirs(params, { name, customSrc: item[name].src })
+    return { name, route, ...dirs }
+  }
+  errors.push(`Invalid @ws item: ${item}`)
+}