@architect/inventory 2.1.1 → 2.2.0

package/changelog.md

@@ -2,6 +2,38 @@
 
 ---
 
+## [2.2.0] 2021-11-16
+
+### Added
+
+- Finally formalized `@tables-streams`, the fully customizable successor to `@tables` with `stream true`
+- Added `@tables-indexes` pragma
+  - `@tables-indexes` has identical semantics as (and will eventually supersede) `@indexes`
+  - Until Arc 10.0 + Inventory 3.0, consumers should now check both `inv.indexes` AND `inv.tables-indexes`
+
+---
+
+## [2.1.3] 2021-11-04
+
+### Fixed
+
+- Hardened runtime validation by ensuring non-string values will fail gracefully
+
+---
+
+## [2.1.2] 2021-10-28
+
+### Added
+
+- Added memory / timeout configuration validation
+
+
+### Changed
+
+- Improved layer validation error formatting
+
+---
+
 ## [2.1.1] 2021-10-13
 
 ### Added

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@architect/inventory",
-  "version": "2.1.1",
+  "version": "2.2.0",
   "description": "Architect project resource enumeration utility",
   "main": "src/index.js",
   "scripts": {
@@ -23,21 +23,28 @@
     "@architect/asap": "~4.1.0",
     "@architect/parser": "~5.0.2",
     "@architect/utils": "~3.0.4",
-    "lambda-runtimes": "~1.0.1"
+    "lambda-runtimes": "~1.1.0"
   },
   "devDependencies": {
     "@architect/eslint-config": "~2.0.1",
     "aws-sdk": "2.880.0",
     "aws-sdk-mock": "~5.4.0",
     "cross-env": "~7.0.3",
-    "eslint": "~8.0.1",
-    "mock-fs": "~5.1.1",
+    "eslint": "~8.2.0",
+    "mock-fs": "~5.1.2",
     "mock-require": "~3.0.3",
     "nyc": "~15.1.0",
     "tap-spec": "^5.0.0",
-    "tape": "^5.3.1"
+    "tape": "^5.3.2"
   },
   "eslintConfig": {
     "extends": "@architect/eslint-config"
+  },
+  "nyc": {
+    "check-coverage": true,
+    "branches": 100,
+    "lines": 100,
+    "functions": 100,
+    "statements": 100
   }
 }

package/readme.md

