@architect/inventory 3.1.1 → 3.2.0

package/changelog.md

@@ -2,6 +2,33 @@
 
 ---
 
+## [3.2.0] 2022-07-24
+
+### Added
+
+- Added support for new setter plugin APIs, specifically: `@proxy`, `@shared`, `@static`, `@tables`, `@tables-indexes`, `@views`
+- Added new `@static` setting: `compression`
+
+
+### Changed
+
+- Lambdas defined in the userland Architect project manifest now override conflicting Lambdas returned by plugins (instead of throwing validation errors); fixes #1352
+  - Plugin developers can now use a `required` flag to enforce a validation error should their plugin conflict with userland Lambdas
+- `@tables` and `@tables-indexes` can now accept lower case key types (e.g. `*string` instead of `*String`)
+- `@tables` and `@tables-indexes` can also accept `*` and `**` as a shortcut for string-type primary and sort keys
+- Changed plugin function property tags from `plugin|type` to `_plugin|_type` to indicate internal property namespacing
+- Added `@static` pragma validation
+- Fixed obscure case where `@static` `ignore` setting might only use the first list item
+
+
+### Fixed
+
+- Fixed issue where Lambdas created by plugins that returned arrays did not have their `plugin` and `type` properties set
+- Fixed issue where an absolute path in `@shared|views` `src` would incorrectly resolve
+- Fixed issue where `@views` might incorrectly return a validation error when only HTTP setter plugins are used to define `@http` routes
+
+---
+
 ## [3.1.1] 2022-05-09
 
 ### Changed

package/package.json

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

package/src/config/pragmas/plugins.js

@@ -2,10 +2,10 @@ let { join } = require('path')
 let { existsSync } = require('fs')
 let { is, normalizeSrc, pragmas, tidyError, validationPatterns } = require('../../lib')
 let { lambdas } = pragmas
-let nonLambdaSetters = [ 'customLambdas', 'env', 'runtimes' ]
+let nonLambdaSetters = [ 'customLambdas', 'env', 'proxy', 'runtimes', 'shared', 'static', 'views', 'tables', 'tables-indexes' ]
 let setters = [ ...lambdas, ...nonLambdaSetters ]
-let pluginMethods = [ 'deploy', 'sandbox' ] // TODO add more!
-let reservedNames = [ '_methods', 'events', 'queues', 'static', 'tables' ]
+let pluginMethods = [ 'deploy', 'sandbox' ]
+let reservedNames = [ '_methods' ]
 
 module.exports = function getPluginModules ({ arc, inventory, errors }) {
   if (!arc?.plugins?.length && !arc?.macros?.length) return null
@@ -67,8 +67,8 @@ module.exports = function getPluginModules ({ arc, inventory, errors }) {
                   return
                 }
                 if (!methods.set[setter]) methods.set[setter] = []
-                fn.plugin = name
-                fn.type = type
+                fn._plugin = name
+                fn._type = type
                 methods.set[setter].push(fn)
               }
             })
@@ -83,8 +83,8 @@ module.exports = function getPluginModules ({ arc, inventory, errors }) {
               }
               if (!methods[method]) methods[method] = {}
               if (!methods[method][hook]) methods[method][hook] = []
-              fn.plugin = name
-              fn.type = type
+              fn._plugin = name
+              fn._type = type
               methods[method][hook].push(fn)
             })
           }
@@ -101,14 +101,18 @@ module.exports = function getPluginModules ({ arc, inventory, errors }) {
 }
 
 function getPath (cwd, srcDir, name) {
-  let paths = [
-    join(cwd, 'src', srcDir, `${name}.js`),
-    join(cwd, 'src', srcDir, name),
-    join(cwd, 'node_modules', name),
-    join(cwd, 'node_modules', `@${name}`),
-  ]
-  if (existsSync(paths[0]))      return paths[0]
-  else if (existsSync(paths[1])) return paths[1]
-  else if (existsSync(paths[2])) return paths[2]
-  else if (existsSync(paths[3])) return paths[3]
+  let path1 = join(cwd, 'src', srcDir, `${name}.js`)
+  let path2 = join(cwd, 'src', srcDir, name)
+  let path3 = join(cwd, 'node_modules', name)
+  let path4 = join(cwd, 'node_modules', `@${name}`)
+  /**/ if (existsSync(path1)) return path1
+  else if (existsSync(path2)) return path2
+  else if (existsSync(path3)) return path3
+  else if (existsSync(path4)) return path4
+  try {
+    return require.resolve(name)
+  }
+  catch {
+    return
+  }
 }

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

