@architect/inventory 2.2.0 → 3.0.0-RC.1

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

@@ -1,6 +1,7 @@
 let populate = require('./populate-lambda')
 let validate = require('./validate')
-let is = require('../../lib/is')
+let { is } = require('../../lib')
+let ts = 'tables-streams'
 
 /**
  * `@tables-streams`
@@ -9,8 +10,9 @@ let is = require('../../lib/is')
  *   - If a project has an existing `@tables` Lambda, we'll continue using that so long as the directory exists
  */
 module.exports = function configureTablesStreams ({ arc, inventory, errors }) {
-  if (!arc['tables-streams'] && !arc.tables) return null
-  if (arc['tables-streams'] && !arc.tables) {
+  let tablesStreamsPlugins = inventory.plugins?._methods?.set?.[ts]
+  if (!arc[ts]?.length && !tablesStreamsPlugins?.length && !arc.tables?.length) return null
+  if ((arc[ts] || tablesStreamsPlugins) && !arc.tables) {
     errors.push(`Specifying @tables-streams requires specifying corresponding @tables`)
     return null
   }
@@ -18,12 +20,12 @@ module.exports = function configureTablesStreams ({ arc, inventory, errors }) {
   // Populate @tables
   let tables = arc.tables.filter(t => is.object(t) && t[Object.keys(t)[0]].stream === true)
   if (tables.length) {
-    tables = populate.tables(tables, inventory, errors)
+    tables = populate.tables({ arc, inventory, errors, pragma: tables })
   }
   else tables = null
 
   // Populate @tables-streams
-  let streams = populate['tables-streams'](arc['tables-streams'], inventory, errors)
+  let streams = populate[ts]({ arc, inventory, errors })
 
   if (tables && streams) {
     let uniqueTables = tables.filter(t => !streams.some(s => s.table === t.table))

package/src/config/pragmas/tables.js

@@ -1,4 +1,4 @@
-let is = require('../../lib/is')
+let { is } = require('../../lib')
 let validate = require('./validate')
 
 module.exports = function configureTables ({ arc, errors }) {

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

@@ -8,7 +8,7 @@ let { regex, size, unique } = require('./_lib')
  * See: https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-message-metadata.html
  */
 module.exports = function validateEventsAndQueues (pragma, pragmaName, errors) {
-  if (pragma.length) {
+  if (pragma?.length) {
     unique(pragma, pragmaName, errors)
 
     pragma.forEach(event => {

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

@@ -1,11 +1,11 @@
 let { unique } = require('./_lib')
+let { httpMethods } = require('../../../lib')
 
 module.exports = function validateHTTP (http, errors) {
-  if (http.length) {
+  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 validMethod = str => httpMethods.includes(str.toLowerCase())
     let validPath = str => str.match(/^\/[a-zA-Z0-9/\-:._\*]*$/)
     http.forEach(route => {
       let { name, method, path } = 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/_lib.js

@@ -1,4 +1,4 @@
-let is = require('../../../lib/is')
+let { is } = require('../../../lib')
 
 let patterns = {
   looseName: new RegExp(/^[a-z][a-zA-Z0-9-_]+$/),

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

@@ -1,4 +1,4 @@
-let is = require('../../../lib/is')
+let { is } = require('../../../lib')
 let { regex, size, unique } = require('./_lib')
 
 /**
@@ -10,7 +10,7 @@ let { regex, size, unique } = require('./_lib')
  * See: https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-create-rule-schedule.html
  */
 module.exports = function validateScheduled (scheduled, errors) {
-  if (scheduled.length) {
+  if (scheduled?.length) {
     unique(scheduled, '@scheduled', errors)
 
     scheduled.forEach(schedule => {

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

@@ -1,5 +1,5 @@
 let { join, resolve, sep } = require('path')
-let is = require('../../../lib/is')
+let { is } = require('../../../lib')
 
 module.exports = function validateShared (src, cwd, errors) {
   let path = src && resolve(join(cwd, src))

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

@@ -7,13 +7,11 @@ let { regex, size, unique } = require('./_lib')
  * 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)
+  unique(tablesStreams, '@tables-streams', errors)
 
-    tablesStreams.forEach(stream => {
-      let { name } = stream
-      size(name, 3, 255, '@tables-streams', errors)
-      regex(name, 'veryLooseName', '@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

@@ -2,13 +2,13 @@ let { regex, size, unique } = require('./_lib')
 let { deepStrictEqual } = require('assert')
 
 /**
- * Validate @tables + @indexes
+ * Validate @tables + @tables-indexes
  *
  * Where possible, attempts to follow DynamoDB validation
  * See: https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.NamingRulesDataTypes.html
  */
 module.exports = function validateTablesAndIndexes (pragma, pragmaName, errors) {
-  if (pragma.length) {
+  if (pragma?.length) {
     pragma.forEach(table => {
       let { name, indexName, partitionKey, sortKey } = table
 

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

@@ -4,12 +4,12 @@ module.exports = {
   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
+  tables:         require('./_tables'),
+  tablesIndexes:  require('./_tables'), // Same ruleset as @tables (more or less)
   tablesStreams:  require('./_tables-streams'),
   websockets:     require('./_websockets'),
 

package/src/config/pragmas/views.js

@@ -1,6 +1,6 @@
 let { join } = require('path')
 let validate = require('./validate')
-let is = require('../../lib/is')
+let { is } = require('../../lib')
 
 module.exports = function configureViews ({ arc, pragmas, inventory, errors }) {
   if (arc.views && !arc.http) {
@@ -9,46 +9,28 @@ module.exports = function configureViews ({ arc, pragmas, inventory, errors }) {
   }
   if (!arc.http) return null
 
-  let cwd = inventory._project.src
-  let src = join(cwd, 'src', 'views')
+  let { cwd, src: projSrc } = inventory._project
+  let src = join(projSrc, 'views')
   let views = {
     src,
     views: [] // Revert to null later if none are defined
   }
 
-  if (arc.views && arc.views.length) {
-    let foundSrc = false
-
-    // First pass to get + check views folder (if any)
+  // First pass to get + check views folder (if any)
+  let foundSrc = false
+  if (arc?.views?.length) {
     for (let view of arc.views) {
-      let key = view[0].toLowerCase()
-      if (key === 'src' && is.string(view[1])) {
-        views.src = view[1]
-        foundSrc = true
-        validate.shared(views.src, cwd, errors)
-      }
-    }
-
-    // Proceeding from here resets all views config, so make sure it's only if specific views are specified
-    let some = !(arc.views.length === 1 && foundSrc)
-    if (some) {
-      // Reset views settings
-      for (let route of pragmas.http) {
-        route.config.views = false
-      }
-
-      // Set new views settings
-      for (let view of arc.views) {
-        let method = view[0].toLowerCase()
-        let path = view[1]
-        if (method === 'src') continue
-        let name = `${method} ${path}`
-        let route = pragmas.http.find(n => n.name === name)
-        if (!route) {
-          return errors.push(`@views ${name} not found in @http routes`)
+      if (is.array(view)) {
+        let key = view[0]?.toLowerCase()
+        if (key === 'src' && is.string(view[1])) {
+          views.src = view[1]
+          foundSrc = true
+          validate.shared(views.src, cwd, errors)
+          continue
+        }
+        if (key === 'src' && !is.string(view[1])) {
+          errors.push(`@shared invalid setting: ${key}`)
         }
-        // Ignore views into ASAP
-        if (!route.arcStaticAssetProxy) route.config.views = true
       }
     }
   }
@@ -56,6 +38,29 @@ module.exports = function configureViews ({ arc, pragmas, inventory, errors }) {
   // Exit if default views folder doesn't exist
   if (!is.exists(views.src)) return null
 
+  // Proceeding from here resets all views config, so make sure it's only if specific views are specified
+  let some = arc.views?.length && !(arc?.views?.length === 1 && foundSrc)
+  if (some) {
+    // Reset views settings
+    for (let route of pragmas.http) {
+      route.config.views = false
+    }
+
+    // Set new views settings
+    for (let view of arc.views) {
+      let method = view[0].toLowerCase()
+      let path = view[1]
+      if (method === 'src') continue
+      let name = `${method} ${path}`
+      let route = pragmas.http.find(n => n.name === name)
+      if (!route) {
+        return errors.push(`@views ${name} not found in @http routes`)
+      }
+      // Ignore views into ASAP
+      if (!route.arcStaticAssetProxy) route.config.views = true
+    }
+  }
+
   // lambda.config.views was added by Lambda populator defaults, or added above
   for (let { src, config } of pragmas.http) {
     if (config.views === true && !views.views.includes(src)) {
@@ -63,8 +68,5 @@ module.exports = function configureViews ({ arc, pragmas, inventory, errors }) {
     }
   }
 
-  // De-dupe (in case multiple functions live at the same src path)
-  views.views = [ ...new Set(views.views) ]
-
   return views
 }

package/src/config/pragmas/ws.js

@@ -2,21 +2,23 @@ let populate = require('./populate-lambda')
 let validate = require('./validate')
 
 module.exports = function configureWS ({ arc, inventory, errors }) {
-  if (!arc.ws) return null
+  let wsPlugins = inventory.plugins?._methods?.set?.ws
+  if (!arc.ws && !wsPlugins?.length) return null
 
-  let ws = [ ...arc.ws ]
+  let ws = [ ]
+  if (arc.ws) ws.push(...arc.ws)
 
   // Backfill required routes if not already present
   let defaults = [ 'disconnect', 'default', 'connect' ]
   defaults.forEach(route => {
-    let found = arc.ws.find(item => {
+    let found = arc?.ws?.find(item => {
       if (item === route) return true
       if (item[route]) return true
     })
     if (!found) ws.unshift(route)
   })
 
-  let websockets = populate.ws(ws, inventory, errors)
+  let websockets = populate.ws({ arc, inventory, errors, pragma: ws })
 
   // Forgive and normalize userland use of '$default', '$connect', '$disconnect'
   websockets.forEach(({ name }, i) => {

package/src/config/project/index.js

@@ -1,13 +1,14 @@
+let { join } = require('path')
 let upsert = require('../_upsert')
 let prefs = require('./prefs')
-let is = require('../../lib/is')
 let plugins = require('./plugins')
+let { is } = require('../../lib')
 
 /**
  * Get the project-level configuration, overlaying arc.aws settings (if present)
  */
-module.exports = function getProjectConfig (params, errors) {
-  let { arc, raw, filepath, inventory } = params
+module.exports = function getProjectConfig (params) {
+  let { arc, errors, raw, filepath, inventory } = params
   let project = {
     ...inventory._project,
     arc,
@@ -20,13 +21,9 @@ module.exports = function getProjectConfig (params, errors) {
 
   if (filepath) {
     project.manifest = filepath
-    // TODO add manifestCreated once we determine we can get birthtime reliably
   }
 
-  // require project plugin modules
-  project.plugins = plugins(project, errors)
-
-  // parse local and global arc preferences
+  // Parse local and global project preferences
   let scopes = [ 'global', 'local' ]
   for (let scope of scopes) {
     let p = prefs({ scope, inventory, errors })
@@ -36,7 +33,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 +44,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
@@ -56,5 +53,13 @@ module.exports = function getProjectConfig (params, errors) {
     }
   }
 
+  if (inventory.plugins?._methods) {
+    // TODO: project.env = plugins.env(params, project)
+
+    let { build, runtimes } = plugins.runtimes(params, project)
+    if (build)    project.build = join(project.cwd, build)
+    if (runtimes) project.customRuntimes = runtimes
+  }
+
   return project
 }

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

@@ -0,0 +1,5 @@
+let runtimes = require('./runtimes')
+
+module.exports = {
+  runtimes,
+}

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

@@ -0,0 +1,56 @@
+let { is } = require('../../../lib')
+let { aliases, runtimeList } = require('lambda-runtimes')
+let allRuntimes = runtimeList.concat([ 'deno', ...Object.keys(aliases) ])
+
+module.exports = function setRuntimePlugins (params, project) {
+  let { errors, inventory } = params
+  let runtimePlugins = inventory.plugins?._methods?.set?.runtimes
+  if (runtimePlugins?.length) {
+    let runtimes = {
+      runtimes: [],
+    }
+    // inventory._project is not yet built, so provide as much as we can to plugins for now
+    let inv = { ...inventory, _project: project }
+    let build
+    runtimePlugins.forEach(fn => {
+      let errType = `plugin: ${fn.plugin}, method: set.runtimes`
+      try {
+        let result = fn({ inventory: inv })
+        result = is.array(result) ? result : [ result ]
+        result.forEach(runtime => {
+          // TODO add more validation
+          let { name } = runtime
+          if (!name) {
+            let msg = `Runtime plugin must provide a name: ${errType}`
+            return errors.push(msg)
+          }
+          if (allRuntimes.includes(name)) {
+            let msg = `Runtime name '${name}' is reserved: ${errType}`
+            return errors.push(msg)
+          }
+          if (runtimes[name]) {
+            let msg = `Runtime '${name}' already registered: ${errType}`
+            return errors.push(msg)
+          }
+          if (runtime.build) {
+            if (build && build !== runtime.build) {
+              errors.push(`Runtime '${name}' cannot set a build directory, as it is already configured to: ${build}`)
+            }
+            else if (is.bool(runtime.build) ||
+                !is.string(runtime.build)) {
+              build = 'build'
+            }
+            else build = runtime.build
+          }
+          runtimes.runtimes.push(name)
+          runtimes[name] = runtime
+        })
+      }
+      catch (err) {
+        errors.push(`Runtime plugin '${fn.plugin}' failed: ${err.message}`)
+      }
+    })
+    return { build, runtimes }
+  }
+  return {}
+}

package/src/config/project/prefs.js

@@ -1,12 +1,12 @@
 let read = require('../../read')
 let validate = require('./validate')
-let is = require('../../lib/is')
+let { is } = require('../../lib')
 let { homedir } = require('os')
 
 module.exports = function getPrefs ({ scope, inventory, errors }) {
   let cwd = scope === 'global'
     ? homedir()
-    : inventory._project.src
+    : inventory._project.cwd
 
   // Populate preferences
   let prefs = read({ type: 'preferences', cwd, errors })
@@ -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/config/project/validate/index.js

@@ -1,4 +1,4 @@
-let is = require('./../../../lib/is')
+let { is } = require('./../../../lib')
 
 module.exports = function validatePreferences (preferences, errors) {
   // Env checks

package/src/defaults/index.js

@@ -1,14 +1,15 @@
+let { join } = require('path')
 let fnConfig = require('./function-config')
-let pragmas = require('../lib/pragmas')
+let { pragmas } = require('../lib')
 
 /**
  * Returns a default stub inventory object
  * - Every possible officially supported value should be present
  */
 module.exports = function inventoryDefaults (params = {}) {
-  let { cwd, region } = params
+  let { cwd = process.cwd(), region } = params
   // Allow region env var override
-  region = process.env.AWS_REGION || region || 'us-west-2'
+  region = region || process.env.AWS_REGION || 'us-west-2'
   let defaultFunctionConfig = fnConfig()
   return {
     // Meta
@@ -19,9 +20,10 @@ module.exports = function inventoryDefaults (params = {}) {
     },
     _project: {
       type: 'aws',
-      src: cwd,
+      cwd,                          // Project root dir
+      src: join(cwd, 'src'),        // Default source tree dir
+      build: null,                  // Optional build artifact dir
       manifest: null,               // Root project manifest filename
-      // manifestCreated            // TODO
       preferences: null,            // Realized preferences obj, resolved from global > local
       localPreferences: null,       // Local preferences obj
       localPreferencesFile: null,   // Local preferences file path
@@ -29,10 +31,10 @@ module.exports = function inventoryDefaults (params = {}) {
       globalPreferencesFile: null,  // Global preferences file path
       defaultFunctionConfig,        // Project-level function config
       rootHandler: null,            // null | configured | arcStaticAssetProxy | proxy
-      plugins: null,                // `require`d plugin modules as a map of plugin name to module
+      env: null,                    // Env vars pulled from SSM + plugins
+      customRuntimes: null,         // Runtime plugins
       arc: [],                      // Raw arc obj
       raw: '',                      // Raw arc string
-      env: null,                    // Env vars pulled from SSM (if enabled)
     },
     // App + vendor config
     app: '',
@@ -52,9 +54,7 @@ module.exports = function inventoryDefaults (params = {}) {
     cdn: null,
     events: null,
     http: null,
-    indexes: null,
-    macros: null,
-    plugins: null, // These are the Lambdas created by plugins, not the plugin modules, which are in _project.plugins
+    plugins: null,
     proxy: null,
     queues: null,
     scheduled: null,
@@ -65,7 +65,9 @@ module.exports = function inventoryDefaults (params = {}) {
     'tables-streams': null,
     views: null,
     ws: null,
-    // Collection of all Lambda paths
+    // Unclassified / non-pragma custom Lambdas created by plugins
+    customLambdas: null,
+    // Collection of all Lambda source paths
     lambdaSrcDirs: null,
     // Lambda lookup by source directory
     lambdasBySrcDir: null,

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

@@ -1,4 +1,4 @@
-let is = require('./lib/is')
+let { is } = require('./lib')
 
 module.exports = function _get (inventory) {
   function getter (prag, name) {
@@ -38,5 +38,4 @@ module.exports = function _get (inventory) {
 // These refer to other pragmas, and thus may allow multiple same/same-named entities
 let multipleResults = [
   'tables-indexes',
-  'indexes',
 ]

package/src/index.js

@@ -5,7 +5,7 @@ let config = require('./config')
 let getEnv = require('./env')
 let validate = require('./validate')
 let get = require('./get')
-let errorFmt = require('./lib/error-fmt')
+let { errorFmt } = require('./lib')
 
 /**
  * Architect Inventory
@@ -50,10 +50,7 @@ module.exports = function architectInventory (params = {}, callback) {
 
   // Exit early if supplied Arc is fundamentally broken
   if (errors.length) {
-    callback(errorFmt({
-      type: 'manifest',
-      errors,
-    }))
+    callback(errorFmt({ type: 'manifest', errors }))
     return promise
   }
 
@@ -61,27 +58,32 @@ module.exports = function architectInventory (params = {}, callback) {
   let inventory = inventoryDefaults(params)
 
   // Set up project params for config
-  let project = { cwd, arc, raw, filepath, inventory }
+  let project = { arc, cwd, errors, filepath, inventory, raw }
 
   // Populate inventory.arc
   inventory._arc = config._arc(project)
 
+  // @plugins come first, as they register hooks all around the project
+  inventory.plugins = config.pragmas.plugins(project)
+
   // Establish default function config from project + Arc defaults
-  inventory._project = config._project(project, errors)
+  inventory._project = config._project(project)
+
+  // End here if plugins failed
+  if (errors.length) {
+    callback(errorFmt({ type: 'plugin', errors }))
+    return promise
+  }
 
-  // Userland: fill out the pragmas
+  // Userland: fill out the pragmas, starting with @plugins
   inventory = {
     ...inventory,
-    ...config.pragmas(project, errors)
+    ...config.pragmas(project)
   }
 
-  // End here if first-pass pragma validation failed
+  // End here if first-pass validation failed
   if (errors.length) {
-    callback(errorFmt({
-      type: 'validation',
-      errors,
-      inventory,
-    }))
+    callback(errorFmt({ type: 'validation', errors }))
     return promise
   }