@architect/inventory 2.2.0-RC.0 → 3.0.0-RC.0

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()
 
 /**

package/src/validate/config.js

@@ -1,19 +1,25 @@
-let is = require('../lib/is')
-let { lambdas } = require('../lib/pragmas')
+let { is, pragmas } = require('../lib')
+let { lambdas } = pragmas
 let { aliases, runtimeList } = require('lambda-runtimes')
-let allRuntimes = runtimeList.concat([ 'deno' ])
 
 /**
  * Configuration validator
  */
 module.exports = function configValidator (params, inventory, errors) {
-  let { runtime: globalRuntime, memory: globalMemory, timeout: globalTimeout } = inventory.aws
+  let {
+    runtime: globalRuntime,
+    memory: globalMemory,
+    timeout: globalTimeout
+  } = inventory.aws
+
+  let customRuntimes = inventory._project?.customRuntimes?.runtimes || []
+  let allRuntimes = runtimeList.concat([ 'deno', ...customRuntimes ])
 
   /**
    * Global config
    */
   // Memory
-  if (is.defined(globalMemory) && invalidMemory(globalMemory)) {
+  if (!is.nullish(globalMemory) && invalidMemory(globalMemory)) {
     errors.push(invalidMemoryMsg(`${globalMemory} MB (@aws)`))
   }
   // Runtime
@@ -23,7 +29,7 @@ module.exports = function configValidator (params, inventory, errors) {
     errors.push(`Invalid project-level runtime: ${globalRuntime}`)
   }
   // Timeout
-  if (is.defined(globalTimeout) && invalidTimeout(globalTimeout)) {
+  if (!is.nullish(globalTimeout) && invalidTimeout(globalTimeout)) {
     errors.push(invalidTimeoutMsg(`${globalTimeout} seconds (@aws)`))
   }
 

package/src/validate/index.js

@@ -21,24 +21,16 @@ module.exports = function finalValidation (params, inventory) {
   // TODO add deeper policy validation here
 
   if (errors.length) {
-    return errorFmt({
-      type: 'configuration',
-      errors,
-      inventory,
-    })
+    return errorFmt({ type: 'configuration', errors })
   }
 
   /**
    * Deal with project validation errors
    */
-  // Ensure @tables children (@tables-streams, @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,
-      inventory,
-    })
+    return errorFmt({ type: 'validation', errors })
   }
 }

package/src/validate/layers.js

@@ -1,6 +1,6 @@
 let { sep } = require('path')
