@architect/inventory 3.2.0-RC.0 → 3.2.1

package/changelog.md

@@ -2,17 +2,37 @@
 
 ---
 
+## [3.2.1] 2022-08-10
+
+### Changed
+
+- By default, when a `set.shared|views` plugin sets a `src` path, if it is not present on the filesystem, Inventory falls back to default paths (e.g. `src/shared|views`)
+  - `set.shared|views` plugins now accept a `required` flag to enforce a validation error should a `src` path conflict with the project manifest (or not be found on the filesystem)
+
+
+### Fixed
+
+- Fixed an obscure internal reference passing bug in `set.proxy|shared|static|views` plugins
+
+---
+
 ## [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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@architect/inventory",
-  "version": "3.2.0-RC.0",
+  "version": "3.2.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
     })
@@ -75,27 +75,27 @@ function validate (item, valid, type) {
  */
 function settings (params) {
   let { errors, settings, plugins, inventory, type, valid } = params
+  let newSettings = is.defined(settings) ? JSON.parse(JSON.stringify(settings)) : settings
   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}`
+        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 {
         Object.entries(result).forEach(([ setting, value ]) => {
           if (is.defined(settings[setting]) && is.defined(value)) {
-            pluginSettings[setting] = value
+            newSettings[setting] = value
           }
         })
       }
@@ -103,15 +103,15 @@ function settings (params) {
     if (foundError) return null
 
     // Validation pass
-    let validationErrors = validate(pluginSettings, valid, type)
+    let validationErrors = validate(newSettings, valid, type)
     if (validationErrors.length) {
       errors = errors.push(...validationErrors)
       return null
     }
 
-    return pluginSettings
+    return newSettings
   }
-  return settings
+  return newSettings
 }
 
 module.exports = { resources, settings }

package/src/config/pragmas/shared.js

@@ -14,10 +14,10 @@ module.exports = function configureShared ({ arc, pragmas, inventory, errors })
     shared: []
   }
 
-  let foundSrcSetting = false
+  let foundPluginSrc, foundArcSrc, required = false
   let pluginSrc = populate.settings({
     errors,
-    settings: shared,
+    settings: { ...shared, required: null },
     plugins: inventory.plugins?._methods?.set?.shared,
     inventory,
     type: 'shared',
@@ -27,33 +27,45 @@ module.exports = function configureShared ({ arc, pragmas, inventory, errors })
   // Lambda paths have not yet been reified in Inventory
   if (is.string(pluginSrc?.src)) {
     shared.src = pluginSrc.src
-    foundSrcSetting = true
+    required = pluginSrc.required
+    foundPluginSrc = true
   }
 
   // First pass to get + check shared folder (if any)
   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])) {
+      if (is.array(share) && share[0]?.toLowerCase() === 'src') {
+        if (is.string(share[1])) {
           shared.src = share[1]
-          foundSrcSetting = true
+          foundArcSrc = true
+          if (required) errors.push(`@shared src setting conflicts with plugin`)
           continue
         }
-        if (key === 'src' && !is.string(share[1])) {
-          errors.push(`@shared invalid setting: ${key}`)
-        }
+        else errors.push(`@shared invalid setting: src`)
       }
     }
   }
 
-  if (foundSrcSetting) validate.shared(shared.src, cwd, errors)
-  else shared.src = src
-
+  // Source path selection + validation: manifest always wins; validate plugins differently if required; if not, fall back to `src/shared` (or null)
+  if (foundArcSrc) {
+    validate.shared(shared.src, cwd, errors, true)
+  }
+  else if (foundPluginSrc) {
+    if (!required) {
+      if (!is.exists(shared.src)) shared.src = src
+      if (!is.exists(shared.src)) return null
+    }
+    validate.shared(shared.src, cwd, errors, required)
+  }
+  else if (is.exists(src)) {
+    shared.src = src
+    validate.shared(shared.src, cwd, errors, false)
+  }
   // Exit if configured shared folder doesn't exist
-  if (!is.exists(shared.src)) return null
+  else return null
 
   // Proceeding from here resets all shared config, so make sure it's only if specific shared are specified
+  let foundSrcSetting = foundArcSrc || foundPluginSrc
   let some = arc.shared?.length && !(arc?.shared?.length === 1 && foundSrcSetting)
   if (some) {
     // Reset shared settings

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/_shared.js

@@ -1,13 +1,12 @@
 let { join, resolve, sep } = require('path')
 let { is } = require('../../../lib')
 
-module.exports = function validateShared (src, cwd, errors) {
-  let path = src && src.startsWith(cwd) ? src : resolve(join(cwd, src))
+module.exports = function validateShared (src, cwd, errors, required) {
+  let path = 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}`)
+  if (is.exists(path) && !is.folder(path)) errors.push(`Must be a directory: ${src}`)
+  else if (!is.exists(path) && required) errors.push(`Directory not found: ${src}`)
 
-  let valid = path && path.startsWith(cwd) &&
-              (cwd.split(sep) < path.split(sep))
+  let valid = path?.startsWith(cwd) && (cwd.split(sep) < path.split(sep))
   if (!valid) errors.push(`Directory must be a subfolder of this project: ${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/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

@@ -18,10 +18,10 @@ module.exports = function configureViews ({ arc, pragmas, inventory, errors }) {
     views: []
   }
 
-  let foundSrcSetting = false
+  let foundPluginSrc, foundArcSrc, required = false
   let pluginSrc = populate.settings({
     errors,
-    settings: views,
+    settings: { ...views, required: null },
     plugins: inventory.plugins?._methods?.set?.views,
     inventory,
     type: 'views',
@@ -31,33 +31,45 @@ module.exports = function configureViews ({ arc, pragmas, inventory, errors }) {
   // Lambda paths have not yet been reified in Inventory
   if (is.string(pluginSrc?.src)) {
     views.src = pluginSrc.src
-    foundSrcSetting = true
+    required = pluginSrc.required
+    foundPluginSrc = true
   }
 
   // First pass to get + check views folder (if any)
   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])) {
+      if (is.array(view) && view[0]?.toLowerCase() === 'src') {
+        if (is.string(view[1])) {
           views.src = view[1]
-          foundSrcSetting = true
+          foundArcSrc = true
+          if (required) errors.push(`@views src setting conflicts with plugin`)
           continue
         }
-        if (key === 'src' && !is.string(view[1])) {
-          errors.push(`@shared invalid setting: ${key}`)
-        }
+        else errors.push(`@views invalid setting: src`)
       }
     }
   }
 
-  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
+  // Source path selection + validation: manifest always wins; validate plugins differently if required; if not, fall back to `src/shared` (or null)
+  if (foundArcSrc) {
+    validate.shared(views.src, cwd, errors, true)
+  }
+  else if (foundPluginSrc) {
+    if (!required) {
+      if (!is.exists(views.src)) views.src = src
+      if (!is.exists(views.src)) return null
+    }
+    validate.shared(views.src, cwd, errors, required)
+  }
+  else if (is.exists(src)) {
+    views.src = src
+    validate.shared(views.src, cwd, errors, false)
+  }
+  // Exit if configured shared folder doesn't exist
+  else return null
 
   // Proceeding from here resets all views config, so make sure it's only if specific views are specified
+  let foundSrcSetting = foundArcSrc || foundPluginSrc
   let some = arc.views?.length && !(arc?.views?.length === 1 && foundSrcSetting)
   if (some) {
     // Reset views settings