@@ -1,4 +1,4 @@
-[<img src="https://s3-us-west-2.amazonaws.com/arc.codes/architect-logo-500b@2x.png" width=500>](https://www.npmjs.com/package/@architect/inventory)
+[<img src="https://assets.arc.codes/architect-logo-500b@2x.png" width=500>](https://www.npmjs.com/package/@architect/inventory)
 
 ## [`@architect/inventory`](https://www.npmjs.com/package/@architect/inventory)
 

package/src/config/pragmas/index.js

@@ -1,7 +1,7 @@
 let { all: allPragmas } = require('../../lib/pragmas')
 
 // Get all pragmas except special cases
-let isSpecial = p => p === 'shared' || p === 'views'
+let isSpecial = p => [ 'shared', 'views' ].includes(p)
 let visitors = allPragmas.map(p => {
   // eslint-disable-next-line
   if (!isSpecial(p)) return require(`./${p}`)
@@ -21,6 +21,9 @@ module.exports = function configureArcPragmas ({ arc, inventory }, errors) {
   visitors.forEach(visitor => {
     // Expects pragma visitors to have function name of: `configure${pragma}`
     let name = visitor.name.replace('configure', '').toLowerCase()
+    // Special cases for dasherization
+    if (name === 'tablesindexes') name = 'tables-indexes'
+    if (name === 'tablesstreams') name = 'tables-streams'
     pragmas[name] = visitor({ arc, inventory, errors })
   })
 

package/src/config/pragmas/indexes.js

@@ -1,5 +1,5 @@
-let is = require('../../lib/is')
 let validate = require('./validate')
+let { getIndexes } = require('./tables-indexes')
 
 module.exports = function configureIndexes ({ arc, errors }) {
   if (!arc.indexes || !arc.indexes.length) return null
@@ -7,43 +7,12 @@ module.exports = function configureIndexes ({ arc, errors }) {
     errors.push(`Specifying @indexes requires specifying corresponding @tables`)
     return null
   }
+  if (arc['tables-indexes']?.length && arc.indexes?.length) {
+    errors.push(`Either @tables-indexes or @indexes can be specified, but not both`)
+    return null
+  }
 
-  let isCustomName = key => is.string(key) && key.toLowerCase() === 'name'
-  function error (item) { errors.push(`Invalid @indexes item: ${item}`) }
-
-  let indexes = arc.indexes.map(index => {
-    if (is.object(index)) {
-      let name = Object.keys(index)[0]
-      let partitionKey = null
-      let partitionKeyType = null
-      let sortKey = null
-      let sortKeyType = null
-      let indexName = null
-      Object.entries(index[name]).forEach(([ key, value ]) => {
-        if (is.sortKey(value)) {
-          sortKey = key
-          sortKeyType = value.replace('**', '')
-        }
-        else if (is.primaryKey(value)) {
-          partitionKey = key
-          partitionKeyType = value.replace('*', '')
-        }
-        else if (isCustomName(key)) {
-          indexName = value
-        }
-      })
-      return {
-        indexName,
-        name,
-        partitionKey,
-        partitionKeyType,
-        sortKey,
-        sortKeyType,
-      }
-    }
-    error(index)
-  }).filter(Boolean) // Invalid indexes may create undefined entries in the map
-
+  let indexes = getIndexes(arc, 'indexes', errors)
   validate.indexes(indexes, '@indexes', errors)
 
   return indexes

package/src/config/pragmas/populate-lambda/{_streams.js → _tables-streams.js}

@@ -2,23 +2,29 @@ let { join } = require('path')
 let { existsSync } = require('fs')
 let is = require('../../../lib/is')
 
-module.exports = function populateStreams ({ type, item, dir, cwd, errors }) {
+module.exports = function populateTablesStreams ({ type, item, dir, cwd, errors }) {
   if (type === 'tables' && is.object(item)) {
     let name = Object.keys(item)[0]
-    // Check for the legacy dir from before `@tables tablename stream true` generated an @streams item
+    // 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 src = existsSync(legacySrc) ? legacySrc : streamSrc
+    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 }
   }
-  else if (type === 'streams' && is.string(item)) {
+  else if (type === 'tables-streams' && is.string(item)) {
     let name = item
     let src = join(cwd, dir, name)
     let table = name
     return { name, src, table }
   }
-  else if (type === 'streams' && is.object(item)) {
+  else if (type === 'tables-streams' && is.object(item)) {
     let name = Object.keys(item)[0]
     let src = item[name].src
       ? join(cwd, item[name].src)

package/src/config/pragmas/populate-lambda/get-runtime.js

@@ -1,3 +1,4 @@
+let is = require('../../../lib/is')
 let { aliases, runtimes, runtimeList } = require('lambda-runtimes')
 
 // Runtime interpolater
@@ -18,5 +19,9 @@ module.exports = function getRuntime (config) {
       config.runtimeAlias = runtime
     }
   }
+  else if (is.defined(runtime)) {
+    // Someone did something funky like specify a number or bool, so coerce and let it fail validation
+    config.runtime = `${config.runtime}`
+  }
   return config
 }

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

@@ -10,7 +10,7 @@ let getEvents = require('./_events')
 let getPlugins = require('./_plugins')
 let getScheduled = require('./_scheduled')
 let getWS = require('./_websockets')
-let getStreams = require('./_streams')
+let getTablesStreams = require('./_tables-streams')
 
 /**
  * Build out the Lambda tree
@@ -87,6 +87,8 @@ function populateLambda (type, pragma, inventory, errors) {
   return lambdas
 }
 
+let ts = 'tables-streams'
+
 function getLambda (params) {
   let { type } = params
   params.dir = `src/${type}/`
@@ -96,8 +98,8 @@ function getLambda (params) {
   if (type === 'plugins')   return getPlugins(params)
   if (type === 'queues')    return getEvents(params) // Effectively the same as events
   if (type === 'scheduled') return getScheduled(params)
-  if (type === 'streams')   return getStreams(params)
-  if (type === 'tables')    return getStreams(params) // Shortcut for creating streams
+  if (type === ts)          return getTablesStreams(params)
+  if (type === 'tables')    return getTablesStreams(params) // Shortcut for creating streams
   /* istanbul ignore else */ /* Clearer to be explicit here */
   if (type === 'ws')        return getWS(params)
 }
@@ -108,7 +110,7 @@ module.exports = {
   plugins:    populateLambda.bind({}, 'plugins'),
   queues:     populateLambda.bind({}, 'queues'),
   scheduled:  populateLambda.bind({}, 'scheduled'),
-  streams:    populateLambda.bind({}, 'streams'),
   tables:     populateLambda.bind({}, 'tables'),
+  [ts]:       populateLambda.bind({}, ts),
   ws:         populateLambda.bind({}, 'ws'),
 }

package/src/config/pragmas/tables-indexes.js

@@ -0,0 +1,59 @@
+let is = require('../../lib/is')
+let validate = require('./validate')
+
+function configureTablesIndexes ({ arc, errors }) {
+  if (!arc['tables-indexes'] || !arc['tables-indexes'].length) return null
+  if (arc['tables-indexes'] && !arc.tables) {
+    errors.push(`Specifying @tables-indexes requires specifying corresponding @tables`)
+    return null
+  }
+  if (arc['tables-indexes']?.length && arc.indexes?.length) {
+    errors.push(`Either @tables-indexes or @indexes can be specified, but not both`)
+    return null
+  }
+
+  let indexes = getIndexes(arc, 'tables-indexes', errors)
+  validate.indexes(indexes, '@tables-indexes', errors)
+
+  return indexes
+}
+
+let getIndexes = (arc, pragma, errors) => {
+  let isCustomName = key => is.string(key) && key.toLowerCase() === 'name'
+  function error (item) { errors.push(`Invalid @${pragma} item: ${item}`) }
+  return arc[pragma].map(index => {
+    if (is.object(index)) {
+      let name = Object.keys(index)[0]
+      let partitionKey = null
+      let partitionKeyType = null
+      let sortKey = null
+      let sortKeyType = null
+      let indexName = null
+      Object.entries(index[name]).forEach(([ key, value ]) => {
+        if (is.sortKey(value)) {
+          sortKey = key
+          sortKeyType = value.replace('**', '')
+        }
+        else if (is.primaryKey(value)) {
+          partitionKey = key
+          partitionKeyType = value.replace('*', '')
+        }
+        else if (isCustomName(key)) {
+          indexName = value
+        }
+      })
+      return {
+        indexName,
+        name,
+        partitionKey,
+        partitionKeyType,
+        sortKey,
+        sortKeyType,
+      }
+    }
+    error(index)
+  }).filter(Boolean) // Invalid indexes may create undefined entries in the map
+}
+
+configureTablesIndexes.getIndexes = getIndexes
+module.exports = configureTablesIndexes

package/src/config/pragmas/{streams.js → tables-streams.js}

@@ -3,15 +3,15 @@ let validate = require('./validate')
 let is = require('../../lib/is')
 
 /**
- * `@streams` (formerly `@tables`)
+ * `@tables-streams`
  * - Originally `@tables {tablename} stream true` created a lambda at src/tables/{tablename}
- * - This was superseded by `@streams`; `@tables` remains for backwards compat and as a convenience for creating `@streams`
+ * - This was superseded by `@tables-streams`; `@tables` remains for backwards compat and as a convenience for creating `@tables-streams`
  *   - If a project has an existing `@tables` Lambda, we'll continue using that so long as the directory exists
  */
-module.exports = function configureStreams ({ arc, inventory, errors }) {
-  if (!arc.streams && !arc.tables) return null
-  if (arc.streams && !arc.tables) {
-    errors.push(`Specifying @streams requires specifying corresponding @tables`)
+module.exports = function configureTablesStreams ({ arc, inventory, errors }) {
+  if (!arc['tables-streams'] && !arc.tables) return null
+  if (arc['tables-streams'] && !arc.tables) {
+    errors.push(`Specifying @tables-streams requires specifying corresponding @tables`)
     return null
   }
 
@@ -22,21 +22,21 @@ module.exports = function configureStreams ({ arc, inventory, errors }) {
   }
   else tables = null
 
-  // Populate @streams
-  let streams = populate.streams(arc.streams, inventory, errors)
+  // Populate @tables-streams
+  let streams = populate['tables-streams'](arc['tables-streams'], inventory, errors)
 
   if (tables && streams) {
     let uniqueTables = tables.filter(t => !streams.some(s => s.table === t.table))
     let merged = streams.concat(uniqueTables)
-    validate.streams(merged, errors)
+    validate.tablesStreams(merged, errors)
     return merged
   }
   else if (streams) {
-    validate.streams(streams, errors)
+    validate.tablesStreams(streams, errors)
     return streams
   }
   else if (tables) {
-    validate.streams(tables, errors)
+    validate.tablesStreams(tables, errors)
     return tables
   }
   return null

package/src/config/pragmas/validate/_scheduled.js

@@ -53,7 +53,6 @@ function validateCron (schedule, errors) {
   if (!year.toString().match(minHrYr))    expErr('year', year)
 }
 
-
 let singular = [ 'minute', 'hour', 'day' ]
 let plural = [ 'minutes', 'hours', 'days' ]
 function validateRate (schedule, errors) {
@@ -69,11 +68,7 @@ function validateRate (schedule, errors) {
 
   // Value must be a >0 number
   if (!is.number(value) || !(value > 0)) {
-    expErr('rate value must be a number greater than 0', value)
-  }
-  // Value must be a whole number
-  else if (!value.toString().match(/^\d+$/)) {
-    expErr('rate value must be a whole number', value)
+    expErr('rate value must be a whole number greater than 0', value)
   }
   // Interval must be a string
   if (!is.string(interval)) {

package/src/config/pragmas/validate/_tables-streams.js

@@ -0,0 +1,19 @@
+let { regex, size, unique } = require('./_lib')
+
+/**
+ * Validate @tables-streams (& @tables streams true)
+ *
+ * Where possible, attempts to follow DynamoDB validation
+ * See: https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.NamingRulesDataTypes.html
+ */
+module.exports = function validateTablesStreams (tablesStreams, errors) {
+  if (tablesStreams.length) {
+    unique(tablesStreams, '@tables-streams', errors)
+
+    tablesStreams.forEach(stream => {
+      let { name } = stream
+      size(name, 3, 255, '@tables-streams', errors)
+      regex(name, 'veryLooseName', '@tables-streams', errors)
+    })
+  }
+}

package/src/config/pragmas/validate/_tables.js

@@ -47,7 +47,7 @@ module.exports = function validateTablesAndIndexes (pragma, pragmaName, errors)
           }
         })
         if (foundDupe) {
-          let err = `Duplicate @indexes value: '${index.name}'`
+          let err = `Duplicate ${pragmaName} value: '${index.name}'`
           if (!errors.includes(err)) errors.push(err)
         }
       })

package/src/config/pragmas/validate/index.js

@@ -1,18 +1,18 @@
 /* eslint-disable global-require */
 module.exports = {
   // Pragmas and project validation
-  aws:        require('./_aws'),
-  events:     require('./_events'),
-  http:       require('./_http'),
-  indexes:    require('./_tables'), // Same ruleset as @tables (more or less)
-  proxy:      require('./_proxy'),
-  tables:     require('./_tables'),
-  queues:     require('./_events'), // Same ruleset as @events
-  scheduled:  require('./_scheduled'),
-  shared:     require('./_shared'), // Also includes @views
-  streams:    require('./_streams'),
-  websockets: require('./_websockets'),
+  aws:            require('./_aws'),
+  events:         require('./_events'),
+  http:           require('./_http'),
+  indexes:        require('./_tables'), // Same ruleset as @tables (more or less)
+  proxy:          require('./_proxy'),
+  tables:         require('./_tables'),
+  queues:         require('./_events'), // Same ruleset as @events
+  scheduled:      require('./_scheduled'),
+  shared:         require('./_shared'), // Also includes @views
+  tablesStreams:  require('./_tables-streams'),
+  websockets:     require('./_websockets'),
 
   // Misc
-  validate: require('./_lib')
+  validate:       require('./_lib')
 }

package/src/defaults/index.js

@@ -60,8 +60,9 @@ module.exports = function inventoryDefaults (params = {}) {
     scheduled: null,
     shared: null,
     static: null,
-    streams: null,
     tables: null,
+    'tables-indexes': null,
+    'tables-streams': null,
     views: null,
     ws: null,
     // Collection of all Lambda paths

package/src/get.js

@@ -8,7 +8,7 @@ module.exports = function _get (inventory) {
     if (pragma === null) return null
     if (is.array(pragma)) {
       // Handle arrays of named entities or string values
-      let finder = i => i && i.name && i.name === name || i === name
+      let finder = i => i?.name === name || i === name
       if (multipleResults.includes(prag)) {
         let results = pragma.filter(finder)
         return results.length ? results : undefined
@@ -37,5 +37,6 @@ module.exports = function _get (inventory) {
 // Everything is uniquely named except in certain special-case pragmas
 // These refer to other pragmas, and thus may allow multiple same/same-named entities
 let multipleResults = [
-  'indexes'
+  'tables-indexes',
+  'indexes',
 ]

package/src/lib/is.js

@@ -4,9 +4,10 @@ module.exports = {
   // Types
   array: item => Array.isArray(item),
   bool: item => typeof item === 'boolean',
-  number: item => typeof item === 'number',
+  number: item => Number.isInteger(item),
   object: item => typeof item === 'object' && !Array.isArray(item),
   string: item => typeof item === 'string',
+  defined: item => typeof item !== 'undefined' && item !== null,
   // Filesystem
   exists: path => existsSync(path),
   folder: path => existsSync(path) && lstatSync(path).isDirectory(),

package/src/lib/pragmas.js

@@ -6,7 +6,7 @@ module.exports = {
     'cdn',
     'events',
     'http',
-    'indexes',
+    'indexes', // -> transitioning to @tables-indexes
     'macros',
     'plugins',
     'proxy',
@@ -14,8 +14,9 @@ module.exports = {
     'scheduled',
     'shared',
     'static',
-    'streams',
     'tables',
+    'tables-indexes',
+    'tables-streams',
     'views',
     'ws',
   ],
@@ -26,7 +27,7 @@ module.exports = {
     'plugins',
     'queues',
     'scheduled',
-    'streams',
+    'tables-streams',
     'ws',
   ],
 }

package/src/validate/config.js

@@ -0,0 +1,64 @@
+let is = require('../lib/is')
+let { lambdas } = require('../lib/pragmas')
+let { aliases, runtimeList } = require('lambda-runtimes')
+let allRuntimes = runtimeList.concat([ 'deno' ])
+
+/**
+ * Configuration validator
+ */
+module.exports = function configValidator (params, inventory, errors) {
+  let { runtime: globalRuntime, memory: globalMemory, timeout: globalTimeout } = inventory.aws
+
+  /**
+   * Global config
+   */
+  // Memory
+  if (is.defined(globalMemory) && invalidMemory(globalMemory)) {
+    errors.push(invalidMemoryMsg(`${globalMemory} MB (@aws)`))
+  }
+  // Runtime
+  if ((globalRuntime && !is.string(globalRuntime)) ||
+      (globalRuntime && !allRuntimes.includes(globalRuntime) &&
+       !aliases[globalRuntime] && !aliases[globalRuntime.toLowerCase()])) {
+    errors.push(`Invalid project-level runtime: ${globalRuntime}`)
+  }
+  // Timeout
+  if (is.defined(globalTimeout) && invalidTimeout(globalTimeout)) {
+    errors.push(invalidTimeoutMsg(`${globalTimeout} seconds (@aws)`))
+  }
+
+  /**
+   * Lambda config
+   */
+  lambdas.forEach(p => {
+    let pragma = inventory[p]
+    if (pragma) pragma.forEach(({ name, config }) => {
+      let { memory, runtime, timeout } = config
+
+      // Memory
+      if (invalidMemory(memory) && memory !== globalMemory) {
+        errors.push(invalidMemoryMsg(`${memory} MB (@${p} ${name})`))
+      }
+      // Runtime
+      if (!allRuntimes.includes(runtime) && runtime !== globalRuntime) {
+        errors.push(`Invalid runtime: ${runtime} (@${p} ${name})`)
+      }
+      // Timeout
+      if (invalidTimeout(timeout) && timeout !== globalTimeout) {
+        errors.push(invalidTimeoutMsg(`${timeout} seconds (@${p} ${name})`))
+      }
+    })
+  })
+}
+
+// Memory
+let minMemory = 128
+let maxMemory = 10240
+let invalidMemory = memory => !is.number(memory) || (memory < minMemory) || (memory > maxMemory)
+let invalidMemoryMsg = info => `Invalid Lambda memory setting: ${info}, memory must be between ${minMemory} - ${maxMemory} MB`
+
+// Timeout
+let minTimeout = 1
+let maxTimeout = 1 * 60 * 15 // 15 mins
+let invalidTimeout = timeout => !is.number(timeout) || (timeout < minTimeout) || (timeout > maxTimeout)
+let invalidTimeoutMsg = info => `Invalid Lambda timeout setting: ${info}, timeout must be between ${minTimeout} - ${maxTimeout} seconds`

package/src/validate/index.js

@@ -1,4 +1,4 @@
-let runtimes = require('./runtimes')
+let config = require('./config')
 let layers = require('./layers')
 let tablesChildren = require('./tables-children')
 let errorFmt = require('../lib/error-fmt')
@@ -12,9 +12,8 @@ module.exports = function finalValidation (params, inventory) {
   /**
    * Deal with vendor configuration errors
    */
-
-  // Blow up on any non-matching runtimes
-  runtimes(params, inventory, errors)
+  // Analyze function configuration
+  config(params, inventory, errors)
 
   // Ensure layer configuration will work, AWS blows up with awful errors on this
   layers(params, inventory, errors)
@@ -32,8 +31,7 @@ module.exports = function finalValidation (params, inventory) {
   /**
    * Deal with project validation errors
    */
-
-  // Ensure @tables children (@streams, @indexes) have parent tables present
+  // Ensure @tables children (@tables-streams, @indexes) have parent tables present
   tablesChildren(inventory, errors)
 
   if (errors.length) {

package/src/validate/layers.js

@@ -1,12 +1,14 @@
 let { sep } = require('path')
 let { lambdas } = require('../lib/pragmas')
-let validateARN = require('./arn')
+let is = require('../lib/is')
+let plural = arr => arr.length > 1 ? 's' : ''
 
 /**
  * Layer validator
  */
 module.exports = function layerValidator (params, inventory, errors) {
-  let { region } = inventory.aws
+  let { _project } = inventory
+  let { region, layers: globalLayers } = inventory.aws
   let { cwd, validateLayers = true } = params
 
   // Shouldn't be possible because we backfill region, but jic
@@ -15,39 +17,69 @@ module.exports = function layerValidator (params, inventory, errors) {
   // Allow for manual opt-out of layer validation
   if (!validateLayers) return
 
-  // Walk the tree of layer configs, starting with @aws
-  Object.entries(inventory).forEach(([ i ]) => {
-    let item = inventory[i]
-    if (i === 'aws') {
-      let location = inventory._project.manifest &&
-                     inventory._project.manifest.replace(cwd, '')
-      let layers = item.layers
-      validateLayer({ layers, region, location })
-    }
-    else if (lambdas.includes(i) && item) {
-      item.forEach(entry => {
-        // Probably unnecessary if no configFile is present but why not, let's be extra safe
-        let location = entry.configFile && entry.configFile.replace(cwd, '')
-        let layers = entry.config.layers
-        validateLayer({ layers, region, location })
-      })
-    }
+  /**
+   * Global config
+   */
+  let location = _project?.manifest?.replace(cwd, '')
+  validateLayer({ layers: globalLayers, region, location, errors })
+
+  /**
+   * Lambda config
+   */
+  lambdas.forEach(p => {
+    let pragma = inventory[p]
+    if (pragma) pragma.forEach(({ config, configFile }) => {
+      let location = configFile?.replace(cwd, '')
+      validateLayer({ layers: config.layers, region, location, errors })
+    })
   })
+}
 
-  function validateLayer ({ layers, region, location }) {
-    let loc = location && location.startsWith(sep) ? location.substr(1) : location
-    let lambda = loc ? `  - Lambda: ${loc}\n` : ''
-    if (!layers || !layers.length) return
-    else {
-      if (layers.length > 5) {
-        let list = `  - Layers:\n ${layers.map(l => `    - ${l}`).join('\n')}`
-        errors.push(`Lambda can only be configured with up to 5 layers\n${lambda}${list}`)
-      }
-      // CloudFormation fails without a helpful error if any layers aren't in the same region as the app because CloudFormation
-      for (let arn of layers) {
-        let arnError = validateARN({ arn, region, loc })
-        if (arnError) errors.push(arnError)
-      }
+function validateLayer ({ layers, region, location, errors }) {
+  let loc = location && location.startsWith(sep) ? location.substr(1) : location
+  let config = loc ? ` (${loc})` : ''
+  if (!layers || !layers.length) return
+  else {
+    if (layers.length > 5) {
+      let list = `${layers.map(l => `  - ${l}`).join('\n')}`
+      errors.push(`Lambdas can only be configured with up to 5 layers, got ${layers.length} layers${config}:\n${list}`)
     }
+    // CloudFormation fails without a helpful error if any layers aren't in the same region as the app because CloudFormation
+    let arnErrors = validateARN({ layers, region, config })
+    if (arnErrors) errors.push(arnErrors)
+  }
+}
+
+// Validates Lambda layer / policy ARNs, prob can't be used for other kinds of ARN
+function validateARN ({ layers, region, config }) {
+  let invalidArns = []
+  let badRegions = []
+  layers.forEach(arn => {
+    let parts = is.string(arn) && arn.split(':')
+    // Invalid
+    if (!is.string(arn) ||
+        !arn.startsWith('arn:') ||
+        parts.length !== 8) {
+      return invalidArns.push(`  - ${arn}`)
+    }
+    // Bad region
+    let layerRegion = parts[3]
+    if (region !== layerRegion) {
+      badRegions.push(
+        `  - Layer ARN: ${arn}\n` +
+        `  - Layer region: ${layerRegion}`
+      )
+    }
+  })
+  let err = ''
+  if (invalidArns.length) {
+    err +=  `Invalid ARN${plural(invalidArns)}${config}:\n` +
+            invalidArns.join('\n')
+  }
+  if (badRegions.length) {
+    err +=  `Layer${plural(badRegions)} ` +
+            `not in app's region of ${region}${config}:\n` +
+            badRegions.join('\n')
   }
+  if (err) return err
 }

package/src/validate/tables-children.js

@@ -1,17 +1,17 @@
 /**
- * Ensure @tables children (@streams, @indexes) have parent tables present
+ * Ensure @tables children (@tables-streams, @indexes) have parent tables present
  * - If not, configuration is invalid
  */
 module.exports = function validateTablesChildren (inventory, errors) {
-  let { indexes, streams, tables } = inventory
+  let { indexes, 'tables-streams': tablesStreams, tables } = inventory
 
   function check (table, type) {
     if (!tables.some(t => t.name === table)) {
       errors.push(`@${type} ${table} missing corresponding table`)
     }
   }
-  if (streams) {
-    streams.forEach(stream => check(stream.table, 'streams'))
+  if (tablesStreams) {
+    tablesStreams.forEach(stream => check(stream.table, 'tables-streams'))
   }
   if (indexes) {
     indexes.forEach(index => check(index.name, 'indexes'))

package/src/config/pragmas/validate/_streams.js

@@ -1,19 +0,0 @@
-let { regex, size, unique } = require('./_lib')
-
-/**
- * Validate @streams (& @tables streams true)
- *
- * Where possible, attempts to follow DynamoDB validation
- * See: https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.NamingRulesDataTypes.html
- */
-module.exports = function validateStreams (streams, errors) {
-  if (streams.length) {
-    unique(streams, '@streams', errors)
-
-    streams.forEach(stream => {
-      let { name } = stream
-      size(name, 3, 255, '@streams', errors)
-      regex(name, 'veryLooseName', '@streams', errors)
-    })
-  }
-}

package/src/validate/arn.js

@@ -1,24 +0,0 @@
-let is = require('../lib/is')
-
-// Validates Lambda layer / policy ARNs, prob can't be used for other kinds of ARN
-module.exports = function validateARN ({ arn, region, loc }) {
-  if (!is.string(arn) ||
-      !arn.startsWith('arn:') ||
-      arn.split(':').length !== 8) {
-    /* istanbul ignore next */
-    let lambda = loc ? `in ${loc}` : ''
-    return `Invalid ARN${lambda}: ${arn}`
-  }
-
-  let parts = arn.split(':')
-  let layerRegion = parts[3]
-  if (region !== layerRegion) {
-    /* istanbul ignore next */
-    let lambda = loc ? `  - Lambda: ${loc}\n` : ''
-    let err = `Lambda layers must be in the same region as app\n` + lambda +
-              `  - App region: ${region}\n` +
-              `  - Layer ARN: ${arn}\n` +
-              `  - Layer region: ${layerRegion}`
-    return err
-  }
-}

package/src/validate/runtimes.js

@@ -1,28 +0,0 @@
-let { lambdas } = require('../lib/pragmas')
-let { aliases, runtimeList } = require('lambda-runtimes')
-
-/**
- * Runtime validator
- */
-module.exports = function runtimeValidator (params, inventory, errors) {
-
-  let allRuntimes = runtimeList.concat([ 'deno' ])
-  let globalRuntime = inventory.aws?.runtime
-  if (globalRuntime &&
-      !allRuntimes.includes(globalRuntime) &&
-      !aliases[globalRuntime]) {
-    errors.push(`Invalid project-level runtime: ${globalRuntime}`)
-  }
-
-  // Walk the tree of layer configs, starting with @aws
-  lambdas.forEach(p => {
-    let pragma = inventory[p]
-    if (pragma) pragma.forEach(entry => {
-      let runtime = entry.config.runtime
-      if (runtime === globalRuntime) return
-      if (!allRuntimes.includes(runtime)) {
-        errors.push(`Invalid runtime: ${runtime} (@${p} ${entry.name})`)
-      }
-    })
-  })
-}