@architect/inventory 2.2.1 → 3.0.0-RC.3

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

@@ -1,4 +1,4 @@
-let is = require('../../../lib/is')
+let { is } = require('../../../lib')
 
 let patterns = {
   looseName: new RegExp(/^[a-z][a-zA-Z0-9-_]+$/),

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

@@ -1,4 +1,4 @@
-let is = require('../../../lib/is')
+let { is } = require('../../../lib')
 let { regex, size, unique } = require('./_lib')
 
 /**
@@ -10,7 +10,7 @@ let { regex, size, unique } = require('./_lib')
  * See: https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-create-rule-schedule.html
  */
 module.exports = function validateScheduled (scheduled, errors) {
-  if (scheduled.length) {
+  if (scheduled?.length) {
     unique(scheduled, '@scheduled', errors)
 
     scheduled.forEach(schedule => {

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

@@ -1,5 +1,5 @@
 let { join, resolve, sep } = require('path')
-let is = require('../../../lib/is')
+let { is } = require('../../../lib')
 
 module.exports = function validateShared (src, cwd, errors) {
   let path = src && resolve(join(cwd, src))

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

@@ -7,13 +7,11 @@ let { regex, size, unique } = require('./_lib')
  * See: https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.NamingRulesDataTypes.html
  */
 module.exports = function validateTablesStreams (tablesStreams, errors) {
-  if (tablesStreams.length) {
-    unique(tablesStreams, '@tables-streams', errors)
+  unique(tablesStreams, '@tables-streams', errors)
 
-    tablesStreams.forEach(stream => {
-      let { name } = stream
-      size(name, 3, 255, '@tables-streams', errors)
-      regex(name, 'veryLooseName', '@tables-streams', errors)
-    })
-  }
+  tablesStreams.forEach(stream => {
+    let { name } = stream
+    size(name, 3, 255, '@tables-streams', errors)
+    regex(name, 'veryLooseName', '@tables-streams', errors)
+  })
 }

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

@@ -2,13 +2,13 @@ let { regex, size, unique } = require('./_lib')
 let { deepStrictEqual } = require('assert')
 
 /**
- * Validate @tables + @indexes
+ * Validate @tables + @tables-indexes
  *
  * Where possible, attempts to follow DynamoDB validation
  * See: https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.NamingRulesDataTypes.html
  */
 module.exports = function validateTablesAndIndexes (pragma, pragmaName, errors) {
-  if (pragma.length) {
+  if (pragma?.length) {
     pragma.forEach(table => {
       let { name, indexName, partitionKey, sortKey } = table
 

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

@@ -4,12 +4,12 @@ module.exports = {
   aws:            require('./_aws'),
   events:         require('./_events'),
   http:           require('./_http'),
-  indexes:        require('./_tables'), // Same ruleset as @tables (more or less)
   proxy:          require('./_proxy'),
-  tables:         require('./_tables'),
   queues:         require('./_events'), // Same ruleset as @events
   scheduled:      require('./_scheduled'),
   shared:         require('./_shared'), // Also includes @views
+  tables:         require('./_tables'),
+  tablesIndexes:  require('./_tables'), // Same ruleset as @tables (more or less)
   tablesStreams:  require('./_tables-streams'),
   websockets:     require('./_websockets'),
 

package/src/config/pragmas/views.js

@@ -1,6 +1,6 @@
 let { join } = require('path')
 let validate = require('./validate')
-let is = require('../../lib/is')
+let { is } = require('../../lib')
 
 module.exports = function configureViews ({ arc, pragmas, inventory, errors }) {
   if (arc.views && !arc.http) {
@@ -9,46 +9,28 @@ module.exports = function configureViews ({ arc, pragmas, inventory, errors }) {
   }
   if (!arc.http) return null
 
-  let cwd = inventory._project.src
-  let src = join(cwd, 'src', 'views')
+  let { cwd, src: projSrc } = inventory._project
+  let src = join(projSrc, 'views')
   let views = {
     src,
     views: [] // Revert to null later if none are defined
   }
 
-  if (arc.views && arc.views.length) {
-    let foundSrc = false
-
-    // First pass to get + check views folder (if any)
+  // First pass to get + check views folder (if any)
+  let foundSrc = false
+  if (arc?.views?.length) {
     for (let view of arc.views) {
-      let key = view[0].toLowerCase()
-      if (key === 'src' && is.string(view[1])) {
-        views.src = view[1]
-        foundSrc = true
-        validate.shared(views.src, cwd, errors)
-      }
-    }
-
-    // Proceeding from here resets all views config, so make sure it's only if specific views are specified
-    let some = !(arc.views.length === 1 && foundSrc)
-    if (some) {
-      // Reset views settings
-      for (let route of pragmas.http) {
-        route.config.views = false
-      }
-
-      // Set new views settings
-      for (let view of arc.views) {
-        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)
-        if (!route) {
-          return errors.push(`@views ${name} not found in @http routes`)
+      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)
+          continue
+        }
+        if (key === 'src' && !is.string(view[1])) {
+          errors.push(`@shared invalid setting: ${key}`)
         }
-        // Ignore views into ASAP
-        if (!route.arcStaticAssetProxy) route.config.views = true
       }
     }
   }
@@ -56,6 +38,29 @@ module.exports = function configureViews ({ arc, pragmas, inventory, errors }) {
   // 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)
+  if (some) {
+    // Reset views settings
+    for (let route of pragmas.http) {
+      route.config.views = false
+    }
+
+    // Set new views settings
+    for (let view of arc.views) {
+      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)
+      if (!route) {
+        return errors.push(`@views ${name} not found in @http routes`)
+      }
+      // Ignore views into ASAP
+      if (!route.arcStaticAssetProxy) route.config.views = true
+    }
+  }
+
   // lambda.config.views was added by Lambda populator defaults, or added above
   for (let { src, config } of pragmas.http) {
     if (config.views === true && !views.views.includes(src)) {
@@ -63,8 +68,5 @@ module.exports = function configureViews ({ arc, pragmas, inventory, errors }) {
     }
   }
 
-  // De-dupe (in case multiple functions live at the same src path)
-  views.views = [ ...new Set(views.views) ]
-
   return views
 }

package/src/config/pragmas/ws.js

@@ -2,21 +2,23 @@ let populate = require('./populate-lambda')
 let validate = require('./validate')
 
 module.exports = function configureWS ({ arc, inventory, errors }) {
-  if (!arc.ws) return null
+  let wsPlugins = inventory.plugins?._methods?.set?.ws
+  if (!arc.ws && !wsPlugins?.length) return null
 
-  let ws = [ ...arc.ws ]
+  let ws = [ ]
+  if (arc.ws) ws.push(...arc.ws)
 
   // Backfill required routes if not already present
   let defaults = [ 'disconnect', 'default', 'connect' ]
   defaults.forEach(route => {
-    let found = arc.ws.find(item => {
+    let found = arc?.ws?.find(item => {
       if (item === route) return true
       if (item[route]) return true
     })
     if (!found) ws.unshift(route)
   })
 
-  let websockets = populate.ws(ws, inventory, errors)
+  let websockets = populate.ws({ arc, inventory, errors, pragma: ws })
 
   // Forgive and normalize userland use of '$default', '$connect', '$disconnect'
   websockets.forEach(({ name }, i) => {

package/src/config/project/index.js

@@ -1,60 +1,76 @@
+let { join } = require('path')
 let upsert = require('../_upsert')
 let prefs = require('./prefs')
-let is = require('../../lib/is')
 let plugins = require('./plugins')
+let { is, mergeEnvVars } = require('../../lib')
 
 /**
  * Get the project-level configuration, overlaying arc.aws settings (if present)
  */
-module.exports = function getProjectConfig (params, errors) {
-  let { arc, raw, filepath, inventory } = params
-  let project = {
+module.exports = function getProjectConfig (params) {
+  let { arc, errors, raw, filepath, inventory } = params
+  let _project = {
     ...inventory._project,
     arc,
     raw,
   }
 
   if (arc.aws) {
-    project.defaultFunctionConfig = upsert(project.defaultFunctionConfig, arc.aws)
+    _project.defaultFunctionConfig = upsert(_project.defaultFunctionConfig, arc.aws)
   }
 
   if (filepath) {
-    project.manifest = filepath
-    // TODO add manifestCreated once we determine we can get birthtime reliably
+    _project.manifest = filepath
   }
 
-  // require project plugin modules
-  project.plugins = plugins(project, errors)
-
-  // parse local and global arc preferences
+  // Parse local and global project preferences
   let scopes = [ 'global', 'local' ]
   for (let scope of scopes) {
     let p = prefs({ scope, inventory, errors })
     if (p) {
       // Set up the scoped metadata
-      project[`${scope}Preferences`] = p.preferences
-      project[`${scope}PreferencesFile`] = p.preferencesFile
+      _project[`${scope}Preferences`] = p.preferences
+      _project[`${scope}PreferencesFile`] = p.preferencesFile
 
       // Build out the final preferences
       /* istanbul ignore else: jic */
-      if (!project.preferences) project.preferences = {}
+      if (!_project.preferences) _project.preferences = {}
       Object.keys(p.preferences).forEach(pragma => {
         // Ignore the raw data
         if (pragma === '_arc' || pragma === '_raw') return
         // Allow booleans, etc.
         if (!is.object(p.preferences[pragma])) {
-          project.preferences[pragma] = p.preferences[pragma]
+          _project.preferences[pragma] = p.preferences[pragma]
           return
         }
         // Traverse and merge individual settings
         /* istanbul ignore else: jic */
-        if (!project.preferences[pragma]) project.preferences[pragma] = {}
+        if (!_project.preferences[pragma]) _project.preferences[pragma] = {}
         Object.entries(p.preferences[pragma]).forEach(([ setting, value ]) => {
-          project.preferences[pragma][setting] = value
+          _project.preferences[pragma][setting] = value
         })
       })
     }
   }
 
-  return project
+  // Populate local env from preferences
+  if (_project.preferences?.env) {
+    _project.env.local = _project.preferences.env
+  }
+
+  if (inventory.plugins?._methods) {
+    _project.env.plugins = plugins.env(params, _project)
+    _project.env.local = mergeEnvVars({
+      name: 'Local',
+      source: _project.env.plugins,
+      target: _project.env.local,
+      errors,
+    })
+
+    let { build, runtimes } = plugins.runtimes(params, _project)
+    if (build)    _project.build = join(_project.cwd, build)
+    if (runtimes) _project.customRuntimes = runtimes
+  }
+
+  return _project
 }

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

@@ -0,0 +1,33 @@
+let { is } = require('../../../lib')
+
+module.exports = function setEnvPlugins (params, project) {
+  let { errors, inventory } = params
+  let envPlugins = inventory.plugins?._methods?.set?.env
+  if (envPlugins?.length) {
+    let env = {}
+
+    // inventory._project is not yet built, so provide as much as we can to plugins for now
+    let inv = { ...inventory, _project: project }
+    envPlugins.forEach(fn => {
+      let errType = `plugin: ${fn.plugin}, method: set.env`
+      try {
+        let result = fn({ 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)
+        })
+      }
+      catch (err) {
+        errors.push(`Runtime plugin '${fn.plugin}' failed: ${err.message}`)
+      }
+    })
+    return { testing: env, staging: env, production: env }
+  }
+  return inventory._project.env.plugins
+}

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

@@ -0,0 +1,7 @@
+let env = require('./env')
+let runtimes = require('./runtimes')
+
+module.exports = {
+  env,
+  runtimes,
+}

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

@@ -0,0 +1,56 @@
+let { is } = require('../../../lib')
+let { aliases, runtimeList } = require('lambda-runtimes')
+let allRuntimes = runtimeList.concat([ 'deno', ...Object.keys(aliases) ])
+
+module.exports = function setRuntimePlugins (params, project) {
+  let { errors, inventory } = params
+  let runtimePlugins = inventory.plugins?._methods?.set?.runtimes
+  if (runtimePlugins?.length) {
+    let runtimes = {
+      runtimes: [],
+    }
+    // inventory._project is not yet built, so provide as much as we can to plugins for now
+    let inv = { ...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
+        })
+      }
+      catch (err) {
+        errors.push(`Runtime plugin '${fn.plugin}' failed: ${err.message}`)
+      }
+    })
+    return { build, runtimes }
+  }
+  return {}
+}

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

@@ -0,0 +1,73 @@
+// Copyright (c) 2015, Scott Motte
+// All rights reserved.
+
+/* istanbul ignore file */
+/* eslint-disable */
+// node_modules/dotenv/lib/main.js
+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 obj = {};
+  src.toString().split(NEWLINES_MATCH).forEach(function(line, idx) {
+    const keyValueArr = line.match(RE_INI_KEY_VAL);
+    if (keyValueArr != null) {
+      const key = keyValueArr[1];
+      let val = keyValueArr[2] || "";
+      const end = val.length - 1;
+      const isDoubleQuoted = val[0] === '"' && val[end] === '"';
+      const isSingleQuoted = val[0] === "'" && val[end] === "'";
+      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) {
+      log(`did not match key and value when parsing line ${idx + 1}: ${line}`);
+    }
+  });
+  return obj;
+}
+function resolveHome(envPath) {
+  return envPath[0] === "~" ? path.join(os.homedir(), envPath.slice(1)) : envPath;
+}
+function config(options) {
+  let dotenvPath = path.resolve(process.cwd(), ".env");
+  let encoding = "utf8";
+  const debug = Boolean(options && options.debug);
+  if (options) {
+    if (options.path != null) {
+      dotenvPath = resolveHome(options.path);
+    }
+    if (options.encoding != null) {
+      encoding = options.encoding;
+    }
+  }
+  try {
+    const parsed = parse(fs.readFileSync(dotenvPath, { encoding }), { debug });
+    Object.keys(parsed).forEach(function(key) {
+      if (!Object.prototype.hasOwnProperty.call(process.env, key)) {
+        process.env[key] = parsed[key];
+      } else if (debug) {
+        log(`"${key}" is already defined in \`process.env\` and will not be overwritten`);
+      }
+    });
+    return { parsed };
+  } catch (e) {
+    return { error: e };
+  }
+}
+module.exports.config = config;
+module.exports.parse = parse;

package/src/config/project/{prefs.js → prefs/index.js}

@@ -1,17 +1,26 @@
-let read = require('../../read')
-let validate = require('./validate')
-let is = require('../../lib/is')
+let { join } = require('path')
+let { existsSync, readFileSync } = require('fs')
+let read = require('../../../read')
+let validate = require('../validate')
+let { is } = require('../../../lib')
+let { parse } = require('./dotenv')
 let { homedir } = require('os')
 
 module.exports = function getPrefs ({ scope, inventory, errors }) {
   let cwd = scope === 'global'
     ? homedir()
-    : inventory._project.src
+    : inventory._project.cwd
 
-  // Populate preferences
+  let envFilepath = join(cwd, '.env')
+  let hasEnvFile = scope === 'local' && existsSync(envFilepath)
   let prefs = read({ type: 'preferences', cwd, errors })
+
+  if (!prefs.filepath && !hasEnvFile) return null
+
+  let preferences = {}
+
+  // Populate Architect preferences
   if (prefs.filepath) {
-    let preferences = {}
     // Ok, this gets a bit hairy
     // Arc outputs an object of nested arrays
     // Basically, construct a pared-down intermediate prefs obj for consumers
@@ -45,6 +54,7 @@ module.exports = function getPrefs ({ scope, inventory, errors }) {
               if (is.array(val)) preferences.env[e][key] = val.join(' ')
             })
           }
+          else preferences.env[e] = null
         })
       }
       // Turn Sandbox scripts into commands
@@ -58,16 +68,24 @@ module.exports = function getPrefs ({ scope, inventory, errors }) {
     })
 
     validate(preferences, errors)
+  }
 
-    return {
-      preferences: {
-        ...preferences,
-        _arc: prefs.arc,
-        _raw: prefs.raw,
-      },
-      preferencesFile: prefs.filepath
+  // Populate .env (testing environment only, disables other env vars)
+  if (hasEnvFile) {
+    let dotenv = parse(readFileSync(envFilepath))
+    preferences.env = {
+      testing: Object.keys(dotenv).length ? dotenv : null,
+      staging: null,
+      production: null,
     }
   }
 
-  return null
+  return {
+    preferences: {
+      ...preferences,
+      _arc: prefs.arc,
+      _raw: prefs.raw,
+    },
+    preferencesFile: prefs.filepath
+  }
 }

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

@@ -1,4 +1,4 @@
-let is = require('./../../../lib/is')
+let { is } = require('./../../../lib')
 
 module.exports = function validatePreferences (preferences, errors) {
   // Env checks

package/src/defaults/index.js

@@ -1,38 +1,45 @@
+let { join } = require('path')
 let fnConfig = require('./function-config')
-let pragmas = require('../lib/pragmas')
+let { pragmas } = require('../lib')
 
 /**
  * Returns a default stub inventory object
  * - Every possible officially supported value should be present
  */
 module.exports = function inventoryDefaults (params = {}) {
-  let { cwd, region } = params
+  let { cwd = process.cwd(), deployStage = null, region } = params
   // Allow region env var override
-  region = process.env.AWS_REGION || region || 'us-west-2'
+  region = region || process.env.AWS_REGION || 'us-west-2'
   let defaultFunctionConfig = fnConfig()
   return {
     // Meta
     _arc: {
       version: 'Unknown',     // @architect/architect semver (if installed)
       defaultFunctionConfig,  // Architect's default function config
-      pragmas,                // Registry of all + Lambda pragmas
+      pragmas,                // Registry of all, Lambda, reserved, retired pragmas
+      deployStage,            // Deploy stage of the running project (if specified)
     },
     _project: {
       type: 'aws',
-      src: cwd,
+      cwd,                          // Project root dir
+      src: join(cwd, 'src'),        // Default source tree dir
+      build: null,                  // Optional build artifact dir
       manifest: null,               // Root project manifest filename
-      // manifestCreated            // TODO
-      preferences: null,            // Realized preferences obj, resolved from global > local
+      preferences: null,            // Realized preferences obj, resolved from local > global
       localPreferences: null,       // Local preferences obj
       localPreferencesFile: null,   // Local preferences file path
       globalPreferences: null,      // Global preferences obj
       globalPreferencesFile: null,  // Global preferences file path
       defaultFunctionConfig,        // Project-level function config
       rootHandler: null,            // null | configured | arcStaticAssetProxy | proxy
-      plugins: null,                // `require`d plugin modules as a map of plugin name to module
+      env: {                        // Env vars pulled from:
+        local: null,                // Local/global prefs or .env
+        plugins: null,              // Plugins
+        aws: null,                  // SSM
+      },
+      customRuntimes: null,         // Runtime plugins
       arc: [],                      // Raw arc obj
       raw: '',                      // Raw arc string
-      env: null,                    // Env vars pulled from SSM (if enabled)
     },
     // App + vendor config
     app: '',
@@ -52,9 +59,7 @@ module.exports = function inventoryDefaults (params = {}) {
     cdn: null,
     events: null,
     http: null,
-    indexes: null,
-    macros: null,
-    plugins: null, // These are the Lambdas created by plugins, not the plugin modules, which are in _project.plugins
+    plugins: null,
     proxy: null,
     queues: null,
     scheduled: null,
@@ -65,7 +70,9 @@ module.exports = function inventoryDefaults (params = {}) {
     'tables-streams': null,
     views: null,
     ws: null,
-    // Collection of all Lambda paths
+    // Unclassified / non-pragma custom Lambdas created by plugins
+    customLambdas: null,
+    // Collection of all Lambda source paths
     lambdaSrcDirs: null,
     // Lambda lookup by source directory
     lambdasBySrcDir: null,