@@ -25,25 +25,26 @@ function populateLambda (type, params) {
         var result = fn({ arc: invCopy._project.arc, inventory: { inv: invCopy } })
       }
       catch (err) {
-        err.message = `Setter plugin exception: plugin: ${fn.plugin}, method: set.${type}`
+        err.message = `Setter plugin exception: plugin: ${fn._plugin}, method: set.${type}`
                       + `\n` + err.message
         throw err
       }
       if (!result ||
           (!is.object(result) && !is.array(result)) ||
           (is.array(result) && result.some(r => !is.object(r)))) {
-        errors.push(`Setter plugins must return a valid response: plugin: ${fn.plugin}, method: set.${type}`)
+        errors.push(`Setter plugins must return a valid response: plugin: ${fn._plugin}, method: set.${type}`)
         return []
       }
       if (is.array(result)) {
-        result.forEach(item => {
-          item.plugin = fn.plugin
-          item.type = fn.type
+        result.forEach((item, i) => {
+          item._plugin = fn._plugin
+          item._type = fn._type
+          result[i] = item
         })
       }
       else {
-        result.plugin = fn.plugin
-        result.type = fn.type
+        result._plugin = fn._plugin
+        result._type = fn._type
       }
       return result
     })
@@ -52,6 +53,15 @@ function populateLambda (type, params) {
 
   let pragmaLambda = populate(type, pragma || arc[type], inventory, errors) || []
   let aggregate = [ ...pluginLambda, ...pragmaLambda ]
+
+  // Filter plugins, if appropriate: not required, but do conflict with a manifest entry
+  aggregate = aggregate.filter(lambda => {
+    if (lambda._plugin && !lambda.required &&
+        aggregate.some(({ name, _plugin }) => !_plugin && name === lambda.name)) {
+      return false
+    }
+    return true
+  })
   return aggregate.length ? aggregate : null
 }
 
@@ -135,6 +145,12 @@ function populate (type, pragma, inventory, errors, plugin) {
     // Final tidying of any undefined properties
     Object.keys(lambda).forEach(k => !is.defined(lambda[k]) && delete lambda[k])
 
+    // Pass through the plugin tag and required status
+    if (item._plugin) {
+      lambda._plugin = item._plugin
+      if (item.required === true) lambda.required = true
+    }
+
     lambdas.push(lambda)
   }
 

package/src/config/pragmas/populate-other/index.js

