@architect/inventory 2.2.0 → 3.0.0-RC.1

package/src/config/pragmas/populate-lambda/get-handler.js

@@ -1,14 +1,87 @@
-module.exports = function getHandler (config, src, errors) {
-  let { handler, runtime } = config
-  let parts = handler.split('.')
-  if (parts.length !== 2) errors.push(`Invalid handler: ${handler}. Expected {file}.{function}, example: index.handler`)
-  let ext
-  if (runtime.startsWith('nodejs')) ext = 'js'
-  if (runtime.startsWith('python')) ext = 'py'
-  if (runtime.startsWith('ruby'))   ext = 'rb'
-  if (runtime.startsWith('deno'))   ext = 'ts'
-  // TODO add Go, Java, .NET, etc.
-  let handlerFile = `${src}/${parts[0]}${ext ? '.' + ext : ''}`
-  let handlerFunction = parts[1]
-  return { handlerFile, handlerFunction }
+let { join } = require('path')
+let { existsSync, readFileSync } = require('fs')
+
+module.exports = function getHandler ({ config, src, build, errors }) {
+  let { handler, runtime, runtimeConfig } = config
+  let parts = handler.split('.') // Default is 'index.handler'
+  if (parts.length !== 2) {
+    errors.push(`Invalid handler: ${handler}. Expected {file}.{method}, example: index.handler`)
+  }
+
+  let { file, ext, handlerModuleSystem } = getExt({ runtime, src, errors })
+  file = file || parts[0] // Falls back to 'index'
+  ext = ext ? '.' + ext : ''
+  let handlerFile = join(src, `${file}${ext}`)
+  let handlerMethod = parts[1]
+  let customRuntimeType = runtimeConfig?.type
+
+  // Compiled to an interpreted runtime (eg TypeScript)
+  if (customRuntimeType === 'transpiled') {
+    handlerFile = join(build, runtimeConfig?.handlerFile || 'index.js')
+  }
+  // Compiled to a binary
+  else if (customRuntimeType === 'compiled') {
+    handlerFile = join(build, runtimeConfig.handlerFile || 'handler')
+  }
+  // Interpreted
+  else if (customRuntimeType === 'interpreted') {
+    handlerFile = join(src, runtimeConfig.handlerFile || 'index')
+  }
+
+  let handlerConfig = { handlerFile, handlerMethod, handlerModuleSystem }
+  return handlerConfig
+}
+
+let nodeHandlers = [ 'index.js', 'index.mjs', 'index.cjs' ]
+let denoHandlers = [ 'mod.ts', 'mod.js' ]
+  // TODO: these are all prob going away
+  .concat([ 'mod.tsx', 'index.ts', 'index.js', 'index.tsx' ])
+
+function getExt ({ runtime, src, errors }) {
+  try {
+    if (runtime.startsWith('node')) {
+      if (runtime === 'nodejs12.x') {
+        return { ext: 'js', handlerModuleSystem: 'cjs' }
+      }
+      // This presumes Node.js 14.x+ Lambda releases use the same CJS/ESM pattern
+      else {
+        let { file, ext = 'js' } = findHandler(nodeHandlers, src)
+        let handlerModuleSystem = ext === 'mjs' ? 'esm' : 'cjs'
+        let pkgFile = join(src, 'package.json')
+        if (existsSync(pkgFile)) {
+          let pkg = JSON.parse(readFileSync(pkgFile))
+          handlerModuleSystem = getModSystem(pkg)
+        }
+        return { file, ext, handlerModuleSystem }
+      }
+    }
+    if (runtime.startsWith('python')) return { ext: 'py' }
+    if (runtime.startsWith('ruby')) return { ext: 'rb' }
+    if (runtime.startsWith('deno')) {
+      let { file = 'mod', ext = 'ts' } = findHandler(denoHandlers, src)
+      return { file, ext }
+    }
+    return { ext: '' }
+  }
+  catch (err) {
+    errors.push(`Error getting Lambda handler in ${src}: ${err.message}`)
+    return {}
+  }
+}
+
+function findHandler (arr, src){
+  for (let handler of arr) {
+    if (existsSync(join(src, handler))) {
+      let bits = handler.split('.')
+      return { file: bits[0], ext: bits[1] }
+    }
+  }
+  return {}
+}
+
+function getModSystem (pkg) {
+  if (pkg?.type === 'module') return 'esm'
+  else if (pkg?.type === 'commonjs') return 'cjs'
+  else if (pkg?.type) throw Error(`Invalid 'type' field: ${pkg.type}`)
+  return 'cjs'
 }

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

@@ -0,0 +1,23 @@
+// Pragma-specific Lambda constructors
+let getHTTP = require('./_http')
+let getEvents = require('./_events')
+let getCustomLambdas = require('./_custom-lambdas')
+let getScheduled = require('./_scheduled')
+let getWS = require('./_ws')
+let getTablesStreams = require('./_tables-streams')
+
+let cl = 'customLambdas'
+let ts = 'tables-streams'
+
+module.exports = function getLambda (params) {
+  let { type } = params
+  if (type === 'http')      return getHTTP(params)
+  if (type === 'events')    return getEvents(params)
+  if (type === cl)          return getCustomLambdas(params)
+  if (type === 'queues')    return getEvents(params) // Effectively the same as events
+  if (type === 'scheduled') return getScheduled(params)
+  if (type === ts)          return getTablesStreams(params)
+  if (type === 'tables')    return getTablesStreams(params) // Shortcut for creating streams
+  /* istanbul ignore else: clearer to be explicit here */
+  if (type === 'ws')        return getWS(params)
+}

package/src/config/pragmas/populate-lambda/get-runtime.js

@@ -1,16 +1,13 @@
-let is = require('../../../lib/is')
-let { aliases, runtimes, runtimeList } = require('lambda-runtimes')
+let { is } = require('../../../lib')
+let { aliases, runtimes } = require('lambda-runtimes')
 
 // Runtime interpolater
-module.exports = function getRuntime (config) {
+module.exports = function getRuntime ({ config, inventory }) {
   let { runtime } = config
 
-  if (runtimeList.includes(runtime) || runtime === 'deno') {
-    return config
-  }
-
   if (typeof runtime === 'string') {
     runtime = runtime.toLowerCase()
+    let customRuntime = inventory._project?.customRuntimes?.[runtime]
 
     // Runtime is not actually an AWS value, but a shorthand/aliased name
     if (aliases[runtime]) {
@@ -18,6 +15,10 @@ module.exports = function getRuntime (config) {
       config.runtime = runtimes[aliased][0]
       config.runtimeAlias = runtime
     }
+    // Runtime is custom via plugin
+    else if (customRuntime) {
+      config.runtimeConfig = customRuntime
+    }
   }
   else if (is.defined(runtime)) {
     // Someone did something funky like specify a number or bool, so coerce and let it fail validation

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

@@ -1,113 +1,131 @@
 let read = require('../../../read')
+let getLambda = require('./get-lambda')
 let getRuntime = require('./get-runtime')
 let getHandler = require('./get-handler')
 let upsert = require('../../_upsert')
-let is = require('../../../lib/is')
-
-// Pragma-specific Lambda constructors
-let getHTTP = require('./_http')
-let getEvents = require('./_events')
-let getPlugins = require('./_plugins')
-let getScheduled = require('./_scheduled')
-let getWS = require('./_websockets')
-let getTablesStreams = require('./_tables-streams')
+let defaultFunctionConfig = require('../../../defaults/function-config')
+let { compiledRuntimes, is } = require('../../../lib')
 
 /**
- * Build out the Lambda tree
+ * Build out the Lambda tree from the Arc manifest or a passed pragma, and plugins
  */
-function populateLambda (type, pragma, inventory, errors) {
-  if (!pragma || !pragma.length) return null // Jic
+function populateLambda (type, { arc, inventory, errors, pragma }) {
+  let plugins = inventory.plugins?._methods?.set?.[type]
+  let pluginLambda = []
+  if (plugins) {
+    let pluginResults = plugins.flatMap(fn => {
+      let result = fn({ arc, inventory })
+      if (!result) {
+        errors.push(`Setter plugins must return a valid response: plugin: ${fn.plugin}, method: set.${type}`)
+        return []
+      }
+      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
+}
+
+function populate (type, pragma, inventory, errors, plugin) {
+  if (!pragma || !pragma.length) return
 
-  let createDefaultConfig = () => JSON.parse(JSON.stringify(inventory._project.defaultFunctionConfig))
-  let cwd = inventory._project.src
+  let defaultProjectConfig = () => JSON.parse(JSON.stringify(inventory._project.defaultFunctionConfig))
+  let { cwd, src: projSrc, build: projBuild } = inventory._project
 
   // Fill er up
   let lambdas = []
 
   for (let item of pragma) {
     // Get name, source dir, and any pragma-specific properties
-    let results = getLambda({ type, item, cwd, inventory, errors })
-    // Some lambda populators (e.g. plugins) may return empty results
-    if (!results) continue
-    // Some lambda populators (e.g. plugins) may return multiple results
-    if (!is.array(results)) results = [ results ]
-
-    results.forEach(result => {
-      let { name, src } = result
-      // Set up fresh config
-      let config = createDefaultConfig()
-
-      // Knock out any pragma-specific early
-      if (type === 'queues') {
-        config.fifo = config.fifo === undefined ? true : config.fifo
-      }
-      if (type === 'http') {
-        if (name.startsWith('get ') || name.startsWith('any ')) config.views = true
-      }
-
-      // Now let's check in on the function config
-      let { arc: arcConfig, filepath } = read({ type: 'functionConfig', cwd: src, errors })
-
-      // Set function config file path (if one is present)
-      let configFile = filepath ? filepath : null
-
-      // Layer any function config over Arc / project defaults
-      if (arcConfig && arcConfig.aws) {
-        config = upsert(config, arcConfig.aws)
-      }
-      if (arcConfig && arcConfig.arc) {
-        config = upsert(config, arcConfig.arc)
-      }
-
-      // Interpolate runtimes
-      config = getRuntime(config)
-
-      // Tidy up any irrelevant params
-      if (type !== 'http') {
-        delete config.apigateway
-      }
-
-      // Now we know the final source dir + runtime + handler: assemble handler props
-      let { handlerFile, handlerFunction } = getHandler(config, src, errors)
-
-      let lambda = {
-        name,
-        config,
-        src,
-        handlerFile,
-        handlerFunction,
-        configFile,
-        ...result, // Any other pragma-specific stuff
-      }
-
-      lambdas.push(lambda)
-    })
+    let result = getLambda({ type, item, cwd, projSrc, projBuild, inventory, errors, plugin })
+    // Some Lambda populators (e.g. plugins) may return empty result
+    if (!result) continue
+
+    let { name, src, build } = result
+    // Set up fresh config, then overlay plugin config
+    let config = defaultProjectConfig()
+    config = { ...config, ...getKnownProps(configProps, result.config) }
+
+    // Knock out any pragma-specific early
+    if (type === 'queues') {
+      config.fifo = config.fifo === undefined ? true : config.fifo
+    }
+    if (type === 'http') {
+      if (name.startsWith('get ') || name.startsWith('any ')) config.views = true
+    }
+
+    // Now let's check in on the function config
+    let { arc: arcConfig, filepath } = read({ type: 'functionConfig', cwd: src, errors })
+
+    // Set function config file path (if one is present)
+    let configFile = filepath ? filepath : null
+
+    // Layer any function config over Arc / project defaults
+    if (arcConfig && arcConfig.aws) {
+      config = upsert(config, arcConfig.aws)
+    }
+    if (arcConfig && arcConfig.arc) {
+      config = upsert(config, arcConfig.arc)
+    }
+
+    // Interpolate runtimes
+    config = getRuntime({ config, inventory })
+
+    // Disable code sharing on [trans|com]piled functions
+    if (compiledRuntimes.includes(config.runtimeConfig?.type)) {
+      config.shared = config.views = false
+    }
+
+    // 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
+      build = undefined
+    }
+    if (type !== 'http') {
+      delete config.apigateway
+    }
+
+    // Now we know the final source dir + runtime + handler: assemble handler props
+    let handlerProps = getHandler({ config, src, build, errors })
+
+    let lambda = {
+      name,
+      ...getKnownProps(lambdaProps, result), // Pragma-specific stuff
+      config,
+      src,
+      build,
+      ...handlerProps,
+      configFile,
+      pragma: type !== 'customLambdas' ? type : null,
+    }
+    // Final tidying of any undefined properties
+    Object.keys(lambda).forEach(k => !is.defined(lambda[k]) && delete lambda[k])
+
+    lambdas.push(lambda)
   }
 
   return lambdas
 }
 
-let ts = 'tables-streams'
-
-function getLambda (params) {
-  let { type } = params
-  params.dir = `src/${type}/`
-
-  if (type === 'http')      return getHTTP(params)
-  if (type === 'events')    return getEvents(params)
-  if (type === 'plugins')   return getPlugins(params)
-  if (type === 'queues')    return getEvents(params) // Effectively the same as events
-  if (type === 'scheduled') return getScheduled(params)
-  if (type === ts)          return getTablesStreams(params)
-  if (type === 'tables')    return getTablesStreams(params) // Shortcut for creating streams
-  /* istanbul ignore else */ /* Clearer to be explicit here */
-  if (type === 'ws')        return getWS(params)
+// Lambda setter plugins can technically return anything, so this ensures everything is tidy
+let lambdaProps = [ 'cron', 'method', 'path', 'plugin', 'rate', 'route', 'table' ]
+let configProps = [ ...Object.keys(defaultFunctionConfig()), 'fifo', 'views' ]
+let getKnownProps = (knownProps, raw = {}) => {
+  let props = knownProps.flatMap(prop => is.defined(raw[prop]) ? [ [ prop, raw[prop] ] ] : [])
+  return Object.fromEntries(props)
 }
 
+let cl = 'customLambdas'
+let ts = 'tables-streams'
+
 module.exports = {
   events:     populateLambda.bind({}, 'events'),
   http:       populateLambda.bind({}, 'http'),
-  plugins:    populateLambda.bind({}, 'plugins'),
+  [cl]:       populateLambda.bind({}, cl),
   queues:     populateLambda.bind({}, 'queues'),
   scheduled:  populateLambda.bind({}, 'scheduled'),
   tables:     populateLambda.bind({}, 'tables'),

package/src/config/pragmas/queues.js

@@ -2,9 +2,10 @@ let populate = require('./populate-lambda')
 let validate = require('./validate')
 
 module.exports = function configureQueues ({ arc, inventory, errors }) {
-  if (!arc.queues || !arc.queues.length) return null
+  let queuesPlugins = inventory.plugins?._methods?.set?.queues
+  if (!arc?.queues?.length && !queuesPlugins?.length) return null
 
-  let queues = populate.queues(arc.queues, inventory, errors)
+  let queues = populate.queues({ arc, inventory, errors })
 
   validate.queues(queues, '@queues', errors)
 

package/src/config/pragmas/scheduled.js

@@ -2,9 +2,10 @@ let populate = require('./populate-lambda')
 let validate = require('./validate')
 
 module.exports = function configureScheduled ({ arc, inventory, errors }) {
-  if (!arc.scheduled || !arc.scheduled.length) return null
+  let scheduledPlugins = inventory.plugins?._methods?.set?.scheduled
+  if (!arc?.scheduled?.length && !scheduledPlugins?.length) return null
 
-  let scheduled = populate.scheduled(arc.scheduled, inventory, errors)
+  let scheduled = populate.scheduled({ arc, inventory, errors })
 
   validate.scheduled(scheduled, errors)
 

package/src/config/pragmas/shared.js

@@ -1,24 +1,24 @@
 let { join } = require('path')
 let validate = require('./validate')
-let is = require('../../lib/is')
-let { lambdas } = require('../../lib/pragmas')
+let { is, pragmas } = require('../../lib')
+let lambdas = pragmas.lambdas.concat('customLambdas')
 
 module.exports = function configureShared ({ arc, pragmas, inventory, errors }) {
   if (!pragmas.lambdaSrcDirs) return null
 
-  let cwd = inventory._project.src
-  let src = join(cwd, 'src', 'shared')
+  let { cwd, src: projSrc } = inventory._project
+  let src = join(projSrc, 'shared')
   let shared = {
     src,
     shared: [] // Revert to null later if none are defined
   }
-  if (arc.shared && arc.shared.length) {
-    let foundSrc = false
 
-    // First pass to get + check views folder (if any)
+  // First pass to get + check shared folder (if any)
+  let foundSrc = false
+  if (arc?.shared?.length) {
     for (let share of arc.shared) {
       if (is.array(share)) {
-        let key = share[0].toLowerCase()
+        let key = share[0]?.toLowerCase()
         if (key === 'src' && is.string(share[1])) {
           shared.src = share[1]
           foundSrc = true
@@ -30,49 +30,49 @@ module.exports = function configureShared ({ arc, pragmas, inventory, errors })
         }
       }
     }
+  }
 
-    // Proceeding from here resets all views config, so make sure it's only if specific views are specified
-    let some = !(arc.shared.length === 1 && foundSrc)
-    if (some) {
-      // Reset shared settings
-      for (let pragma of lambdas) {
-        if (!pragmas[pragma]) continue
-        for (let { config } of pragmas[pragma]) {
-          config.shared = false
-        }
+  // Exit if configured shared folder doesn't exist
+  if (!is.exists(shared.src)) return null
+
+  // Proceeding from here resets all shared config, so make sure it's only if specific shared are specified
+  let some = arc.shared?.length && !(arc?.shared?.length === 1 && foundSrc)
+  if (some) {
+    // Reset shared settings
+    for (let pragma of lambdas) {
+      if (!pragmas[pragma]) continue
+      for (let { config } of pragmas[pragma]) {
+        config.shared = false
       }
+    }
 
-      // Set new shared settings
-      for (let pragma of arc.shared) {
-        if (is.array(pragma)) continue // Bail on src setting
-        if (!is.object(pragma)) {
-          return errors.push(`@shared invalid setting: ${pragma}`)
-        }
+    // Set new shared settings
+    for (let pragma of arc.shared) {
+      if (is.array(pragma)) continue // Bail on src setting
+      if (!is.object(pragma)) {
+        return errors.push(`@shared invalid setting: ${pragma}`)
+      }
 
-        let p = Object.keys(pragma)[0]
-        if (!lambdas.includes(p)) {
-          return errors.push(`${p} is not a valid @shared pragma`)
-        }
+      let p = Object.keys(pragma)[0]
+      if (!lambdas.includes(p)) {
+        return errors.push(`${p} is not a valid @shared pragma`)
+      }
 
-        let entries = is.object(pragma[p])
-          ? Object.entries(pragma[p])
-          : pragma[p]
-        for (let lambda of entries) {
-          let name = p === 'http' ? lambda.join(' ') : lambda
-          let fn = pragmas[p].find(n => n.name === name)
-          if (!fn) {
-            return errors.push(`@shared ${name} not found in @${p} Lambdas`)
-          }
-          // Ignore shared into ASAP
-          if (!fn.arcStaticAssetProxy) fn.config.shared = true
+      let entries = is.object(pragma[p])
+        ? Object.entries(pragma[p])
+        : pragma[p]
+      for (let lambda of entries) {
+        let name = p === 'http' ? lambda.join(' ') : lambda
+        let fn = pragmas[p].find(n => n.name === name)
+        if (!fn) {
+          return errors.push(`@shared ${name} not found in @${p} Lambdas`)
         }
+        // Ignore shared into ASAP
+        if (!fn.arcStaticAssetProxy) fn.config.shared = true
       }
     }
   }
 
-  // Exit if default views folder doesn't exist
-  if (!is.exists(shared.src)) return null
-
   // lambda.config.shared was added by function config defaults, or added above
   for (let pragma of lambdas) {
     if (!pragmas[pragma]) continue
@@ -83,8 +83,5 @@ module.exports = function configureShared ({ arc, pragmas, inventory, errors })
     }
   }
 
-  // De-dupe (in case multiple functions live at the same src path)
-  shared.shared = [ ...new Set(shared.shared) ]
-
   return shared
 }

package/src/config/pragmas/sort/http.js

@@ -0,0 +1,72 @@
+let { httpMethods } = require('../../../lib')
+
+/**
+ * HTTP route sorter; this is a multifurcating tree, so we'll do a few passes
+ * Broadly in the theme of most to least specific:
+ * - First, by method, with `any` last
+ * - Then by path depth (descending)
+ * - Within each depth downrank for contained params
+ * - Then sort alphabetically
+ * - Then, ensure trailing captures are last
+ * - Finally, ensure root captures rank below a root literal
+ */
+module.exports = function sortHTTP (http) {
+  // Construct the tree from HTTP methods
+  let tree = {}
+  http.forEach(({ method, path }) => {
+    if (!tree[method]) tree[method] = []
+    let parts = path.split('/').filter(Boolean)
+    let depth = parts.length
+    let item = { depth, path }
+    let param = /\/:/
+    if (path.match(param)) {
+      item.hasParam = true
+      item.paramIndex = path.match(param).index // If multiple, we want the earliest
+    }
+    if (parts.length) {
+      if (parts[depth - 1] === '*') item.trailingCapture = 'catchall'
+      if (parts[depth - 1].startsWith(':')) item.trailingCapture = 'param'
+    }
+    tree[method].push(item)
+  })
+
+  // Multi-pass route sort
+  let sorted = []
+  httpMethods.forEach(method => {
+    if (!tree[method]) return
+    /* istanbul ignore next: random test shuffles may not trigger all paths */
+    tree[method]
+      // Sort by depth
+      .sort((a, b) => b.depth - a.depth)
+      // Sort within a given depth
+      .sort((a, b) => {
+        // Handle root (depth: 0)
+        if (a.depth - b.depth < 0) return
+        if (a.hasParam && b.hasParam) {
+          // Sort at the earliest param
+          if (a.paramIndex < b.paramIndex) return 1
+          if (a.paramIndex > b.paramIndex) return -1
+          // Then sort alphabetically
+          if (a.path < b.path) return -1
+          if (a.path > b.path) return 1
+        }
+        if (a.hasParam) return 1
+        if (b.hasParam) return -1
+        if (a.path < b.path) return -1
+        if (a.path > b.path) return 1
+      })
+      // Trailing capture sort
+      .sort((a, b) => {
+        if (!a.depth && b.depth === 1 && b.trailingCapture) return -1
+        if (a.depth - b.depth < 0) return
+        if (a.trailingCapture) return 1
+        if (b.trailingCapture) return -1
+      })
+    tree[method].forEach(({ path }) => {
+      let route = http.find(i => i.method === method && i.path === path)
+      sorted.push(route)
+    })
+  })
+
+  return sorted
+}

package/src/config/pragmas/static.js

@@ -1,5 +1,4 @@
-let asapSrc = require('../../lib/asap-src')
-let is = require('../../lib/is')
+let { asapSrc, is } = require('../../lib')
 
 module.exports = function configureStatic ({ arc, inventory }) {
   // @static is inferred by @http

package/src/config/pragmas/tables-indexes.js

@@ -1,19 +1,15 @@
-let is = require('../../lib/is')
+let { is } = require('../../lib')
 let validate = require('./validate')
 
-function configureTablesIndexes ({ arc, errors }) {
+module.exports = function configureTablesIndexes ({ arc, errors }) {
   if (!arc['tables-indexes'] || !arc['tables-indexes'].length) return null
   if (arc['tables-indexes'] && !arc.tables) {
     errors.push(`Specifying @tables-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, 'tables-indexes', errors)
-  validate.indexes(indexes, '@tables-indexes', errors)
+  validate.tablesIndexes(indexes, '@tables-indexes', errors)
 
   return indexes
 }
@@ -54,6 +50,3 @@ let getIndexes = (arc, pragma, errors) => {
     error(index)
   }).filter(Boolean) // Invalid indexes may create undefined entries in the map
 }
-
-configureTablesIndexes.getIndexes = getIndexes
-module.exports = configureTablesIndexes