@architect/inventory 2.1.3 → 2.2.0-RC.0

package/changelog.md

@@ -2,6 +2,17 @@
 
 ---
 
+## [2.2.0] 2021-11-11
+
+### 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.0-RC.0",
   "description": "Architect project resource enumeration utility",
   "main": "src/index.js",
   "scripts": {

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 an @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
+    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,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/_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/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)
-    })
-  }
-}