@@ -0,0 +1,117 @@
+let { deepFrozenCopy } = require('@architect/utils')
+let { is } = require('../../../lib')
+
+/**
+ * Build out resource pragmas (e.g. `@tables`) via plugins
+ * Returns an array of resources
+ */
+function resources (params) {
+  let { errors, template, plugins, inventory, type, valid } = params
+  if (plugins) {
+    let invCopy = deepFrozenCopy(inventory)
+    let pluginResults = plugins.flatMap(fn => {
+      try {
+        var result = fn({ arc: invCopy._project.arc, inventory: { inv: invCopy } })
+      }
+      catch (err) {
+        err.message = `Setter plugin exception: plugin: ${fn._plugin}, method: set.${type}`
+                      + `\n` + err.message
+        throw err
+      }
+      if (!result ||
+          (!is.object(result) && !is.array(result)) ||
+          (is.array(result) && result.some(r => !is.object(r)))) {
+        errors.push(`Setter plugins must return a valid response: plugin: ${fn._plugin}, method: set.${type}`)
+        return []
+      }
+      if (is.array(result)) {
+        result.forEach((item, i) => {
+          item = populateTemplate(template, item)
+          item._plugin = fn._plugin
+          item._type = fn._type
+          result[i] = item
+        })
+      }
+      else {
+        result = populateTemplate(template, result)
+        result._plugin = fn._plugin
+        result._type = fn._type
+      }
+      return result
+    })
+    // Validation pass
+    let validationErrors = []
+    pluginResults.forEach(item => {
+      let errors = validate(item, valid, type)
+      validationErrors.push(...errors)
+    })
+    if (validationErrors.length) {
+      errors = errors.push(...validationErrors)
+      return []
+    }
+    return pluginResults
+  }
+  return
+}
+
+function populateTemplate (template, item) {
+  let newItem = JSON.parse(JSON.stringify(template))
+  Object.entries(item).forEach(([ setting, value ]) => {
+    if (is.defined(value)) newItem[setting] = value
+  })
+  return newItem
+}
+
+function validate (item, valid, type) {
+  if (!valid) return []
+  return Object.entries(valid).map(([ setting, value ]) => {
+    if (!is[value](item[setting])) return `Invalid plugin-generated @${type} resource: ${setting}: ${item[setting]}`
+  }).filter(Boolean)
+}
+
+/**
+ * Build out settings pragmas (e.g. `@static`) via plugins
+ * Returns an object of settings
+ */
+function settings (params) {
+  let { errors, settings, plugins, inventory, type, valid } = params
+  if (plugins) {
+    let invCopy = deepFrozenCopy(inventory)
+    let pluginSettings = settings
+    let foundError = false
+    plugins.forEach(fn => {
+      try {
+        var result = fn({ arc: invCopy._project.arc, inventory: { inv: invCopy } })
+      }
+      catch (err) {
+        err.message = `Setter plugin exception: plugin: ${fn._plugin}, method: set.${type}`
+                      + `\n` + err.message
+        throw err
+      }
+      if (!result || !is.object(result)) {
+        errors.push(`Setter plugins must return a valid response: plugin: ${fn._plugin}, method: set.${type}`)
+        foundError = true
+      }
+      else {
+        Object.entries(result).forEach(([ setting, value ]) => {
+          if (is.defined(settings[setting]) && is.defined(value)) {
+            pluginSettings[setting] = value
+          }
+        })
+      }
+    })
+    if (foundError) return null
+
+    // Validation pass
+    let validationErrors = validate(pluginSettings, valid, type)
+    if (validationErrors.length) {
+      errors = errors.push(...validationErrors)
+      return null
+    }
+
+    return pluginSettings
+  }
+  return settings
+}
+
+module.exports = { resources, settings }

package/src/config/pragmas/proxy.js

@@ -1,19 +1,43 @@
+let populate = require('./populate-other')
 let validate = require('./validate')
 
