@architect/inventory 2.1.0 → 2.1.3

package/changelog.md

@@ -2,12 +2,51 @@
 
 ---
 
+## [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
+
+- Added `config.runtimeAlias` property to Lambdas whose `config.runtime` is interpolated by way of latest-runtime aliasing (e.g. `node` or `py`)
+
+
+### Changed
+
+- Internal change: implement [Lambda runtimes module](https://www.npmjs.com/package/lambda-runtimes) instead of maintaining valid runtime list in Inventory
+
+
+### Fixed
+
+- Fixed `@scheduled` parsing in `app.json` + `package.json` > `arc.scheduled`
+
+---
+
 ## [2.1.0] 2021-10-11
 
 ### Added
 
-- Added latest-runtime version pinning
-  - Example: if you always want your app to run the latest Lambda version of Python, instead of specifying `python3.9` (and changing it every time a new version of Python is released), instead simply specify `python` or `py`
+- Added latest-runtime version aliasing
+  - Example: you want your app to always run the latest Lambda version of Python (instead of specifying `python3.9`(and changing it every time a new version of Python is released); now you can specify `python` or `py`
   - Valid shortcuts: Node.js: `node`, `nodejs`, `node.js`; Python: `python`, `py`; Ruby: `ruby`, `rb`; Java: `java`; Go: `go`, `golang`; .NET: `dotnet`, `.net`; and custom runtimes: `custom`
 - Added runtime validation
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@architect/inventory",
-  "version": "2.1.0",
+  "version": "2.1.3",
   "description": "Architect project resource enumeration utility",
   "main": "src/index.js",
   "scripts": {
@@ -22,14 +22,15 @@
   "dependencies": {
     "@architect/asap": "~4.1.0",
     "@architect/parser": "~5.0.2",
-    "@architect/utils": "~3.0.3"
+    "@architect/utils": "~3.0.4",
+    "lambda-runtimes": "~1.0.1"
   },
   "devDependencies": {
     "@architect/eslint-config": "~2.0.1",
     "aws-sdk": "2.880.0",
-    "aws-sdk-mock": "5.4.0",
+    "aws-sdk-mock": "~5.4.0",
     "cross-env": "~7.0.3",
-    "eslint": "~8.0.0",
+    "eslint": "~8.0.1",
     "mock-fs": "~5.1.1",
     "mock-require": "~3.0.3",
     "nyc": "~15.1.0",
@@ -38,5 +39,12 @@
   },
   "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/_upsert.js

@@ -1,5 +1,4 @@
 let is = require('../lib/is')
-let runtimes = require('../lib/runtimes')
 
 /**
  * Overlay / append properties onto an existing config object
@@ -60,9 +59,6 @@ module.exports = function upsertProps (config, newConfig) {
     else if (name === 'policies' && !!(value)) {
       policies = policies.concat(value)
     }
-    else if (name === 'runtime' && !!(value)) {
-      props.runtime = runtimes(value[0])
-    }
     else {
       props[name] = value[0]
     }

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

@@ -33,7 +33,7 @@ let get = {
 module.exports = function populateScheduled ({ item, dir, cwd, errors }) {
   let rate = null
   let cron = null
-  if (is.array(item) && item.length >= 3) {
+  if (is.array(item)) {
     let name = item[0]
 
     // Hacky but it works
@@ -52,9 +52,17 @@ module.exports = function populateScheduled ({ item, dir, cwd, errors }) {
   else if (is.object(item)) {
     let name = Object.keys(item)[0]
 
-    // Handle rate + cron
-    if (item[name].rate) rate = get.rate(item[name].rate.join(' '))
-    if (item[name].cron) cron = get.cron(item[name].cron.join(' '))
+    // Handle rate + cron props
+    if (item[name].rate) {
+      let itemRate = item[name].rate
+      let exp = is.array(itemRate) ? itemRate.join(' ') : itemRate
+      rate = get.rate(exp)
+    }
+    if (item[name].cron) {
+      let itemCron = item[name].cron
+      let exp = is.array(itemCron) ? itemCron.join(' ') : itemCron
+      cron = get.cron(exp)
+    }
 
     let src = item[name].src
       ? join(cwd, item[name].src)

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

@@ -0,0 +1,27 @@
+let is = require('../../../lib/is')
+let { aliases, runtimes, runtimeList } = require('lambda-runtimes')
+
+// Runtime interpolater
+module.exports = function getRuntime (config) {
+  let { runtime } = config
+
+  if (runtimeList.includes(runtime) || runtime === 'deno') {
+    return config
+  }
+
+  if (typeof runtime === 'string') {
+    runtime = runtime.toLowerCase()
+
+    // Runtime is not actually an AWS value, but a shorthand/aliased name
+    if (aliases[runtime]) {
+      let aliased = aliases[runtime]
+      config.runtime = runtimes[aliased][0]
+      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

@@ -1,4 +1,5 @@
 let read = require('../../../read')
+let getRuntime = require('./get-runtime')
 let getHandler = require('./get-handler')
 let upsert = require('../../_upsert')
 let is = require('../../../lib/is')
@@ -58,6 +59,9 @@ function populateLambda (type, pragma, inventory, errors) {
         config = upsert(config, arcConfig.arc)
       }
 
+      // Interpolate runtimes
+      config = getRuntime(config)
+
       // Tidy up any irrelevant params
       if (type !== 'http') {
         delete config.apigateway

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/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/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)

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/lib/runtimes.js

@@ -1,84 +0,0 @@
-// Canonical runtime list: https://docs.aws.amazon.com/lambda/latest/dg/lambda-runtimes.html
-// Array order matters, newest (or most preferable) must always be at the top
-let runtimes = {
-  node: [
-    'nodejs14.x',
-    'nodejs12.x',
-    'nodejs10.x',
-  ],
-  python: [
-    'python3.9',
-    'python3.8',
-    'python3.7',
-    'python3.6',
-    'python2.7',
-  ],
-  ruby: [
-    'ruby2.7',
-    'ruby2.5',
-  ],
-  java: [
-    'java11',
-    'java8.al2',
-    'java8',
-  ],
-  go: [
-    'go1.x',
-  ],
-  dotnet: [
-    'dotnetcore3.1',
-    'dotnetcore2.1',
-  ],
-  custom: [
-    'provided.al2',
-    'provided',
-  ],
-  // Arc specific
-  deno: [
-    'deno'
-  ],
-}
-
-// Human friendly shortcuts
-let nodes = [ 'node', 'nodejs', 'node.js' ]
-let pythons = [ 'python', 'py' ]
-let rubies = [ 'ruby', 'rb' ]
-let javas = [ 'java' ]
-let gos = [ 'go', 'golang' ]
-let dotnets = [ 'dotnet', '.net' ]
-let customs = [ 'custom' ]
-
-// Runtime interpolater
-function getRuntime (name) {
-  if (typeof name === 'string') {
-    name = name.toLowerCase()
-
-    if (nodes.includes(name))             return runtimes.node[0]
-    if (runtimes.node.includes(name))     return name
-
-    if (pythons.includes(name))           return runtimes.python[0]
-    if (runtimes.python.includes(name))   return name
-
-    if (rubies.includes(name))            return runtimes.ruby[0]
-    if (runtimes.ruby.includes(name))     return name
-
-    if (javas.includes(name))             return runtimes.java[0]
-    if (runtimes.java.includes(name))     return name
-
-    if (gos.includes(name))               return runtimes.go[0]
-    if (runtimes.go.includes(name))       return name
-
-    if (dotnets.includes(name))           return runtimes.dotnet[0]
-    if (runtimes.dotnet.includes(name))   return name
-
-    if (customs.includes(name))           return runtimes.custom[0]
-    if (runtimes.custom.includes(name))   return name
-
-    if (runtimes.deno.includes(name))     return name
-
-    return name // Will be validated later
-  }
-}
-
-getRuntime.runtimes = runtimes
-module.exports = getRuntime

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 { runtimes } = require('../lib/runtimes')
-
-/**
- * Runtime validator
- */
-module.exports = function runtimeValidator (params, inventory, errors) {
-
-  let allRuntimes = Object.keys(runtimes).reduce((a, k) => a.concat(runtimes[k]), [])
-  let globalRuntime = inventory.aws?.runtime
-  if (globalRuntime && !allRuntimes.includes(globalRuntime)) {
-    errors.push(`Invalid project-level runtime: ${globalRuntime}`)
-  }
-
-  // Walk the tree of layer configs, starting with @aws
-  Object.keys(inventory).forEach(i => {
-    let item = inventory[i]
-    if (lambdas.includes(i) && item) {
-      item.forEach(entry => {
-        let runtime = entry.config.runtime
-        if (runtime === globalRuntime) return
-        if (!allRuntimes.includes(runtime)) {
-          errors.push(`Invalid runtime: ${runtime} (@${i} ${entry.name})`)
-        }
-      })
-    }
-  })
-}