@architect/inventory 3.0.0-RC.5 → 3.0.0-RC.9

package/changelog.md

@@ -37,6 +37,7 @@
 - Breaking change: renamed `lambda.handlerFunction` to `lambda.handlerMethod`
 - Breaking change: prioritize `mod.ts|js` handlers in Deno Lambdas
 - Breaking change: removed `toml` support
+- Breaking change: removed `get.macros` method; as `@macros` are now automatically mapped to the Architect plugins, you can simply use `get.plugins` instead
 - Performance improvements to building `inv.shared` + `inv.views`
 - Improved memory footprint of Inventory object by preserving references in `lambdaSrcDirs`, `lambdasBySrcDir`
   - Added `pragma` property to all Lambdas to aid in reference preservation
@@ -44,6 +45,13 @@
 Update CI
 - Stop publishing to the GitHub Package registry
 
+
+### Fixed
+
+- Added file path validation because `aws-sdk` blows up on !ascii paths; fixes #1292, thanks @GustMartins!
+- Fixed env var validation from preference files
+- Fixed error bubbling when reading a preferences file with issues
+
 ---
 
 ## [2.2.1] 2021-11-22

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@architect/inventory",
-  "version": "3.0.0-RC.5",
+  "version": "3.0.0-RC.9",
   "description": "Architect project resource enumeration utility",
   "main": "src/index.js",
   "scripts": {
@@ -23,26 +23,26 @@
   "dependencies": {
     "@architect/asap": "~5.0.0-RC.0",
     "@architect/parser": "~6.0.0-RC.0",
-    "@architect/utils": "~3.0.4",
+    "@architect/utils": "~3.1.0-RC.0",
     "lambda-runtimes": "~1.1.1"
   },
   "devDependencies": {
     "@architect/eslint-config": "~2.0.1",
     "aws-sdk": "2.1001.0",
-    "aws-sdk-mock": "~5.6.0",
+    "aws-sdk-mock": "~5.6.2",
     "cross-env": "~7.0.3",
-    "dotenv": "~14.3.2",
-    "eslint": "~8.7.0",
+    "dotenv": "~15.0.0",
+    "eslint": "~8.8.0",
     "mock-fs": "~5.1.2",
     "mock-require": "~3.0.3",
     "nyc": "~15.1.0",
     "tap-spec": "^5.0.0",
-    "tape": "^5.4.1"
+    "tape": "^5.5.0"
   },
   "eslintConfig": {
     "extends": "@architect/eslint-config"
   },
-  "_nyc": {
+  "nyc": {
     "check-coverage": true,
     "branches": 100,
     "lines": 100,

package/src/config/pragmas/plugins.js

@@ -1,10 +1,11 @@
 let { join } = require('path')
 let { existsSync } = require('fs')
-let { is, normalizeSrc, pragmas } = require('../../lib')
+let { is, normalizeSrc, pragmas, validationPatterns } = require('../../lib')
 let { lambdas } = pragmas
 let nonLambdaSetters = [ 'customLambdas', 'env', 'runtimes' ]
 let setters = [ ...lambdas, ...nonLambdaSetters ]
 let pluginMethods = [ 'deploy', 'sandbox' ] // TODO add more!
+let reservedNames = [ '_methods', 'events', 'queues', 'static', 'tables' ]
 
 module.exports = function getPluginModules ({ arc, inventory, errors }) {
   if (!arc?.plugins?.length && !arc?.macros?.length) return null
@@ -33,8 +34,12 @@ module.exports = function getPluginModules ({ arc, inventory, errors }) {
         : join(cwd, 'src', type + 's', name)
     }
 
-    if (name === '_methods') {
-      errors.push('Plugin name _methods is reserved, please rename your plugin')
+    if (reservedNames.includes(name)) {
+      errors.push(`Plugin name ${name} is reserved, please rename your plugin`)
+      continue
+    }
+    if (!validationPatterns.veryLooseName.test(name)) {
+      errors.push('Plugin names can only contain [a-zA-Z0-9/\\-._]')
       continue
     }
     if (pluginPath) {

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

@@ -1,3 +1,5 @@
+let { sep } = require('path')
+let { deepFrozenCopy } = require('@architect/utils')
 let read = require('../../../read')
 let getLambda = require('./get-lambda')
 let getRuntime = require('./get-runtime')
@@ -9,22 +11,45 @@ let { compiledRuntimes, is } = require('../../../lib')
 /**
  * Build out the Lambda tree from the Arc manifest or a passed pragma, and plugins
  */
-function populateLambda (type, { arc, inventory, errors, pragma }) {
+function populateLambda (type, params) {
+  // Passing a pragma array via params allows special overrides
+  // See: @tables populating inv['tables-streams']
+  let { arc, inventory, errors, pragma } = params
+
   let plugins = inventory.plugins?._methods?.set?.[type]
   let pluginLambda = []
   if (plugins) {
+    let invCopy = deepFrozenCopy(inventory)
     let pluginResults = plugins.flatMap(fn => {
-      let result = fn({ arc, inventory })
-      if (!result) {
+      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 []
       }
-      result.plugin = fn.plugin
-      result.type = fn.type
+      if (is.array(result)) {
+        result.forEach(item => {
+          item.plugin = fn.plugin
+          item.type = fn.type
+        })
+      }
+      else {
+        result.plugin = fn.plugin
+        result.type = fn.type
+      }
       return result
     })
     pluginLambda = populate(type, pluginResults, inventory, errors, true) || []
   }
+
   let pragmaLambda = populate(type, pragma || arc[type], inventory, errors) || []
   let aggregate = [ ...pluginLambda, ...pragmaLambda ]
   return aggregate.length ? aggregate : null
@@ -46,6 +71,11 @@ function populate (type, pragma, inventory, errors, plugin) {
     if (!result) continue
 
     let { name, src, build } = result
+
+    // Normalize paths, especially since plugin authors may not use path.join
+    src = normalize(src)
+    if (build) build = normalize(build)
+
     // Set up fresh config, then overlay plugin config
     let config = defaultProjectConfig()
     config = { ...config, ...getKnownProps(configProps, result.config) }
@@ -82,7 +112,7 @@ function populate (type, pragma, inventory, errors, plugin) {
 
     // Tidy up any irrelevant properties
     if (!compiledRuntimes.includes(config.runtimeConfig?.type)) {
-      // Important: if we don't clean up the build prop, many explosions will explode
+      // Super important! If we don't clean up the build prop, many explosions will explode
       build = undefined
     }
     if (type !== 'http') {
@@ -111,8 +141,10 @@ function populate (type, pragma, inventory, errors, plugin) {
   return lambdas
 }
 
+let normalize = path => path.replace(/[\\\/]/g, sep)
+
 // Lambda setter plugins can technically return anything, so this ensures everything is tidy
-let lambdaProps = [ 'cron', 'method', 'path', 'plugin', 'rate', 'route', 'table' ]
+let lambdaProps = [ 'cron', 'method', 'path', 'plugin', 'rate', 'route', 'table', 'type' ]
 let configProps = [ ...Object.keys(defaultFunctionConfig()), 'fifo', 'views' ]
 let getKnownProps = (knownProps, raw = {}) => {
   let props = knownProps.flatMap(prop => is.defined(raw[prop]) ? [ [ prop, raw[prop] ] ] : [])

package/src/config/pragmas/static.js

@@ -1,8 +1,10 @@
 let { asapSrc, is } = require('../../lib')
 
 module.exports = function configureStatic ({ arc, inventory }) {
+  let httpSetters = inventory.plugins?._methods?.set?.http
+
   // @static is inferred by @http
-  if (!arc.static && !arc.http) return null
+  if (!arc.static && !arc.http && !httpSetters) return null
 
   let staticPragma = arc.static || []
   let _static = {
@@ -37,7 +39,7 @@ module.exports = function configureStatic ({ arc, inventory }) {
   }
 
   // Handy shortcut to ASAP for bare @static
-  if (!arc.http) {
+  if (!arc.http && !httpSetters) {
     inventory._project.rootHandler = 'arcStaticAssetProxy'
     inventory._project.asapSrc = asapSrc()
   }

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

@@ -1,15 +1,8 @@
-let { is } = require('../../../lib')
-
-let patterns = {
-  looseName: new RegExp(/^[a-z][a-zA-Z0-9-_]+$/),
-  strictName: new RegExp(/^[a-z][a-z0-9-]+$/),
-  // DynamoDB, SNS, SQS
-  veryLooseName: new RegExp(/^[a-zA-Z0-9/\-._]*$/),
-}
+let { is, validationPatterns } = require('../../../lib')
 
 function regex (value, pattern, pragmaName, errors) {
-  if (!patterns[pattern]) throw ReferenceError(`Invalid validation pattern specified: ${pattern}`)
-  if (!patterns[pattern].test(value)) errors.push(`Invalid ${pragmaName} item: '${value}' must match ${patterns[pattern]}`)
+  if (!validationPatterns[pattern]) throw ReferenceError(`Invalid validation pattern specified: ${pattern}`)
+  if (!validationPatterns[pattern].test(value)) errors.push(`Invalid ${pragmaName} item: '${value}' must match ${validationPatterns[pattern]}`)
 }
 
 function size (value, min, max, pragmaName, errors) {

package/src/config/pragmas/views.js

@@ -48,8 +48,8 @@ module.exports = function configureViews ({ arc, pragmas, inventory, errors }) {
 
     // Set new views settings
     for (let view of arc.views) {
-      let method = view[0].toLowerCase()
-      let path = view[1]
+      let method = view?.[0]?.toLowerCase()
+      let path = view?.[1]
       if (method === 'src') continue
       let name = `${method} ${path}`
       let route = pragmas.http.find(n => n.name === name)

package/src/config/project/index.js

@@ -68,7 +68,7 @@ module.exports = function getProjectConfig (params) {
     })
 
     let { build, runtimes } = plugins.runtimes(params, _project)
-    if (build)    _project.build = join(_project.cwd, build)
+    if (build) _project.build = join(_project.cwd, build)
     if (runtimes) _project.customRuntimes = runtimes
   }
 

package/src/config/project/plugins/env.js

@@ -1,33 +1,71 @@
-let { is } = require('../../../lib')
+let { deepFrozenCopy } = require('@architect/utils')
+let { is, validationPatterns: valid } = require('../../../lib')
+let envs = [ 'testing', 'staging', 'production' ]
+let str = value => {
+  if (is.object(value) || is.array(value)) return JSON.stringify(value)
+  return String(value)
+}
 
 module.exports = function setEnvPlugins (params, project) {
   let { errors, inventory } = params
   let envPlugins = inventory.plugins?._methods?.set?.env
   if (envPlugins?.length) {
-    let env = {}
+    let env = {
+      testing: null,
+      staging: null,
+      production: null,
+    }
 
     // inventory._project is not yet built, so provide as much as we can to plugins for now
-    let inv = { ...inventory, _project: project }
+    let inv = deepFrozenCopy({ ...inventory, _project: project })
     envPlugins.forEach(fn => {
       let errType = `plugin: ${fn.plugin}, method: set.env`
       try {
-        let result = fn({ inventory: { inv } })
+        let result = fn({ arc: inv._project.arc, inventory: { inv } })
         if (!is.object(result) || !Object.keys(result).length) {
           return errors.push(`Env plugin returned invalid data, must return an Object with one or more keys + values: ${errType}`)
         }
-        Object.entries(result).forEach(([ k, v ]) => {
-          if (env[k]) {
-            return errors.push(`Env var '${k}' already registered: ${errType}`)
-          }
-          if (is.object(v) || is.array(v)) env[k] = JSON.stringify(v)
-          else env[k] = String(v)
-        })
+        // Populate env vars based on environment
+        // If any keys are environment names, disregard all keys except environment names
+        if (Object.keys(result).some(k => envs.includes(k))) {
+          envs.forEach(e => {
+            if (result[e]) Object.entries(result[e]).forEach(([ k, v ]) => {
+              if (!valid.envVar.test(k)) {
+                return errors.push(`Env var '${k}' is invalid, must be [a-zA-Z0-9_]`)
+              }
+              let errored = false, val = str(v)
+              if (!env[e]) env[e] = { [k]: val }
+              else if (env[e][k] && !errored) {
+                errored = true
+                errors.push(`Env var '${k}' already registered: ${errType}`)
+              }
+              else env[e][k] = val
+            })
+          })
+        }
+        // Populate all environments based on env var
+        else {
+          Object.entries(result).forEach(([ k, v ]) => {
+            if (!valid.envVar.test(k)) {
+              return errors.push(`Env var '${k}' is invalid, must be [a-zA-Z0-9_]`)
+            }
+            let errored = false, val = str(v)
+            envs.forEach(e => {
+              if (!env[e]) env[e] = { [k]: val }
+              else if (env[e][k] && !errored) {
+                errored = true
+                errors.push(`Env var '${k}' already registered: ${errType}`)
+              }
+              else env[e][k] = val
+            })
+          })
+        }
       }
       catch (err) {
         errors.push(`Runtime plugin '${fn.plugin}' failed: ${err.message}`)
       }
     })
-    return { testing: env, staging: env, production: env }
+    return env
   }
   return inventory._project.env.plugins
 }

package/src/config/project/plugins/runtimes.js

@@ -1,6 +1,10 @@
-let { is } = require('../../../lib')
 let { aliases, runtimeList } = require('lambda-runtimes')
+let { deepFrozenCopy } = require('@architect/utils')
+let { is, validationPatterns } = require('../../../lib')
+let { looserName } = validationPatterns
 let allRuntimes = runtimeList.concat([ 'deno', ...Object.keys(aliases) ])
+let validTypes = [ 'transpiled', 'compiled', 'interpreted' ]
+let builtTypes = validTypes.filter(t => t !== 'interpreted')
 
 module.exports = function setRuntimePlugins (params, project) {
   let { errors, inventory } = params
@@ -10,45 +14,52 @@ module.exports = function setRuntimePlugins (params, project) {
       runtimes: [],
     }
     // inventory._project is not yet built, so provide as much as we can to plugins for now
-    let inv = { ...inventory, _project: project }
+    let inv = deepFrozenCopy({ ...inventory, _project: project })
     let build
     runtimePlugins.forEach(fn => {
       let errType = `plugin: ${fn.plugin}, method: set.runtimes`
       try {
-        let result = fn({ inventory: { inv } })
-        result = is.array(result) ? result : [ result ]
-        result.forEach(runtime => {
-          // TODO add more validation
-          let { name } = runtime
-          if (!name) {
-            let msg = `Runtime plugin must provide a name: ${errType}`
-            return errors.push(msg)
-          }
-          if (allRuntimes.includes(name)) {
-            let msg = `Runtime name '${name}' is reserved: ${errType}`
-            return errors.push(msg)
-          }
-          if (runtimes[name]) {
-            let msg = `Runtime '${name}' already registered: ${errType}`
-            return errors.push(msg)
-          }
-          if (runtime.build) {
-            if (build && build !== runtime.build) {
-              errors.push(`Runtime '${name}' cannot set a build directory, as it is already configured to: ${build}`)
-            }
-            else if (is.bool(runtime.build) ||
-                !is.string(runtime.build)) {
-              build = 'build'
-            }
-            else build = runtime.build
-          }
-          runtimes.runtimes.push(name)
-          runtimes[name] = runtime
-        })
+        var result = fn({ arc: inv._project.arc, inventory: { inv } })
       }
       catch (err) {
-        errors.push(`Runtime plugin '${fn.plugin}' failed: ${err.message}`)
+        err.message = `Runtime plugin exception: ${errType}`
+                      + `\n` + err.message
+        throw err
       }
+      // Accept one or more results, then loop through them
+      result = is.array(result) ? result : [ result ]
+      result.forEach(runtime => {
+        let { name, type, baseRuntime } = runtime
+        if (!name || !looserName.test(name)) {
+          let msg = `Runtime plugin must provide a valid name: ${errType}`
+          return errors.push(msg)
+        }
+        if (!type || !validTypes.includes(type)) {
+          let msg = `Runtime plugin must provide a valid type: ${errType}`
+          return errors.push(msg)
+        }
+        if (allRuntimes.includes(name)) {
+          let msg = `Runtime name '${name}' is reserved: ${errType}`
+          return errors.push(msg)
+        }
+        if (runtimes[name]) {
+          let msg = `Runtime name '${name}' already registered: ${errType}`
+          return errors.push(msg)
+        }
+        if (builtTypes.includes(type)) {
+          if (build && runtime.build && build !== runtime.build) {
+            return errors.push(`Runtime '${name}' cannot set a build directory, as it is already configured to: ${build}`)
+          }
+          // Adhere to Postel's Law
+          build = 'build'
+          if (is.string(runtime.build)) build = runtime.build
+        }
+        if (type === 'transpiled' && !allRuntimes.includes(baseRuntime)) {
+          return errors.push(`Runtime '${name}' must include a valid baseRuntime property corresponding to a valid Lambda runtime (e.g. 'nodejs14.x')`)
+        }
+        runtimes.runtimes.push(name)
+        runtimes[name] = runtime
+      })
     })
     return { build, runtimes }
   }

package/src/config/project/prefs/dotenv.js

@@ -7,60 +7,30 @@
 var fs = require("fs");
 var path = require("path");
 var os = require("os");
-function log(message) {
-  console.log(`[dotenv][DEBUG] ${message}`);
-}
-var NEWLINE = "\n";
-var RE_INI_KEY_VAL = /^\s*([\w.-]+)\s*=\s*("[^"]*"|'[^']*'|.*?)(\s+#.*)?$/;
-var RE_NEWLINES = /\\n/g;
-var NEWLINES_MATCH = /\r\n|\n|\r/;
-function parse(src, options) {
-  const debug = Boolean(options && options.debug);
-  const multiline = Boolean(options && options.multiline);
+var LINE = /(?:^|^)\s*(?:export\s+)?([\w.-]+)(?:\s*=\s*?|:\s+?)(\s*'(?:\\'|[^'])*'|\s*"(?:\\"|[^"])*"|[^#\r\n]+)?\s*(?:#.*)?(?:$|$)/mg;
+function parse(src) {
   const obj = {};
-  const lines = src.toString().split(NEWLINES_MATCH);
-  for (let idx = 0; idx < lines.length; idx++) {
-    let line = lines[idx];
-    const keyValueArr = line.match(RE_INI_KEY_VAL);
-    if (keyValueArr != null) {
-      const key = keyValueArr[1];
-      let val = keyValueArr[2] || "";
-      let end = val.length - 1;
-      const isDoubleQuoted = val[0] === '"' && val[end] === '"';
-      const isSingleQuoted = val[0] === "'" && val[end] === "'";
-      const isMultilineDoubleQuoted = val[0] === '"' && val[end] !== '"';
-      const isMultilineSingleQuoted = val[0] === "'" && val[end] !== "'";
-      if (multiline && (isMultilineDoubleQuoted || isMultilineSingleQuoted)) {
-        const quoteChar = isMultilineDoubleQuoted ? '"' : "'";
-        val = val.substring(1);
-        while (idx++ < lines.length - 1) {
-          line = lines[idx];
-          end = line.length - 1;
-          if (line[end] === quoteChar) {
-            val += NEWLINE + line.substring(0, end);
-            break;
-          }
-          val += NEWLINE + line;
-        }
-      } else if (isSingleQuoted || isDoubleQuoted) {
-        val = val.substring(1, end);
-        if (isDoubleQuoted) {
-          val = val.replace(RE_NEWLINES, NEWLINE);
-        }
-      } else {
-        val = val.trim();
-      }
-      obj[key] = val;
-    } else if (debug) {
-      const trimmedLine = line.trim();
-      if (trimmedLine.length && trimmedLine[0] !== "#") {
-        log(`Failed to match key and value when parsing line ${idx + 1}: ${line}`);
-      }
+  let lines = src.toString();
+  lines = lines.replace(/\r\n?/mg, "\n");
+  let match;
+  while ((match = LINE.exec(lines)) != null) {
+    const key = match[1];
+    let value = match[2] || "";
+    value = value.trim();
+    const maybeQuote = value[0];
+    value = value.replace(/^(['"])([\s\S]+)\1$/mg, "$2");
+    if (maybeQuote === '"') {
+      value = value.replace(/\\n/g, "\n");
+      value = value.replace(/\\r/g, "\r");
     }
+    obj[key] = value;
   }
   return obj;
 }
-function resolveHome(envPath) {
+function _log(message) {
+  console.log(`[dotenv][DEBUG] ${message}`);
+}
+function _resolveHome(envPath) {
   return envPath[0] === "~" ? path.join(os.homedir(), envPath.slice(1)) : envPath;
 }
 function config(options) {
@@ -68,17 +38,16 @@ function config(options) {
   let encoding = "utf8";
   const debug = Boolean(options && options.debug);
   const override = Boolean(options && options.override);
-  const multiline = Boolean(options && options.multiline);
   if (options) {
     if (options.path != null) {
-      dotenvPath = resolveHome(options.path);
+      dotenvPath = _resolveHome(options.path);
     }
     if (options.encoding != null) {
       encoding = options.encoding;
     }
   }
   try {
-    const parsed = DotenvModule.parse(fs.readFileSync(dotenvPath, { encoding }), { debug, multiline });
+    const parsed = DotenvModule.parse(fs.readFileSync(dotenvPath, { encoding }));
     Object.keys(parsed).forEach(function(key) {
       if (!Object.prototype.hasOwnProperty.call(process.env, key)) {
         process.env[key] = parsed[key];
@@ -88,9 +57,9 @@ function config(options) {
         }
         if (debug) {
           if (override === true) {
-            log(`"${key}" is already defined in \`process.env\` and WAS overwritten`);
+            _log(`"${key}" is already defined in \`process.env\` and WAS overwritten`);
           } else {
-            log(`"${key}" is already defined in \`process.env\` and was NOT overwritten`);
+            _log(`"${key}" is already defined in \`process.env\` and was NOT overwritten`);
           }
         }
       }
@@ -98,7 +67,7 @@ function config(options) {
     return { parsed };
   } catch (e) {
     if (debug) {
-      log(`Failed to load ${dotenvPath} ${e.message}`);
+      _log(`Failed to load ${dotenvPath} ${e.message}`);
     }
     return { error: e };
   }

package/src/config/project/prefs/index.js

@@ -2,7 +2,7 @@ let { join } = require('path')
 let { existsSync, readFileSync } = require('fs')
 let read = require('../../../read')
 let validate = require('../validate')
-let { is } = require('../../../lib')
+let { is, validationPatterns: valid } = require('../../../lib')
 let { parse } = require('./dotenv')
 let { homedir } = require('os')
 
@@ -20,13 +20,11 @@ module.exports = function getPrefs ({ scope, inventory, errors }) {
   let preferences = {}
 
   // Populate Architect preferences
-  if (prefs.filepath) {
+  if (prefs.filepath && prefs.arc) {
     // Ok, this gets a bit hairy
     // Arc outputs an object of nested arrays
     // Basically, construct a pared-down intermediate prefs obj for consumers
     Object.entries(prefs.arc).forEach(([ key, val ]) => {
-      // TODO add additional preferences checks and normalization
-
       /* istanbul ignore else: Parser should get this, but jic */
       if (!preferences[key]) preferences[key] = {}
       /* istanbul ignore else: Parser should only produce arrays, but jic */
@@ -51,6 +49,9 @@ module.exports = function getPrefs ({ scope, inventory, errors }) {
           /* istanbul ignore else: Yet another jic */
           if (preferences.env[e]) {
             Object.entries(preferences.env[e]).forEach(([ key, val ]) => {
+              if (!valid.envVar.test(key)) {
+                errors.push(`Env var '${key}' is invalid, must be [a-zA-Z0-9_]`)
+              }
               if (is.array(val)) preferences.env[e][key] = val.join(' ')
             })
           }

package/src/defaults/index.js

@@ -33,9 +33,9 @@ module.exports = function inventoryDefaults (params = {}) {
       defaultFunctionConfig,        // Project-level function config
       rootHandler: null,            // null | configured | arcStaticAssetProxy | proxy
       env: {                        // Env vars pulled from:
-        local: null,                // Local/global prefs or .env
-        plugins: null,              // Plugins
-        aws: null,                  // SSM
+        local: null,                // - Local/global prefs or .env
+        plugins: null,              // - Plugins
+        aws: null,                  // - SSM
       },
       customRuntimes: null,         // Runtime plugins
       arc: [],                      // Raw arc obj

package/src/lib/get-lambda-dirs.js

@@ -1,4 +1,4 @@
-let { join } = require('path')
+let { isAbsolute, join } = require('path')
 
 /**
  * Get the src (and build) dirs for a Lambda
@@ -29,8 +29,8 @@ function getLambdaDirs (params, options) {
 }
 
 function normalizeSrc (cwd, dir) {
-  if (!dir.startsWith(cwd)) return join(cwd, dir)
-  return dir
+  if (isAbsolute(dir)) return dir
+  return join(cwd, dir)
 }
 
 getLambdaDirs.normalizeSrc = normalizeSrc

package/src/lib/index.js

@@ -15,6 +15,15 @@ let compiledRuntimes = [ 'compiled', 'transpiled' ]
 // `any` must come last for Sandbox route sorting purposes
 let httpMethods = [ 'get', 'post', 'put', 'patch', 'delete', 'options', 'head', 'any' ]
 
+let validationPatterns = {
+  strictName: /^[a-z][a-z0-9-]+$/,
+  looseName: /^[a-z][a-zA-Z0-9-_]+$/,
+  looserName: /^[a-z][a-zA-Z0-9-._]+$/,
+  veryLooseName: /^[a-zA-Z0-9/\-._]*$/,
+  // IEEE 1003.1-2001 does not allow lowercase, so consider this a compromise for the Windows folks in the house
+  envVar: /^[a-zA-Z0-9_]+$/,
+}
+
 module.exports = {
   asapSrc,
   compiledRuntimes,
@@ -25,4 +34,5 @@ module.exports = {
   mergeEnvVars,
   normalizeSrc: getLambdaDirs.normalizeSrc,
   pragmas,
+  validationPatterns,
 }

package/src/validate/index.js

@@ -1,7 +1,8 @@
 let config = require('./config')
 let layers = require('./layers')
 let tablesChildren = require('./tables-children')
-let errorFmt = require('../lib/error-fmt')
+let paths = require('./paths')
+let { errorFmt } = require('../lib')
 
 /**
  * Final inventory validation
@@ -11,26 +12,32 @@ module.exports = function finalValidation (params, inventory) {
 
   /**
    * Deal with vendor configuration errors
+   * - Analyze function configuration
+   * - Ensure layer configuration will work, AWS blows up with awful errors on this
+   * - TODO add deeper policy validation
    */
-  // Analyze function configuration
   config(params, inventory, errors)
-
-  // Ensure layer configuration will work, AWS blows up with awful errors on this
   layers(params, inventory, errors)
-
-  // TODO add deeper policy validation here
-
   if (errors.length) {
     return errorFmt({ type: 'configuration', errors })
   }
 
   /**
    * Deal with project validation errors
+   * - Ensure @tables children (@tables-streams, @tables-indexes) have parent tables present
    */
-  // Ensure @tables children (@tables-streams, @tables-indexes) have parent tables present
   tablesChildren(inventory, errors)
-
   if (errors.length) {
     return errorFmt({ type: 'validation', errors })
   }
+
+  /**
+   * File path validation
+   * - Ensure all file paths are ascii
+   */
+  paths(inventory, errors)
+  if (errors.length) {
+    return errorFmt({ type: 'file path', errors })
+  }
+
 }

package/src/validate/paths.js

@@ -0,0 +1,17 @@
+module.exports = function checkFilePaths (inventory, errors) {
+  let ascii = /^[ -~]+$/
+  let err = str => errors.push(`${str} path must contain only ascii characters`)
+
+  let { _project: proj } = inventory
+  if (!ascii.test(proj.cwd)) return err('Project file')
+  if (!ascii.test(proj.src)) return err('Project source')
+  if (proj.build && !ascii.test(proj.build)) return err('Build')
+
+  let lambdas = inventory.lambdasBySrcDir
+  if (lambdas){
+    Object.values(lambdas).forEach(lambda => {
+      let { name, pragma, src } = lambda
+      if (!ascii.test(src)) err(`@${pragma} ${name} source`)
+    })
+  }
+}