@architect/inventory 3.2.0-RC.0 → 3.2.0-RC.1

package/changelog.md

@@ -7,12 +7,18 @@
 ### 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

package/package.json

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

package/src/config/pragmas/plugins.js

@@ -4,7 +4,7 @@ let { is, normalizeSrc, pragmas, tidyError, validationPatterns } = require('../.
 let { lambdas } = pragmas
 let nonLambdaSetters = [ 'customLambdas', 'env', 'proxy', 'runtimes', 'shared', 'static', 'views', 'tables', 'tables-indexes' ]
 let setters = [ ...lambdas, ...nonLambdaSetters ]
-let pluginMethods = [ 'deploy', 'sandbox' ] // TODO add more!
+let pluginMethods = [ 'deploy', 'sandbox' ]
 let reservedNames = [ '_methods' ]
 
 module.exports = function getPluginModules ({ arc, inventory, errors }) {
@@ -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,26 +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, i) => {
-          item.plugin = fn.plugin
-          item.type = fn.type
+          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
     })
@@ -53,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
 }
 
@@ -136,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

@@ -14,28 +14,28 @@ function resources (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, i) => {
           item = populateTemplate(template, item)
-          item.plugin = fn.plugin
-          item.type = fn.type
+          item._plugin = fn._plugin
+          item._type = fn._type
           result[i] = item
         })
       }
       else {
         result = populateTemplate(template, result)
-        result.plugin = fn.plugin
-        result.type = fn.type
+        result._plugin = fn._plugin
+        result._type = fn._type
       }
       return result
     })
@@ -84,12 +84,12 @@ function settings (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)) {
-        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}`)
         foundError = true
       }
       else {

package/src/config/pragmas/static.js

@@ -1,5 +1,6 @@
 let populate = require('./populate-other')
 let { asapSrc, is } = require('../../lib')
+let validate = require('./validate')
 
 module.exports = function configureStatic ({ arc, inventory, errors }) {
   let staticSetters = inventory.plugins?._methods?.set?.static
@@ -10,6 +11,7 @@ module.exports = function configureStatic ({ arc, inventory, errors }) {
 
   let staticPragma = arc.static || []
   let _static = {
+    compression: false, // Arc applied default
     fingerprint: null,
     folder: 'public', // Arc applied default
     ignore: null,
@@ -35,16 +37,14 @@ module.exports = function configureStatic ({ arc, inventory, errors }) {
   })
 
   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]
     }
   }
 
@@ -54,5 +54,7 @@ module.exports = function configureStatic ({ arc, inventory, errors }) {
     inventory._project.asapSrc = asapSrc()
   }
 
+  validate.static(_static, errors)
+
   return _static
 }

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/_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/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'),