-let { lambdas } = require('../lib/pragmas')
-let is = require('../lib/is')
+let { is, pragmas } = require('../lib')
+let { lambdas } = pragmas
 let plural = arr => arr.length > 1 ? 's' : ''
 
 /**

package/src/validate/tables-children.js

@@ -1,19 +1,19 @@
 /**
- * Ensure @tables children (@tables-streams, @indexes) have parent tables present
+ * Ensure @tables children (@tables-streams, @tables-indexes) have parent tables present
  * - If not, configuration is invalid
  */
 module.exports = function validateTablesChildren (inventory, errors) {
-  let { indexes, 'tables-streams': tablesStreams, tables } = inventory
+  let { 'tables-indexes': indexes, 'tables-streams': streams, tables } = inventory
 
   function check (table, type) {
     if (!tables.some(t => t.name === table)) {
       errors.push(`@${type} ${table} missing corresponding table`)
     }
   }
-  if (tablesStreams) {
-    tablesStreams.forEach(stream => check(stream.table, 'tables-streams'))
+  if (streams) {
+    streams.forEach(stream => check(stream.table, 'tables-streams'))
   }
   if (indexes) {
-    indexes.forEach(index => check(index.name, 'indexes'))
+    indexes.forEach(index => check(index.name, 'tables-indexes'))
   }
 }

package/src/config/pragmas/indexes.js

@@ -1,19 +0,0 @@
-let validate = require('./validate')
-let { getIndexes } = require('./tables-indexes')
-
-module.exports = function configureIndexes ({ arc, errors }) {
-  if (!arc.indexes || !arc.indexes.length) return null
-  if (arc.indexes && !arc.tables) {
-    errors.push(`Specifying @indexes requires specifying corresponding @tables`)
-    return null
-  }
-  if (arc['tables-indexes']?.length && arc.indexes?.length) {
-    errors.push(`Either @tables-indexes or @indexes can be specified, but not both`)
-    return null
-  }
-
-  let indexes = getIndexes(arc, 'indexes', errors)
-  validate.indexes(indexes, '@indexes', errors)
-
-  return indexes
-}

package/src/config/pragmas/macros.js

@@ -1,5 +0,0 @@
-module.exports = function configureMacros ({ arc }) {
-  if (!arc.macros || !arc.macros.length) return null
-
-  return arc.macros
-}

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

@@ -1,25 +0,0 @@
-let { getLambdaName } = require('@architect/utils')
-
-module.exports = function populatePlugins ({ item: pluginName, cwd, inventory, errors }) {
-  if (inventory._project.plugins[pluginName]) {
-    let pluginModule = inventory._project.plugins[pluginName]
-    if (pluginModule.functions || pluginModule.pluginFunctions) {
-      let funk = pluginModule.functions || pluginModule.pluginFunctions
-      let lambdas = funk({
-        arc: inventory._project.arc,
-        inventory: { inv: inventory }
-      }).map(f => {
-        // strip leading `src/` from the path to the plugin function relative to project root
-        let pathToCode = f.src.replace(cwd, '').replace(/^\.?\/?\\?/, '').replace(/^src\/?\\?/, '')
-        let name = getLambdaName(pathToCode)
-        f.name = name
-        return f
-      })
-      if (lambdas.length) {
-        return lambdas
-      }
-    }
-    return null
-  }
-  errors.push(`Invalid @plugins item: ${pluginName}`)
-}

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

@@ -1,19 +0,0 @@
-let { join } = require('path')
-let is = require('../../../lib/is')
-
-module.exports = function populateWebSockets ({ item, dir, cwd, errors }) {
-  if (is.string(item)) {
-    let name = item
-    let route = name // Same as name, just what AWS calls it
-    let src = join(cwd, dir, name)
-    return { name, route, src }
-  }
-  else if (is.object(item)) {
-    let name = Object.keys(item)[0]
-    let route = name
-    // Add back src switch on presence of item[name].src when WS gets more options
-    let src = join(cwd, item[name].src)
-    return { name, route, src }
-  }
-  errors.push(`Invalid @ws item: ${item}`)
-}

package/src/config/project/plugins.js

@@ -1,31 +0,0 @@
-let { join } = require('path')
-let { existsSync } = require('fs')
-
-module.exports = function getPluginModules (project, errors) {
-  let arc = project.arc
-  if (!arc.plugins || !arc.plugins.length) return null
-  let plugins = {}
-  let cwd = project.src
-  for (let name of arc.plugins) {
-    let pluginPath = null
-    let localPath = join(cwd, 'src', 'plugins', `${name}.js`)
-    let localPath1 = join(cwd, 'src', 'plugins', name)
-    let modulePath = join(cwd, 'node_modules', name)
-    let modulePath1 = join(cwd, 'node_modules', `@${name}`)
-    if (existsSync(localPath)) pluginPath = localPath
-    else if (existsSync(localPath1)) pluginPath = localPath1
-    else if (existsSync(modulePath)) pluginPath = modulePath
-    else if (existsSync(modulePath1)) pluginPath = modulePath1
-    if (pluginPath) {
-      try {
-        // eslint-disable-next-line
-        plugins[name] = require(pluginPath)
-      }
-      catch (err) {
-        errors.push(`Unable to load plugin '${name}': ${err.message.split('\n')[0]}`)
-      }
-    }
-    else errors.push(`Cannot find plugin '${name}'! Are you sure you have installed or created it correctly?`)
-  }
-  return plugins
-}