@architect/inventory 2.2.1 → 3.0.0-RC.0

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,13 +1,14 @@
+let { join } = require('path')
 let upsert = require('../_upsert')
 let prefs = require('./prefs')
-let is = require('../../lib/is')
 let plugins = require('./plugins')
+let { is } = 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
+module.exports = function getProjectConfig (params) {
+  let { arc, errors, raw, filepath, inventory } = params
   let project = {
     ...inventory._project,
     arc,
@@ -20,13 +21,9 @@ module.exports = function getProjectConfig (params, errors) {
 
   if (filepath) {
     project.manifest = filepath
-    // TODO add manifestCreated once we determine we can get birthtime reliably
   }
 
-  // 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 })
@@ -56,5 +53,13 @@ module.exports = function getProjectConfig (params, errors) {
     }
   }
 
+  if (inventory.plugins?._methods) {
+    // TODO: project.env = plugins.env(params, project)
+
+    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/index.js

@@ -0,0 +1,5 @@
+let runtimes = require('./runtimes')
+
+module.exports = {
+  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.js

@@ -1,12 +1,12 @@
 let read = require('../../read')
 let validate = require('./validate')
-let is = require('../../lib/is')
+let { is } = require('../../lib')
 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 prefs = read({ type: 'preferences', cwd, errors })

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,14 +1,15 @@
+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(), 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
@@ -19,9 +20,10 @@ module.exports = function inventoryDefaults (params = {}) {
     },
     _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
       localPreferences: null,       // Local preferences obj
       localPreferencesFile: null,   // Local preferences file path
@@ -29,10 +31,10 @@ module.exports = function inventoryDefaults (params = {}) {
       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: null,                    // Env vars pulled from SSM + plugins
+      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 +54,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 +65,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,

package/src/get.js

@@ -1,4 +1,4 @@
-let is = require('./lib/is')
+let { is } = require('./lib')
 
 module.exports = function _get (inventory) {
   function getter (prag, name) {
@@ -38,5 +38,4 @@ module.exports = function _get (inventory) {
 // These refer to other pragmas, and thus may allow multiple same/same-named entities
 let multipleResults = [
   'tables-indexes',
-  'indexes',
 ]

package/src/index.js

@@ -5,7 +5,7 @@ let config = require('./config')
 let getEnv = require('./env')
 let validate = require('./validate')
 let get = require('./get')
-let errorFmt = require('./lib/error-fmt')
+let { errorFmt } = require('./lib')
 
 /**
  * Architect Inventory
@@ -50,10 +50,7 @@ module.exports = function architectInventory (params = {}, callback) {
 
   // Exit early if supplied Arc is fundamentally broken
   if (errors.length) {
-    callback(errorFmt({
-      type: 'manifest',
-      errors,
-    }))
+    callback(errorFmt({ type: 'manifest', errors }))
     return promise
   }
 
@@ -61,27 +58,32 @@ module.exports = function architectInventory (params = {}, callback) {
   let inventory = inventoryDefaults(params)
 
   // Set up project params for config
-  let project = { cwd, arc, raw, filepath, inventory }
+  let project = { arc, cwd, errors, filepath, inventory, raw }
 
   // Populate inventory.arc
   inventory._arc = config._arc(project)
 
+  // @plugins come first, as they register hooks all around the project
+  inventory.plugins = config.pragmas.plugins(project)
+
   // Establish default function config from project + Arc defaults
-  inventory._project = config._project(project, errors)
+  inventory._project = config._project(project)
+
+  // End here if plugins failed
+  if (errors.length) {
+    callback(errorFmt({ type: 'plugin', errors }))
+    return promise
+  }
 
-  // Userland: fill out the pragmas
+  // Userland: fill out the pragmas, starting with @plugins
   inventory = {
     ...inventory,
-    ...config.pragmas(project, errors)
+    ...config.pragmas(project)
   }
 
-  // End here if first-pass pragma validation failed
+  // End here if first-pass validation failed
   if (errors.length) {
-    callback(errorFmt({
-      type: 'validation',
-      errors,
-      inventory,
-    }))
+    callback(errorFmt({ type: 'validation', errors }))
     return promise
   }
 

package/src/lib/error-fmt.js

@@ -1,26 +1,18 @@
-let { basename } = require('path')
-
 /**
  * Common error formatter
  *
  * @param params {object}
  * @param params.type {string} - Inventory error type: `manifest`, `validation`, or `configuration`
  * @param params.errors {array} - Array of one or more errors to output
- * @param params.meta {string} - Appends optional info to primary error message
  * @param params.inventory {object} - Inventory object
  *
  * @returns Formatted Error + appended ARC_ERRORS property
  */
 module.exports = function format (params) {
-  let { type, errors, meta, inventory } = params
-  if (!meta && type === 'validation') {
-    meta = inventory._project.manifest
-      ? ` in ${basename(inventory._project.manifest)}`
-      : ''
-  }
+  let { type, errors } = params
   let output = errors.map(err => `- ${err}`).join('\n')
   let errType = type[0].toUpperCase() + type.substr(1)
-  let err = Error(`${errType} error${errors.length > 1 ? 's' : ''}${meta ? meta : ''}:\n${output}`)
+  let err = Error(`${errType} error${errors.length > 1 ? 's' : ''}:\n${output}`)
   err.ARC_ERRORS = { type, errors }
   return err
 }

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

@@ -0,0 +1,37 @@
+let { join } = require('path')
+
+/**
+ * Get the src (and build) dirs for a Lambda
+ * - Arc Lambdas: pass a name + pragma || relative file path
+ * - Plugin Lambdas: pass a relative file path || absolute file path
+ */
+function getLambdaDirs (params, options) {
+  let { cwd, item, projSrc, projBuild, type: pragma } = params
+  let { name, plugin, customSrc } = options
+  let lambdaDirs = {}
+
+  if (plugin) {
+    let src = normalizeSrc(cwd, item.src)
+    lambdaDirs.src = src
+    if (projBuild) {
+      lambdaDirs.build = src.replace(src, projBuild)
+    }
+  }
+  else {
+    let root = customSrc ? cwd : projSrc
+    let path = customSrc || join(pragma, name)
+    lambdaDirs.src = join(root, path)
+    if (projBuild) {
+      lambdaDirs.build = join(projBuild, path)
+    }
+  }
+  return lambdaDirs
+}
+
+function normalizeSrc (cwd, dir) {
+  if (!dir.startsWith(cwd)) return join(cwd, dir)
+  return dir
+}
+
+getLambdaDirs.normalizeSrc = normalizeSrc
+module.exports = getLambdaDirs

package/src/lib/index.js

@@ -0,0 +1,26 @@
+let asapSrc = require('./asap-src')
+let errorFmt = require('./error-fmt')
+let getLambdaDirs = require('./get-lambda-dirs')
+let is = require('./is')
+let pragmas = require('./pragmas')
+
+/**
+ * Why take up a whole fs block when smol libs can just live here?
+ */
+
+// For setting `lambda.build`, compiled + transpiled are effectively the same
+let compiledRuntimes = [ 'compiled', 'transpiled' ]
+
+// `any` must come last for Sandbox route sorting purposes
+let httpMethods = [ 'get', 'post', 'put', 'patch', 'delete', 'options', 'head', 'any' ]
+
+module.exports = {
+  asapSrc,
+  compiledRuntimes,
+  errorFmt,
+  getLambdaDirs,
+  normalizeSrc: getLambdaDirs.normalizeSrc,
+  httpMethods,
+  is,
+  pragmas,
+}

package/src/lib/is.js

@@ -4,10 +4,12 @@ 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',
-  defined: item => typeof item !== 'undefined' && item !== null,
   // Filesystem
   exists: path => existsSync(path),
   folder: path => existsSync(path) && lstatSync(path).isDirectory(),

package/src/lib/pragmas.js

@@ -6,8 +6,6 @@ module.exports = {
     'cdn',
     'events',
     'http',
-    'indexes', // -> transitioning to @tables-indexes
-    'macros',
     'plugins',
     'proxy',
     'queues',
@@ -24,10 +22,27 @@ module.exports = {
   lambdas: [
     'events',
     'http',
-    'plugins',
     'queues',
     'scheduled',
     'tables-streams',
     'ws',
   ],
+  // Reserved pragma names that map to internal Inventory properties
+  reserved: [
+    'customLambdas',
+  ],
+  // Retired pragmas no longer in active use
+  retired: [
+    'indexes',
+    'macros',
+    'slack',
+    // Static types
+    'css',
+    'html',
+    'js',
+    'json',
+    'jsonapi',
+    'text',
+    'xml',
+  ]
 }

package/src/read/reader.js

@@ -1,7 +1,7 @@
 let parse = require('@architect/parser')
 let { existsSync, readFileSync } = require('fs')
 let { join } = require('path')
-let is = require('../lib/is')
+let { is } = require('../lib')
 let read = p => readFileSync(p).toString()
 
 /**