@architect/inventory 2.0.7 → 2.1.2

package/changelog.md

@@ -2,6 +2,53 @@
 
 ---
 
+## [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 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
+
+
+### Changed
+
+- Updated dependencies
+
+---
+
 ## [2.0.7] 2021-09-30
 
 ### Added

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@architect/inventory",
-  "version": "2.0.7",
+  "version": "2.1.2",
   "description": "Architect project resource enumeration utility",
   "main": "src/index.js",
   "scripts": {
@@ -20,17 +20,18 @@
   },
   "license": "Apache-2.0",
   "dependencies": {
-    "@architect/asap": "~4.0.0",
-    "@architect/parser": "~5.0.0",
-    "@architect/utils": "~3.0.2"
+    "@architect/asap": "~4.1.0",
+    "@architect/parser": "~5.0.2",
+    "@architect/utils": "~3.0.4",
+    "lambda-runtimes": "~1.0.1"
   },
   "devDependencies": {
-    "@architect/eslint-config": "~2.0.0",
+    "@architect/eslint-config": "~2.0.1",
     "aws-sdk": "2.880.0",
-    "aws-sdk-mock": "5.1.0",
+    "aws-sdk-mock": "~5.4.0",
     "cross-env": "~7.0.3",
-    "eslint": "~7.32.0",
-    "mock-fs": "~5.0.0",
+    "eslint": "~8.0.1",
+    "mock-fs": "~5.1.1",
     "mock-require": "~3.0.3",
     "nyc": "~15.1.0",
     "tap-spec": "^5.0.0",

package/src/config/pragmas/cdn.js

@@ -8,7 +8,7 @@ module.exports = function configureCDN ({ arc, errors }) {
   let cdn = true
   arc.cdn.forEach(setting => {
     let disabled = [ false, 'disable', 'disabled' ]
-    let isDisabled = disabled.some(s => s === setting)
+    let isDisabled = disabled.includes(setting)
     if (isDisabled) cdn = false
   })
 

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,22 @@
+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
+    }
+  }
+  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/src-dirs.js

@@ -5,7 +5,7 @@ module.exports = function collectSourceDirs ({ pragmas, errors }) {
   let lambdaSrcDirs = []
   let unsortedBySrcDir = {}
   Object.entries(pragmas).forEach(([ pragma, values ]) => {
-    let mayHaveSrcDirs = lambdas.some(p => p === pragma)
+    let mayHaveSrcDirs = lambdas.includes(pragma)
     if (mayHaveSrcDirs && is.array(values)) {
       pragmas[pragma].forEach(item => {
         if (item.arcStaticAssetProxy === true) return // Special exception for ASAP

package/src/config/pragmas/static.js

@@ -19,13 +19,13 @@ module.exports = function configureStatic ({ arc, inventory }) {
 
   if (is.array(arc.static)) {
     let disabled = [ false, 'disable', 'disabled' ]
-    let isDisabled = disabled.some(s => s === arc.static[0])
+    let isDisabled = disabled.includes(arc.static[0])
     if (isDisabled) return false
   }
 
   let settings = Object.entries(_static).map(([ setting ]) => setting)
   for (let setting of staticPragma) {
-    let validSetting = key => settings.some(s => s === key)
+    let validSetting = key => settings.includes(key)
     if (setting.ignore) {
       _static.ignore = setting.ignore
     }

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

@@ -3,7 +3,7 @@ module.exports = function validateAWS (aws, errors) {
 
   if (apigateway) {
     let valid = [ 'http', 'httpv1', 'httpv2', 'rest' ]
-    if (!valid.some(v => v === apigateway)) {
+    if (!valid.includes(apigateway)) {
       errors.push(`API type must be 'http[v1|v2]', or 'rest'`)
     }
   }

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

@@ -5,7 +5,7 @@ module.exports = function validateHTTP (http, errors) {
     unique(http, '@http routes', errors)
 
     let methods = [ 'get', 'post', 'put', 'patch', 'delete', 'options', 'head', 'any' ]
-    let validMethod = str => methods.some(m => m === str.toLowerCase())
+    let validMethod = str => methods.includes(str.toLowerCase())
     let validPath = str => str.match(/^\/[a-zA-Z0-9/\-:._\*]*$/)
     http.forEach(route => {
       let { name, method, path } = route

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,26 +68,22 @@ 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)) {
     return expErr(`rate interval must be 'minute', 'minutes', 'hour', 'hours', 'day', or 'days'`, interval)
   }
   // Interval must be use the singular/plural values above
-  if (!singular.concat(plural).some(i => i === interval)) {
+  if (!singular.concat(plural).includes(interval)) {
     expErr(`rate interval must be 'minute', 'minutes', 'hour', 'hours', 'day', or 'days'`, interval)
   }
   // Value of 1 must use singular interval
-  if (value === 1 && plural.some(i => i === interval)) {
+  if (value === 1 && plural.includes(interval)) {
     expErr(`rate value of 1 must use a singular interval, e.g. 'minute', 'hour', 'day'`, interval)
   }
   // Value >1 must use plural interval
-  if (value > 1 && singular.some(i => i === interval)) {
+  if (value > 1 && singular.includes(interval)) {
     expErr(`rate values greater than 1 must use plural intervals, e.g. 'minutes', 'hours', 'days'`, interval)
   }
 }

package/src/defaults/function-config.js

@@ -5,7 +5,7 @@ module.exports = function createDefaultFunctionConfig () {
   return {
     timeout: 5,
     memory: 1152,
-    runtime: 'nodejs14.x', // TODO add runtime validation
+    runtime: 'nodejs14.x',
     architecture: 'x86_64', // TODO [BREAKING]: default to 'arm64'
     handler: 'index.handler',
     state: 'n/a',

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,3 +1,4 @@
+let config = require('./config')
 let layers = require('./layers')
 let tablesChildren = require('./tables-children')
 let errorFmt = require('../lib/error-fmt')
@@ -11,6 +12,8 @@ module.exports = function finalValidation (params, inventory) {
   /**
    * Deal with vendor configuration 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.some(p => p === 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
-  }
-}