-module.exports = function configureProxy ({ arc, errors }) {
-  if (arc.proxy && !arc.http) {
-    errors.push('@proxy requires @http')
+module.exports = function configureProxy ({ arc, inventory, errors }) {
+  let proxySetters = inventory.plugins?._methods?.set?.proxy
+  let httpSetters = inventory.plugins?._methods?.set?.http
+  if ((arc.proxy || proxySetters) &&
+      (!arc.http && !httpSetters)) {
+    errors.push('Specifying @proxy requires specifying @http')
     return null
   }
-  if (!arc.proxy || !arc.http) return null
+  if (!arc.proxy && !proxySetters) return null
 
-  let proxy = {}
-  let envs = [ 'testing', 'staging', 'production' ]
-  envs.forEach(env => {
-    let setting = arc.proxy.find(s => (s[0] && s[0] === env) && s[1])
-    if (!setting) errors.push(`@proxy ${env} environment not found or invalid`)
-    else proxy[env] = setting[1]
+  let proxy = {
+    testing: null,
+    staging: null,
+    production: null,
+  }
+
+  proxy = populate.settings({
+    errors,
+    settings: proxy,
+    plugins: proxySetters,
+    inventory,
+    type: 'proxy',
+    valid: {
+      testing: 'string',
+      staging: 'string',
+      production: 'string',
+    },
   })
+  if (proxy === null) return null
+
+  if (arc?.proxy?.length) {
+    Object.keys(proxy).forEach(env => {
+      let setting = arc.proxy.find(s => (s[0] && s[0] === env) && s[1])
+      if (!setting) errors.push(`@proxy ${env} environment not found or invalid`)
+      else proxy[env] = setting[1]
+    })
+  }
 
   validate.proxy(proxy, errors)
 

package/src/config/pragmas/shared.js

@@ -1,4 +1,5 @@
 let { join } = require('path')
+let populate = require('./populate-other')
 let validate = require('./validate')
 let { is, pragmas } = require('../../lib')
 let lambdas = pragmas.lambdas.concat('customLambdas')
@@ -9,20 +10,34 @@ module.exports = function configureShared ({ arc, pragmas, inventory, errors })
   let { cwd, src: projSrc } = inventory._project
   let src = join(projSrc, 'shared')
   let shared = {
-    src,
-    shared: [] // Revert to null later if none are defined
+    src: null,
+    shared: []
+  }
+
+  let foundSrcSetting = false
+  let pluginSrc = populate.settings({
+    errors,
+    settings: shared,
+    plugins: inventory.plugins?._methods?.set?.shared,
+    inventory,
+    type: 'shared',
+    valid: { src: 'string' },
+  })
+  // Shared setters only support src, and do not support specifying Lambdas
+  // Lambda paths have not yet been reified in Inventory
+  if (is.string(pluginSrc?.src)) {
+    shared.src = pluginSrc.src
+    foundSrcSetting = true
   }
 
   // First pass to get + check shared folder (if any)
-  let foundSrc = false
   if (arc?.shared?.length) {
     for (let share of arc.shared) {
       if (is.array(share)) {
         let key = share[0]?.toLowerCase()
         if (key === 'src' && is.string(share[1])) {
           shared.src = share[1]
-          foundSrc = true
-          validate.shared(shared.src, cwd, errors)
+          foundSrcSetting = true
           continue
         }
         if (key === 'src' && !is.string(share[1])) {
@@ -32,11 +47,14 @@ module.exports = function configureShared ({ arc, pragmas, inventory, errors })
     }
   }
 
+  if (foundSrcSetting) validate.shared(shared.src, cwd, errors)
+  else shared.src = src
+
   // Exit if configured shared folder doesn't exist
   if (!is.exists(shared.src)) return null
 
   // Proceeding from here resets all shared config, so make sure it's only if specific shared are specified
-  let some = arc.shared?.length && !(arc?.shared?.length === 1 && foundSrc)
+  let some = arc.shared?.length && !(arc?.shared?.length === 1 && foundSrcSetting)
   if (some) {
     // Reset shared settings
     for (let pragma of lambdas) {

package/src/config/pragmas/static.js

@@ -1,13 +1,17 @@
+let populate = require('./populate-other')
 let { asapSrc, is } = require('../../lib')
+let validate = require('./validate')
 
-module.exports = function configureStatic ({ arc, inventory }) {
+module.exports = function configureStatic ({ arc, inventory, errors }) {
+  let staticSetters = inventory.plugins?._methods?.set?.static
   let httpSetters = inventory.plugins?._methods?.set?.http
 
   // @static is inferred by @http
-  if (!arc.static && !arc.http && !httpSetters) return null
+  if (!arc.static && !staticSetters && !arc.http && !httpSetters) return null
 
   let staticPragma = arc.static || []
   let _static = {
+    compression: false, // Arc applied default
     fingerprint: null,
     folder: 'public', // Arc applied default
     ignore: null,
@@ -24,17 +28,23 @@ module.exports = function configureStatic ({ arc, inventory }) {
     if (isDisabled) return false
   }
 
+  _static = populate.settings({
+    errors,
+    settings: _static,
+    plugins: staticSetters,
+    inventory,
+    type: 'static',
+  })
+
   let settings = Object.entries(_static).map(([ setting ]) => setting)
+  let validSetting = key => settings.includes(key)
   for (let setting of staticPragma) {
-    let validSetting = key => settings.includes(key)
+    // The ignore setting can come in a couple shapes, so we have to handle those
     if (setting.ignore) {
       _static.ignore = setting.ignore
     }
-    else if (is.array(setting) &&
-             setting.length === 2 &&
-             validSetting(setting[0])) {
-      let isIgnore = setting[0] === 'ignore'
-      _static[setting[0]] = isIgnore ? [ setting[1] ] : setting[1]
+    else if (is.array(setting) && validSetting(setting[0])) {
+      _static[setting[0]] = setting[0] === 'ignore' ? [ ...setting.slice(1) ] : setting[1]
     }
   }
 
@@ -44,5 +54,7 @@ module.exports = function configureStatic ({ arc, inventory }) {
     inventory._project.asapSrc = asapSrc()
   }
 
+  validate.static(_static, errors)
+
   return _static
 }

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

@@ -1,52 +1,72 @@
-let { is } = require('../../lib')
+let populate = require('./populate-other')
+let { is, capitalize } = require('../../lib')
 let validate = require('./validate')
 
-module.exports = function configureTablesIndexes ({ arc, errors }) {
-  if (!arc['tables-indexes'] || !arc['tables-indexes'].length) return null
-  if (arc['tables-indexes'] && !arc.tables) {
+module.exports = function configureTablesIndexes ({ arc, inventory, errors }) {
+  let $indexes = 'tables-indexes' // It's quite long!
+  let indexesSetters = inventory.plugins?._methods?.set?.[$indexes]
+  let tablesSetters = inventory.plugins?._methods?.set?.tables
+  if ((!arc[$indexes] || !arc[$indexes].length) && !indexesSetters) return null
+  if ((arc[$indexes] || indexesSetters) &&
+      (!arc.tables && !tablesSetters)) {
     errors.push(`Specifying @tables-indexes requires specifying corresponding @tables`)
     return null
   }
 
-  let indexes = getIndexes(arc, 'tables-indexes', errors)
-  validate.tablesIndexes(indexes, '@tables-indexes', errors)
+  let indexTemplate = () => ({
+    name: undefined,
+    partitionKey: null,
+    partitionKeyType: null,
+    sortKey: null,
+    sortKeyType: null,
+    indexName: null,
+  })
 
-  return indexes
-}
+  let indexes = []
+  let plugins = populate.resources({
+    errors,
+    template: indexTemplate(),
+    plugins: indexesSetters,
+    inventory,
+    type: 'indexes',
+    valid: { name: 'string' }
+  })
+  if (plugins) indexes.push(...plugins)
 
-let getIndexes = (arc, pragma, errors) => {
-  let isCustomName = key => is.string(key) && key.toLowerCase() === 'name'
-  function error (item) { errors.push(`Invalid @${pragma} item: ${item}`) }
-  return arc[pragma].map(index => {
+  let userland = arc?.[$indexes]?.map(index => {
     if (is.object(index)) {
-      let name = Object.keys(index)[0]
-      let partitionKey = null
-      let partitionKeyType = null
-      let sortKey = null
-      let sortKeyType = null
-      let indexName = null
-      Object.entries(index[name]).forEach(([ key, value ]) => {
+      let i = indexTemplate()
+      i.name = Object.keys(index)[0]
+      Object.entries(index[i.name]).forEach(([ key, value ]) => {
         if (is.sortKey(value)) {
-          sortKey = key
-          sortKeyType = value.replace('**', '')
+          i.sortKey = key
+          i.sortKeyType = value.replace('**', '').toLowerCase()
+          if (!i.sortKeyType) i.sortKeyType = 'string'
         }
         else if (is.primaryKey(value)) {
-          partitionKey = key
-          partitionKeyType = value.replace('*', '')
+          i.partitionKey = key
+          i.partitionKeyType = value.replace('*', '').toLowerCase()
+          if (!i.partitionKeyType) i.partitionKeyType = 'string'
         }
-        else if (isCustomName(key)) {
-          indexName = value
+        else if (key?.toLowerCase() === 'name') {
+          i.indexName = value
         }
       })
-      return {
-        indexName,
-        name,
-        partitionKey,
-        partitionKeyType,
-        sortKey,
-        sortKeyType,
-      }
+      return i
     }
-    error(index)
-  }).filter(Boolean) // Invalid indexes may create undefined entries in the map
+    errors.push(`Invalid @${$indexes} item: ${index}`)
+  }).filter(Boolean) // Invalid indexes or plugins may create undefined entries in the map
+  if (userland) indexes.push(...userland)
+
+  // Normalize key type casing
+  if (indexes.length) indexes = indexes.map(index => {
+    let { sortKeyType, partitionKeyType } = index
+    if (sortKeyType) index.sortKeyType = capitalize(index.sortKeyType)
+    if (partitionKeyType) index.partitionKeyType = capitalize(index.partitionKeyType)
+    return index
+  })
+
+  validate.tablesIndexes(indexes, '@tables-indexes', errors)
+
+  return indexes
 }

package/src/config/pragmas/tables.js

@@ -1,54 +1,70 @@
-let { is } = require('../../lib')
+let populate = require('./populate-other')
+let { is, capitalize } = require('../../lib')
 let validate = require('./validate')
 
-module.exports = function configureTables ({ arc, errors }) {
-  if (!arc.tables || !arc.tables.length) return null
+module.exports = function configureTables ({ arc, inventory, errors }) {
+  let tablesSetters = inventory.plugins?._methods?.set?.tables
+  if ((!arc.tables || !arc.tables.length) && !tablesSetters) return null
 
   let pitrLong = 'PointInTimeRecovery' // It's just so long
+  let tableTemplate = () => ({
+    name: undefined,
+    partitionKey: null,
+    partitionKeyType: null,
+    sortKey: null,
+    sortKeyType: null,
+    stream: null,
+    ttl: null,
+    encrypt: null,
+    pitr: null,
+  })
 
-  let tables = arc.tables.map(table => {
+  let tables = []
+  let plugins = populate.resources({
+    errors,
+    template: tableTemplate(),
+    plugins: tablesSetters,
+    inventory,
+    type: 'tables',
+    valid: { name: 'string' }
+  })
+  if (plugins) tables.push(...plugins)
+
+  let userland = arc?.tables?.map(table => {
     if (is.object(table)) {
-      let name = Object.keys(table)[0]
-      let partitionKey = null
-      let partitionKeyType = null
-      let sortKey = null
-      let sortKeyType = null
-      let stream = null
-      let ttl = null
-      let encrypt = null
-      let pitr = null
-      let pitrOld // Old opt, remove in some future breaking change
-      Object.entries(table[name]).forEach(([ key, value ]) => {
+      let t = tableTemplate()
+      t.name = Object.keys(table)[0]
+      Object.entries(table[t.name]).forEach(([ key, value ]) => {
         if (is.sortKey(value)) {
-          sortKey = key
-          sortKeyType = value.replace('**', '')
+          t.sortKey = key
+          t.sortKeyType = value.replace('**', '').toLowerCase()
+          if (!t.sortKeyType) t.sortKeyType = 'string'
         }
         else if (is.primaryKey(value)) {
-          partitionKey = key
-          partitionKeyType = value.replace('*', '')
+          t.partitionKey = key
+          t.partitionKeyType = value.replace('*', '').toLowerCase()
+          if (!t.partitionKeyType) t.partitionKeyType = 'string'
         }
-        if (key === 'stream')   stream = value
-        if (value === 'TTL')    ttl = key
-        if (key === 'encrypt')  encrypt = value
-        if (key === 'pitr')     pitr = value
-        if (key === pitrLong)   pitrOld = value
+        if (key === 'stream')   t.stream = value
+        if (value === 'TTL')    t.ttl = key
+        if (key === 'encrypt')  t.encrypt = value
+        if (key === 'PITR')     t.pitr = value
+        if (key === 'pitr')     t.pitr = value
+        if (key === pitrLong)   t.PointInTimeRecovery = value
       })
-      let t = {
-        name,
-        partitionKey,
-        partitionKeyType,
-        sortKey,
-        sortKeyType,
-        stream,
-        ttl,
-        encrypt,
-        pitr,
-      }
-      if (pitrOld !== undefined) t.PointInTimeRecovery = pitrOld
       return t
     }
     errors.push(`Invalid @tables item: ${table}`)
-  }).filter(Boolean) // Invalid tables may create undefined entries in the map
+  }).filter(Boolean) // Invalid tables or plugins may create undefined entries in the map
+  if (userland) tables.push(...userland)
+
+  // Normalize key type casing
+  if (tables.length) tables = tables.map(table => {
+    let { sortKeyType, partitionKeyType } = table
+    if (sortKeyType) table.sortKeyType = capitalize(table.sortKeyType)
+    if (partitionKeyType) table.partitionKeyType = capitalize(table.partitionKeyType)
+    return table
+  })
 
   validate.tables(tables, '@tables', errors)
 

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

@@ -22,10 +22,19 @@ function size (value, min, max, pragmaName, errors) {
 
 function unique (lambdas, pragmaName, errors) {
   if (!is.array(lambdas)) throw ReferenceError(`Invalid Lambda array: ${lambdas}`)
-  let names = []
-  if (lambdas.length) lambdas.forEach(({ name }) => {
-    let err = `Duplicate ${pragmaName} item: ${name}`
-    if (names.includes(name) && !errors.includes(err)) errors.push(err)
+  let names = []        // List of names we've looked at
+  let namesErrored = [] // List of any offending names
+  if (lambdas.length) lambdas.forEach(({ name, pragma }) => {
+    if (names.includes(name) && !namesErrored.includes(name)) {
+      let err = `Duplicate ${pragmaName} item: ${name}`
+
+      // If we find a plugin Lambda, that means the filter let it through because it's required by the plugin, so we must now error
+      let foundPlugin = lambdas.find(l => l._plugin && l.name === name)
+      if (foundPlugin) err = `Plugin requires conflicting ${pragmaName} item: ${name}, plugin: ${foundPlugin._plugin}, method: set.${pragma}`
+
+      namesErrored.push(name)
+      errors.push(err)
+    }
     names.push(name)
   })
 }

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

@@ -2,7 +2,7 @@ let { join, resolve, sep } = require('path')
 let { is } = require('../../../lib')
 
 module.exports = function validateShared (src, cwd, errors) {
-  let path = src && resolve(join(cwd, src))
+  let path = src && src.startsWith(cwd) ? src : resolve(join(cwd, src))
 
   if (!is.exists(path)) errors.push(`Directory not found: ${src}`)
   else if (!is.folder(path)) errors.push(`Must be a directory: ${src}`)

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

@@ -0,0 +1,40 @@
+let { is } = require('../../../lib')
+
+module.exports = function validateStatic (_static, errors) {
+  // `folder` validation happens elsewhere
+  let {
+    compression,
+    fingerprint,
+    ignore,
+    prefix,
+    prune,
+    spa,
+    staging,
+    production,
+  } = _static
+
+  if (compression && ![ true, 'br', 'gzip' ].includes(compression)) {
+    errors.push(`Compression must be 'br' or 'gzip'`)
+  }
+  if (fingerprint && ![ true, 'external' ].includes(fingerprint)) {
+    errors.push(`Fingerprint must be true or 'external'`)
+  }
+  if (ignore && (!is.array(ignore) || !ignore.every(i => is.string(i)))) {
+    errors.push(`Ignore must be a list of one or more strings`)
+  }
+  if (prefix && !is.string(prefix)) {
+    errors.push(`Prefix must be a string`)
+  }
+  if (!is.nullish(prune) && !is.bool(prune)) {
+    errors.push(`Prune must be a boolean`)
+  }
+  if (!is.nullish(spa) && !is.bool(spa)) {
+    errors.push(`spa must be a string`)
+  }
+  if (!is.nullish(staging) && !is.string(staging)) {
+    errors.push(`Staging must be a string`)
+  }
+  if (!is.nullish(production) && !is.string(production)) {
+    errors.push(`Production must be a string`)
+  }
+}

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

@@ -10,12 +10,13 @@ let { deepStrictEqual } = require('assert')
 module.exports = function validateTablesAndIndexes (pragma, pragmaName, errors) {
   if (pragma?.length) {
     pragma.forEach(table => {
-      let { name, indexName, partitionKey, sortKey } = table
+      let { name, indexName, partitionKey, partitionKeyType, sortKey } = table
 
       size(name, 3, 255, pragmaName, errors)
       regex(name, 'veryLooseName', pragmaName, errors)
 
       if (!partitionKey) errors.push(`Invalid ${pragmaName} item (partition key required): '${name}'`)
+      if (!partitionKeyType) errors.push(`Invalid ${pragmaName} item (partition key type required): '${name}'`)
       if (indexName) {
         size(indexName, 3, 255, pragmaName, errors)
         regex(indexName, 'veryLooseName', pragmaName, errors)

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

@@ -8,6 +8,7 @@ module.exports = {
   queues:         require('./_events'), // Same ruleset as @events
   scheduled:      require('./_scheduled'),
   shared:         require('./_shared'), // Also includes @views
+  static:         require('./_static'),
   tables:         require('./_tables'),
   tablesIndexes:  require('./_tables'), // Same ruleset as @tables (more or less)
   tablesStreams:  require('./_tables-streams'),

package/src/config/pragmas/views.js

@@ -1,31 +1,47 @@
 let { join } = require('path')
+let populate = require('./populate-other')
 let validate = require('./validate')
 let { is } = require('../../lib')
 
 module.exports = function configureViews ({ arc, pragmas, inventory, errors }) {
-  if (arc.views && !arc.http) {
+  let httpSetters = inventory.plugins?._methods?.set?.http
+  if (arc.views && (!arc.http && !httpSetters)) {
     errors.push('@views requires @http')
     return null
   }
-  if (!arc.http) return null
+  if (!arc.http && !httpSetters) return null
 
   let { cwd, src: projSrc } = inventory._project
   let src = join(projSrc, 'views')
   let views = {
-    src,
-    views: [] // Revert to null later if none are defined
+    src: null,
+    views: []
+  }
+
+  let foundSrcSetting = false
+  let pluginSrc = populate.settings({
+    errors,
+    settings: views,
+    plugins: inventory.plugins?._methods?.set?.views,
+    inventory,
+    type: 'views',
+    valid: { src: 'string' },
+  })
+  // Views setters only support src, and do not support specifying Lambdas
+  // Lambda paths have not yet been reified in Inventory
+  if (is.string(pluginSrc?.src)) {
+    views.src = pluginSrc.src
+    foundSrcSetting = true
   }
 
   // First pass to get + check views folder (if any)
-  let foundSrc = false
   if (arc?.views?.length) {
     for (let view of arc.views) {
       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)
+          foundSrcSetting = true
           continue
         }
         if (key === 'src' && !is.string(view[1])) {
@@ -35,11 +51,14 @@ module.exports = function configureViews ({ arc, pragmas, inventory, errors }) {
     }
   }
 
+  if (foundSrcSetting) validate.shared(views.src, cwd, errors)
+  else views.src = src
+
   // 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)
+  let some = arc.views?.length && !(arc?.views?.length === 1 && foundSrcSetting)
   if (some) {
     // Reset views settings
     for (let route of pragmas.http) {

package/src/lib/index.js

@@ -9,6 +9,9 @@ let pragmas = require('./pragmas')
  * Why take up a whole fs block when smol libs can just live here?
  */
 
+// Capitalize a string (used to normalize table/index key types)
+let capitalize = str => str[0].toUpperCase() + str.substr(1)
+
 // For setting `lambda.build`, compiled + transpiled are effectively the same
 let compiledRuntimes = [ 'compiled', 'transpiled' ]
 
@@ -29,6 +32,7 @@ let tidyError = err => err.message + `\n` + err.stack.split('\n').slice(1).join(
 
 module.exports = {
   asapSrc,
+  capitalize,
   compiledRuntimes,
   errorFmt,
   getLambdaDirs,

package/src/lib/is.js

@@ -1,19 +1,32 @@
 let { existsSync, lstatSync } = require('fs')
 
+// Types
+let array = item => Array.isArray(item)
+let bool = item => typeof item === 'boolean'
+let defined = item => typeof item !== 'undefined'
+let fn = item => typeof item === 'function'
+let nullish = item => typeof item === 'undefined' || item === null
+let number = item => Number.isInteger(item)
+let object = item => typeof item === 'object' && !Array.isArray(item)
+let string = item => typeof item === 'string'
+// Filesystem
+let exists = path => existsSync(path)
+let folder = path => existsSync(path) && lstatSync(path).isDirectory()
+// Pragma-specific stuff
+let primaryKey = val => string(val) && [ '*', '*string', '*number' ].includes(val.toLowerCase())
+let sortKey = val => string(val) && [ '**', '**string', '**number' ].includes(val.toLowerCase())
+
 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',
-  // Filesystem
-  exists: path => existsSync(path),
-  folder: path => existsSync(path) && lstatSync(path).isDirectory(),
-  // Pragma-specific stuff
-  primaryKey: val => typeof val === 'string' && (val.startsWith('*String') || val.startsWith('*Number')),
-  sortKey: val => typeof val === 'string' && (val.startsWith('**String') || val.startsWith('**Number')),
+  array,
+  bool,
+  defined,
+  fn,
+  nullish,
+  number,
+  object,
+  string,
+  exists,
+  folder,
+  primaryKey,
+  sortKey,
 }