@architect/inventory 2.1.1 → 2.1.2

package/changelog.md

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@architect/inventory",
-  "version": "2.1.1",
+  "version": "2.1.2",
   "description": "Architect project resource enumeration utility",
   "main": "src/index.js",
   "scripts": {

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