@architect/inventory 2.1.3 → 2.2.1

package/changelog.md

@@ -2,6 +2,26 @@
 
 ---
 
+## [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
+
+- 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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@architect/inventory",
-  "version": "2.1.3",
+  "version": "2.2.1",
   "description": "Architect project resource enumeration utility",
   "main": "src/index.js",
   "scripts": {
@@ -23,19 +23,19 @@
     "@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"

package/src/config/pragmas/http.js

@@ -2,6 +2,7 @@ let { join } = require('path')
 let populate = require('./populate-lambda')
 let asapSrc = require('../../lib/asap-src')
 let validate = require('./validate')
+let sort = require('./sort/http')
 
 module.exports = function configureHTTP ({ arc, inventory, errors }) {
   if (!arc.http) return null
@@ -67,7 +68,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,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/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,9 +98,9 @@ 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
-  /* istanbul ignore else */ /* Clearer to be explicit here */
+  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/sort/http.js

@@ -0,0 +1,72 @@
+let methods = require('../../../lib/http-methods')
+
+/**
+ * HTTP route sorter; this is a multifurcating tree, so we'll do a few passes
+ * Broadly in the theme of most to least specific:
+ * - First, by method, with `any` last
+ * - Then by path depth (descending)
+ * - Within each depth downrank for contained params
+ * - Then sort alphabetically
+ * - Then, ensure trailing captures are last
+ * - Finally, ensure root captures rank below a root literal
+ */
+module.exports = function sortHTTP (http) {
+  // Construct the tree from HTTP methods
+  let tree = {}
+  http.forEach(({ method, path }) => {
+    if (!tree[method]) tree[method] = []
+    let parts = path.split('/').filter(Boolean)
+    let depth = parts.length
+    let item = { depth, path }
+    let param = /\/:/
+    if (path.match(param)) {
+      item.hasParam = true
+      item.paramIndex = path.match(param).index // If multiple, we want the earliest
+    }
+    if (parts.length) {
+      if (parts[depth - 1] === '*') item.trailingCapture = 'catchall'
+      if (parts[depth - 1].startsWith(':')) item.trailingCapture = 'param'
+    }
+    tree[method].push(item)
+  })
+
+  // Multi-pass route sort
+  let sorted = []
+  methods.forEach(method => {
+    if (!tree[method]) return
+    /* istanbul ignore next: random test shuffles may not trigger all paths */
+    tree[method]
+      // Sort by depth
+      .sort((a, b) => b.depth - a.depth)
+      // Sort within a given depth
+      .sort((a, b) => {
+        // Handle root (depth: 0)
+        if (a.depth - b.depth < 0) return
+        if (a.hasParam && b.hasParam) {
+          // Sort at the earliest param
+          if (a.paramIndex < b.paramIndex) return 1
+          if (a.paramIndex > b.paramIndex) return -1
+          // Then sort alphabetically
+          if (a.path < b.path) return -1
+          if (a.path > b.path) return 1
+        }
+        if (a.hasParam) return 1
+        if (b.hasParam) return -1
+        if (a.path < b.path) return -1
+        if (a.path > b.path) return 1
+      })
+      // Trailing capture sort
+      .sort((a, b) => {
+        if (!a.depth && b.depth === 1 && b.trailingCapture) return -1
+        if (a.depth - b.depth < 0) return
+        if (a.trailingCapture) return 1
+        if (b.trailingCapture) return -1
+      })
+    tree[method].forEach(({ path }) => {
+      let route = http.find(i => i.method === method && i.path === path)
+      sorted.push(route)
+    })
+  })
+
+  return sorted
+}

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/_http.js

@@ -1,10 +1,10 @@
 let { unique } = require('./_lib')
+let methods = require('../../../lib/http-methods')
 
 module.exports = function validateHTTP (http, errors) {
   if (http.length) {
     unique(http, '@http routes', errors)
 
-    let methods = [ 'get', 'post', 'put', 'patch', 'delete', 'options', 'head', 'any' ]
     let validMethod = str => methods.includes(str.toLowerCase())
     let validPath = str => str.match(/^\/[a-zA-Z0-9/\-:._\*]*$/)
     http.forEach(route => {
@@ -49,7 +49,7 @@ module.exports = function validateHTTP (http, errors) {
       let params = path.match(/\/:/g)
       if (params) {
         // Params cannot have non-alphanumeric characters
-        let match = path.match(/\/:[a-zA-Z0-9]+(\/|$)/g)
+        let match = path.match(/\/:[\w.-]+(\/|$)/g)
         if (!match) errors.push(`Invalid @http path (parameters must have only alphanumeric characters): ${name}`)
       }
 

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/config/project/index.js

@@ -36,7 +36,7 @@ module.exports = function getProjectConfig (params, errors) {
       project[`${scope}PreferencesFile`] = p.preferencesFile
 
       // Build out the final preferences
-      /* istanbul ignore else */ // jic
+      /* istanbul ignore else: jic */
       if (!project.preferences) project.preferences = {}
       Object.keys(p.preferences).forEach(pragma => {
         // Ignore the raw data
@@ -47,7 +47,7 @@ module.exports = function getProjectConfig (params, errors) {
           return
         }
         // Traverse and merge individual settings
-        /* istanbul ignore else */ // jic
+        /* istanbul ignore else: jic */
         if (!project.preferences[pragma]) project.preferences[pragma] = {}
         Object.entries(p.preferences[pragma]).forEach(([ setting, value ]) => {
           project.preferences[pragma][setting] = value

package/src/config/project/prefs.js

@@ -18,13 +18,13 @@ module.exports = function getPrefs ({ scope, inventory, errors }) {
     Object.entries(prefs.arc).forEach(([ key, val ]) => {
       // TODO add additional preferences checks and normalization
 
-      /* istanbul ignore else */ // Parser should get this, but jic
+      /* istanbul ignore else: Parser should get this, but jic */
       if (!preferences[key]) preferences[key] = {}
-      /* istanbul ignore else */ // Parser should only produce arrays, but jic
+      /* istanbul ignore else: Parser should only produce arrays, but jic */
       if (is.array(val)) {
         val.forEach(v => {
           if (is.array(v)) {
-            /* istanbul ignore if */ // Single vals should be strings, but jic
+            /* istanbul ignore if: Single vals should be strings, but jic */
             if (v.length === 1) preferences[key] = v[0]
             if (v.length === 2) preferences[key][v[0]] = v[1]
             if (v.length > 2)   preferences[key][v[0]] = [ ...v.slice(1) ]
@@ -39,7 +39,7 @@ module.exports = function getPrefs ({ scope, inventory, errors }) {
       // Turn env vars with spaces into strings
       if (key === 'env') {
         [ 'testing', 'staging', 'production' ].forEach(e => {
-          /* istanbul ignore else */ // Yet another jic
+          /* istanbul ignore else: Yet another jic */
           if (preferences.env[e]) {
             Object.entries(preferences.env[e]).forEach(([ key, val ]) => {
               if (is.array(val)) preferences.env[e][key] = val.join(' ')
@@ -51,7 +51,7 @@ module.exports = function getPrefs ({ scope, inventory, errors }) {
       if (key === 'sandbox-startup') {
         preferences[key] = val.map(v => {
           if (is.string(v)) return v
-          /* istanbul ignore else */ // Yet another jic
+          /* istanbul ignore else: Yet another jic */
           if (is.array(v)) return v.join(' ')
         })
       }

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/env/index.js

@@ -45,7 +45,7 @@ module.exports = function env (params, inventory, callback) {
             }
           }))
           // Check for more data and, if so, recurse
-          /* istanbul ignore if */ // Sadly no way to easily mock this for testing
+          /* istanbul ignore if: Sadly no way to easily mock this for testing */
           if (data.NextToken) {
             getSomeEnvVars(name, data.NextToken, callback)
           }

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/http-methods.js

@@ -0,0 +1,2 @@
+// Any must come last for Sandbox route sorting purposes
+module.exports = [ 'get', 'post', 'put', 'patch', 'delete', 'options', 'head', 'any' ]

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/index.js

@@ -31,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/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)
-    })
-  }
-}