@architect/inventory 2.2.1 → 3.0.0-RC.3

package/src/env/index.js

@@ -1,76 +1,91 @@
+let { mergeEnvVars } = require('../lib')
+
 /**
  * Read env vars out of SSM
  */
 module.exports = function env (params, inventory, callback) {
-  if (params.env) {
-    /* istanbul ignore next */
-    try {
-      // eslint-disable-next-line
-      var aws = require('aws-sdk')
-    }
-    catch (err) {
-      let msg = `'aws-sdk' not found, please install locally or globally (see also readme#aws-sdk-caveat)`
-      return callback(Error(msg))
-    }
-    let name = inventory.app
-    let { region } = inventory.aws
-    let ssm = new aws.SSM({ region })
-    let result = []
-
-    function getSomeEnvVars (name, NextToken, callback) {
-      // Base query to ssm
-      let query = {
-        Path: `/${name}`,
-        Recursive: true,
-        MaxResults: 10,
-        WithDecryption: true
-      }
+  if (!params.env) {
+    return callback()
+  }
 
-      // Check if we're paginating
-      /* istanbul ignore if */
-      if (NextToken) query.NextToken = NextToken
+  /* istanbul ignore next */
+  try {
+    // eslint-disable-next-line
+      var aws = require('aws-sdk')
+  }
+  catch (err) {
+    let msg = `'aws-sdk' not found, please install locally or globally (see also readme#aws-sdk-caveat)`
+    return callback(Error(msg))
+  }
+  let name = inventory.app
+  let { region } = inventory.aws
+  let ssm = new aws.SSM({ region })
+  let result = []
 
-      // Perform the query
-      ssm.getParametersByPath(query, function _query (err, data) {
-        if (err) callback(err)
-        else {
-          // Tidy up the response
-          result = result.concat(data.Parameters.map(function (param) {
-            let bits = param.Name.split('/')
-            return {
-              app: name, // jic
-              env: bits[2],
-              name: bits[3],
-              value: param.Value,
-            }
-          }))
-          // Check for more data and, if so, recurse
-          /* istanbul ignore if: Sadly no way to easily mock this for testing */
-          if (data.NextToken) {
-            getSomeEnvVars(name, data.NextToken, callback)
-          }
-          else callback(null, result)
-        }
-      })
+  function getSomeEnvVars (name, NextToken, callback) {
+    // Base query to ssm
+    let query = {
+      Path: `/${name}`,
+      Recursive: true,
+      MaxResults: 10,
+      WithDecryption: true
     }
 
-    getSomeEnvVars(name, false, function done (err, result) {
+    // Check if we're paginating
+    /* istanbul ignore if */
+    if (NextToken) query.NextToken = NextToken
+
+    // Perform the query
+    ssm.getParametersByPath(query, function _query (err, data) {
       if (err) callback(err)
       else {
-        if (result.length) {
-          let testing = null
-          let staging = null
-          let production = null
-          result.forEach(r => {
-            if (r.env === 'testing') testing = Object.assign({}, testing, { [r.name]: r.value })
-            if (r.env === 'staging') staging = Object.assign({}, staging, { [r.name]: r.value })
-            if (r.env === 'production') production = Object.assign({}, production, { [r.name]: r.value })
-          })
-          inventory._project.env = { testing, staging, production }
+        // Tidy up the response
+        result = result.concat(data.Parameters.map(function (param) {
+          let bits = param.Name.split('/')
+          return {
+            app: name, // jic
+            env: bits[2],
+            name: bits[3],
+            value: param.Value,
+          }
+        }))
+        // Check for more data and, if so, recurse
+        /* istanbul ignore if: Sadly no way to easily mock this for testing */
+        if (data.NextToken) {
+          getSomeEnvVars(name, data.NextToken, callback)
         }
-        callback()
+        else callback(null, result)
       }
     })
   }
-  else callback()
+
+  getSomeEnvVars(name, false, function done (err, result) {
+    if (err) callback(err)
+    else {
+      let testing = null
+      let staging = null
+      let production = null
+      if (result.length) {
+        // TODO refactor into a reducer?
+        result.forEach(({ env, name: k, value: v }) => {
+          if (env === 'testing') testing = Object.assign({}, testing, { [k]: v })
+          if (env === 'staging') staging = Object.assign({}, staging, { [k]: v })
+          if (env === 'production') production = Object.assign({}, production, { [k]: v })
+        })
+      }
+
+      let errors = []
+      inventory._project.env.aws = mergeEnvVars({
+        env: 'Application',
+        source: inventory._project.env.plugins,
+        target: { testing, staging, production },
+        errors,
+      })
+      if (errors.length) {
+        callback(Error(errors[0]))
+        return
+      }
+      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
   }
 

package/src/lib/asap-src.js

@@ -17,7 +17,7 @@ module.exports = function asapSrc () {
   try {
     return require.resolve('@architect/asap')
   }
-  catch (err) { /* Swallow */ }
-
-  throw Error('Cannot find ASAP module!')
+  catch (err) {
+    throw Error('Cannot find ASAP module!')
+  }
 }

package/src/lib/error-fmt.js

@@ -1,26 +1,18 @@
-let { basename } = require('path')
-
 /**
  * Common error formatter
  *
  * @param params {object}
  * @param params.type {string} - Inventory error type: `manifest`, `validation`, or `configuration`
  * @param params.errors {array} - Array of one or more errors to output
- * @param params.meta {string} - Appends optional info to primary error message
  * @param params.inventory {object} - Inventory object
  *
  * @returns Formatted Error + appended ARC_ERRORS property
  */
 module.exports = function format (params) {
-  let { type, errors, meta, inventory } = params
-  if (!meta && type === 'validation') {
-    meta = inventory._project.manifest
-      ? ` in ${basename(inventory._project.manifest)}`
-      : ''
-  }
+  let { type, errors } = params
   let output = errors.map(err => `- ${err}`).join('\n')
   let errType = type[0].toUpperCase() + type.substr(1)
-  let err = Error(`${errType} error${errors.length > 1 ? 's' : ''}${meta ? meta : ''}:\n${output}`)
+  let err = Error(`${errType} error${errors.length > 1 ? 's' : ''}:\n${output}`)
   err.ARC_ERRORS = { type, errors }
   return err
 }

package/src/lib/get-lambda-dirs.js

@@ -0,0 +1,37 @@
+let { join } = require('path')
+
+/**
+ * Get the src (and build) dirs for a Lambda
+ * - Arc Lambdas: pass a name + pragma || relative file path
+ * - Plugin Lambdas: pass a relative file path || absolute file path
+ */
+function getLambdaDirs (params, options) {
+  let { cwd, item, projSrc, projBuild, type: pragma } = params
+  let { name, plugin, customSrc } = options
+  let lambdaDirs = {}
+
+  if (plugin) {
+    let src = normalizeSrc(cwd, item.src)
+    lambdaDirs.src = src
+    if (projBuild) {
+      lambdaDirs.build = src.replace(src, projBuild)
+    }
+  }
+  else {
+    let root = customSrc ? cwd : projSrc
+    let path = customSrc || join(pragma, name)
+    lambdaDirs.src = join(root, path)
+    if (projBuild) {
+      lambdaDirs.build = join(projBuild, path)
+    }
+  }
+  return lambdaDirs
+}
+
+function normalizeSrc (cwd, dir) {
+  if (!dir.startsWith(cwd)) return join(cwd, dir)
+  return dir
+}
+
+getLambdaDirs.normalizeSrc = normalizeSrc
+module.exports = getLambdaDirs

package/src/lib/index.js

@@ -0,0 +1,28 @@
+let asapSrc = require('./asap-src')
+let errorFmt = require('./error-fmt')
+let getLambdaDirs = require('./get-lambda-dirs')
+let is = require('./is')
+let mergeEnvVars = require('./merge-env-vars')
+let pragmas = require('./pragmas')
+
+/**
+ * Why take up a whole fs block when smol libs can just live here?
+ */
+
+// For setting `lambda.build`, compiled + transpiled are effectively the same
+let compiledRuntimes = [ 'compiled', 'transpiled' ]
+
+// `any` must come last for Sandbox route sorting purposes
+let httpMethods = [ 'get', 'post', 'put', 'patch', 'delete', 'options', 'head', 'any' ]
+
+module.exports = {
+  asapSrc,
+  compiledRuntimes,
+  errorFmt,
+  getLambdaDirs,
+  httpMethods,
+  is,
+  mergeEnvVars,
+  normalizeSrc: getLambdaDirs.normalizeSrc,
+  pragmas,
+}

package/src/lib/is.js

@@ -4,10 +4,12 @@ module.exports = {
   // Types
   array: item => Array.isArray(item),
   bool: item => typeof item === 'boolean',
+  defined: item => typeof item !== 'undefined',
+  fn: item => typeof item === 'function',
+  nullish: item => typeof item === 'undefined' || item === null,
   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/merge-env-vars.js

@@ -0,0 +1,32 @@
+let envs = [ 'testing', 'staging', 'production' ]
+
+module.exports = function mergeEnvVars (params) {
+  let { name, source, target, errors } = params
+  if (source === null) return target
+  if (target === null) return source
+  let probs = []
+
+  // Deep copy to reset any potential refs
+  let merged = JSON.parse(JSON.stringify(target))
+  envs.forEach(env => {
+    if (!source[env]) return
+    Object.keys(source[env]).forEach(k => {
+      if (merged[env]?.[k]) {
+        probs.push(`'${env}' variable '${k}'`)
+      }
+      else {
+        if (!merged[env]) merged[env] = {}
+        merged[env][k] = source[env][k]
+      }
+    })
+  })
+
+  if (probs.length) {
+    let s = probs.length > 1 ? 's' : ''
+    let msg = `${name} env var${s} conflicts with plugin:\n` +
+              `- ${probs.join('\n- ')}`
+    errors.push(msg)
+  }
+
+  return merged
+}

package/src/lib/pragmas.js

@@ -6,8 +6,6 @@ module.exports = {
     'cdn',
     'events',
     'http',
-    'indexes', // -> transitioning to @tables-indexes
-    'macros',
     'plugins',
     'proxy',
     'queues',
@@ -24,10 +22,28 @@ module.exports = {
   lambdas: [
     'events',
     'http',
-    'plugins',
     'queues',
     'scheduled',
     'tables-streams',
     'ws',
   ],
+  // Reserved pragma names that map to internal Inventory properties
+  reserved: [
+    'customLambdas',
+  ],
+  // Retired pragmas no longer in active use
+  retired: [
+    'indexes',
+    'macros',
+    'slack',
+    'streams', // Never fully launched
+    // Static types
+    'css',
+    'html',
+    'js',
+    'json',
+    'jsonapi',
+    'text',
+    'xml',
+  ]
 }

package/src/read/reader.js

@@ -1,7 +1,7 @@
 let parse = require('@architect/parser')
 let { existsSync, readFileSync } = require('fs')
 let { join } = require('path')
-let is = require('../lib/is')
+let { is } = require('../lib')
 let read = p => readFileSync(p).toString()
 
 /**

package/src/validate/config.js

@@ -1,19 +1,25 @@
-let is = require('../lib/is')
-let { lambdas } = require('../lib/pragmas')
+let { is, pragmas } = require('../lib')
+let { lambdas } = 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
+  let {
+    runtime: globalRuntime,
+    memory: globalMemory,
+    timeout: globalTimeout
+  } = inventory.aws
+
+  let customRuntimes = inventory._project?.customRuntimes?.runtimes || []
+  let allRuntimes = runtimeList.concat([ 'deno', ...customRuntimes ])
 
   /**
    * Global config
    */
   // Memory
-  if (is.defined(globalMemory) && invalidMemory(globalMemory)) {
+  if (!is.nullish(globalMemory) && invalidMemory(globalMemory)) {
     errors.push(invalidMemoryMsg(`${globalMemory} MB (@aws)`))
   }
   // Runtime
@@ -23,7 +29,7 @@ module.exports = function configValidator (params, inventory, errors) {
     errors.push(`Invalid project-level runtime: ${globalRuntime}`)
   }
   // Timeout
-  if (is.defined(globalTimeout) && invalidTimeout(globalTimeout)) {
+  if (!is.nullish(globalTimeout) && invalidTimeout(globalTimeout)) {
     errors.push(invalidTimeoutMsg(`${globalTimeout} seconds (@aws)`))
   }
 

package/src/validate/index.js

@@ -21,24 +21,16 @@ module.exports = function finalValidation (params, inventory) {
   // TODO add deeper policy validation here
 
   if (errors.length) {
-    return errorFmt({
-      type: 'configuration',
-      errors,
-      inventory,
-    })
+    return errorFmt({ type: 'configuration', errors })
   }
 
   /**
    * Deal with project validation errors
    */
-  // Ensure @tables children (@tables-streams, @indexes) have parent tables present
+  // Ensure @tables children (@tables-streams, @tables-indexes) have parent tables present
   tablesChildren(inventory, errors)
 
   if (errors.length) {
-    return errorFmt({
-      type: 'validation',
-      errors,
-      inventory,
-    })
+    return errorFmt({ type: 'validation', errors })
   }
 }

package/src/validate/layers.js

@@ -1,6 +1,6 @@
 let { sep } = require('path')
-let { lambdas } = require('../lib/pragmas')
-let is = require('../lib/is')
+let { is, pragmas } = require('../lib')
+let { lambdas } = pragmas
 let plural = arr => arr.length > 1 ? 's' : ''
 
 /**

package/src/validate/tables-children.js

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

package/src/config/pragmas/indexes.js

@@ -1,19 +0,0 @@
-let validate = require('./validate')
-let { getIndexes } = require('./tables-indexes')
-
-module.exports = function configureIndexes ({ arc, errors }) {
-  if (!arc.indexes || !arc.indexes.length) return null
-  if (arc.indexes && !arc.tables) {
-    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 indexes = getIndexes(arc, 'indexes', errors)
-  validate.indexes(indexes, '@indexes', errors)
-
-  return indexes
-}

package/src/config/pragmas/macros.js

@@ -1,5 +0,0 @@
-module.exports = function configureMacros ({ arc }) {
-  if (!arc.macros || !arc.macros.length) return null
-
-  return arc.macros
-}

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

@@ -1,25 +0,0 @@
-let { getLambdaName } = require('@architect/utils')
-
-module.exports = function populatePlugins ({ item: pluginName, cwd, inventory, errors }) {
-  if (inventory._project.plugins[pluginName]) {
-    let pluginModule = inventory._project.plugins[pluginName]
-    if (pluginModule.functions || pluginModule.pluginFunctions) {
-      let funk = pluginModule.functions || pluginModule.pluginFunctions
-      let lambdas = funk({
-        arc: inventory._project.arc,
-        inventory: { inv: inventory }
-      }).map(f => {
-        // strip leading `src/` from the path to the plugin function relative to project root
-        let pathToCode = f.src.replace(cwd, '').replace(/^\.?\/?\\?/, '').replace(/^src\/?\\?/, '')
-        let name = getLambdaName(pathToCode)
-        f.name = name
-        return f
-      })
-      if (lambdas.length) {
-        return lambdas
-      }
-    }
-    return null
-  }
-  errors.push(`Invalid @plugins item: ${pluginName}`)
-}

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

@@ -1,19 +0,0 @@
-let { join } = require('path')
-let is = require('../../../lib/is')
-
-module.exports = function populateWebSockets ({ item, dir, cwd, errors }) {
-  if (is.string(item)) {
-    let name = item
-    let route = name // Same as name, just what AWS calls it
-    let src = join(cwd, dir, name)
-    return { name, route, src }
-  }
-  else if (is.object(item)) {
-    let name = Object.keys(item)[0]
-    let route = name
-    // Add back src switch on presence of item[name].src when WS gets more options
-    let src = join(cwd, item[name].src)
-    return { name, route, src }
-  }
-  errors.push(`Invalid @ws item: ${item}`)
-}

package/src/config/project/plugins.js

@@ -1,31 +0,0 @@
-let { join } = require('path')
-let { existsSync } = require('fs')
-
-module.exports = function getPluginModules (project, errors) {
-  let arc = project.arc
-  if (!arc.plugins || !arc.plugins.length) return null
-  let plugins = {}
-  let cwd = project.src
-  for (let name of arc.plugins) {
-    let pluginPath = null
-    let localPath = join(cwd, 'src', 'plugins', `${name}.js`)
-    let localPath1 = join(cwd, 'src', 'plugins', name)
-    let modulePath = join(cwd, 'node_modules', name)
-    let modulePath1 = join(cwd, 'node_modules', `@${name}`)
-    if (existsSync(localPath)) pluginPath = localPath
-    else if (existsSync(localPath1)) pluginPath = localPath1
-    else if (existsSync(modulePath)) pluginPath = modulePath
-    else if (existsSync(modulePath1)) pluginPath = modulePath1
-    if (pluginPath) {
-      try {
-        // eslint-disable-next-line
-        plugins[name] = require(pluginPath)
-      }
-      catch (err) {
-        errors.push(`Unable to load plugin '${name}': ${err.message.split('\n')[0]}`)
-      }
-    }
-    else errors.push(`Cannot find plugin '${name}'! Are you sure you have installed or created it correctly?`)
-  }
-  return plugins
-}

package/src/lib/http-methods.js

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