configorama 0.10.4 → 0.11.2

package/cli.js

@@ -215,6 +215,7 @@ if (argv._.length) {
 
 // Set -- flags as options
 options.options = rest
+options.handleSignalEvents = true
 
 // Process the configuration
 configorama(inputFile, options)

package/index.d.ts

@@ -75,6 +75,8 @@ interface ConfigoramaSettings {
   mergeKeys?: string[]
   /** Map of file paths to override */
   filePathOverrides?: Record<string, string>
+  /** Install Configorama CLI signal handlers. Defaults to false for library calls. */
+  handleSignalEvents?: boolean
 }
 
 interface ConfigoramaResult<T = any> {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "configorama",
-  "version": "0.10.4",
+  "version": "0.11.2",
   "description": "Variable support for configuration files",
   "main": "src/index.js",
   "types": "index.d.ts",

package/src/index.js

@@ -22,6 +22,7 @@ const { buildVariableSyntax } = require('./utils/variables/variableUtils')
  * @property {boolean} [dotEnvDebug] - enable env-stage-loader debug logs when useDotenv/useDotEnv is enabled
  * @property {string[]} [mergeKeys] - keys to merge in arrays of objects
  * @property {Object.<string, string>} [filePathOverrides] - map of file paths to override
+ * @property {boolean} [handleSignalEvents] - install Configorama CLI signal handlers. Defaults to false for library calls.
  */
 
 /**

package/src/main.js

@@ -138,8 +138,8 @@ let DEBUG_TYPE = false
 
 class Configorama {
   constructor(fileOrObject, opts) {
-    /* attach sig events on async calls */
-    if (opts && !opts.sync) {
+    /* CLI-only by default. Library consumers should not get process-level signal handlers. */
+    if (opts && opts.handleSignalEvents && !opts.sync) {
       handleSignalEvents()
     }
   
@@ -372,7 +372,12 @@ class Configorama {
         description: `Resolves values from files. Supports sub-properties via :key or .key lookup.`,
         match: fileRefSyntax,
         resolver: (varString, o, x, pathValue) => {
-          return this.getValueFromFile(varString, { context: pathValue })
+          // Inside ignore-path contexts (e.g. Fn::Sub) inline the file as raw text so
+          // embedded CloudFormation refs survive and the body stays a string. Skip
+          // raw mode when a :key/.key accessor is present — that needs a parsed value.
+          const hasAccessor = /\)\s*[:.]/.test(varString)
+          const asRawText = !!(pathValue && this.isIgnorePath(pathValue.path)) && !hasAccessor
+          return this.getValueFromFile(varString, { asRawText, context: pathValue })
         },
       },
 
@@ -484,6 +489,16 @@ class Configorama {
     )
     this.variablesKnownTypes = variablesKnownTypes
 
+    // Explicit configorama types that should still resolve inside ignore-path
+    // contexts like Fn::Sub (file, text, env, opt, cron, git, user sources, ...).
+    // Excludes self/dot.prop refs — those are left verbatim for CloudFormation /
+    // downstream Serverless resolution.
+    this.subResolvableTypes = combineRegexes(
+      /** @type {RegExp[]} */ (this.variableTypes
+        .filter((v) => v.type !== 'string' && v.type !== 'self' && v.type !== 'dot.prop' && v.match instanceof RegExp)
+        .map((v) => v.match))
+    )
+
     // Build prefix lookup map for O(1) type detection (perf optimization)
     this._resolverByPrefix = new Map()
     for (const r of this.variableTypes) {
@@ -1111,9 +1126,23 @@ class Configorama {
   // #######################
   // ## PROPERTY HANDLING ##
   // #######################
-  shouldSkipResolution(pathValue) {
+  isIgnorePath(pathValue) {
     return shouldIgnorePath(pathValue, this.ignorePathPatterns)
   }
+  // True when the value has a configorama-typed token that resolves even inside an
+  // ignore-path (file/text/env/opt/cron/git/custom) — i.e. not just self/CFN refs.
+  hasSubResolvableToken(value) {
+    if (typeof value !== 'string') return false
+    const matches = this.getMatches(value)
+    if (!isArray(matches)) return false
+    return matches.some((m) => this.subResolvableTypes.test(m.variable))
+  }
+  shouldSkipResolution(pathValue, value) {
+    if (!this.isIgnorePath(pathValue)) return false
+    // Under an ignore path (Fn::Sub etc.) keep resolving configorama's own typed
+    // refs; only skip when nothing but self/CFN refs remain.
+    return !this.hasSubResolvableToken(value)
+  }
 
   /**
    * The declaration of a terminal property.  This declaration includes the path and value of the
@@ -1275,7 +1304,7 @@ class Configorama {
     /* Leave opaque paths verbatim. These often contain non-configorama
        `${...}` syntax from CloudFormation, JavaScript, shell, VTL, etc. */
     variables = variables.filter((property) => {
-      return !this.shouldSkipResolution(property.path)
+      return !this.shouldSkipResolution(property.path, property.value)
     })
     /*
     console.log(`variables at call count ${this.callCount}`, variables)
@@ -1563,7 +1592,7 @@ class Configorama {
       console.log(valueObject)
     }
     const property = valueObject.value
-    if (this.shouldSkipResolution(valueObject.path)) {
+    if (this.shouldSkipResolution(valueObject.path, property)) {
       return Promise.resolve(property)
     }
     const matches = this.getMatches(property)
@@ -2166,6 +2195,7 @@ Missing Value ${missingValue} - ${matchedString}
     // Cache joined path to avoid repeated array.join('.') calls
     const pathJoined = pathValue && pathValue.length ? pathValue.join('.') : null
 
+
     // Track every call to getValueFromSource for metadata
     if (this._trackCalls && pathJoined) {
       const pathKey = pathJoined
@@ -2318,6 +2348,14 @@ Missing Value ${missingValue} - ${matchedString}
     // console.log('resolverFunction', resolverFunction)
     /** */
 
+    // Inside ignore-path contexts (Fn::Sub, inline code, VTL templates, ...) leave
+    // self refs, bare config refs, and CloudFormation refs verbatim for CloudFormation
+    // / downstream Serverless to resolve. Everything configorama can resolve on its own
+    // (file/text/env/opt/cron/eval/git/custom/string/number) still resolves.
+    if (this.isIgnorePath(pathValue) && (!found || resolverType === 'self' || resolverType === 'dot.prop')) {
+      return Promise.resolve(encodeUnknown(this.varPrefix + variableString + this.varSuffix))
+    }
+
     if (found && resolverFunction) {
       /*
       console.log(`----------Resolver [${resolverType}]----------------------`)

package/src/parsers/esm.js

@@ -7,22 +7,7 @@ const path = require('path')
  * @returns {Promise<*>} The result of executing the ESM file
  */
 async function executeESMFile(filePath, opts = {}) {
-  try {
-    // Use require for now since ESM dynamic import in async context is complex
-    // We'll use jiti to handle ESM syntax
-    const { createJiti } = require('jiti')
-    const jiti = createJiti(__filename, {
-      interopDefault: true
-    })
-
-    // Load the ESM file - resolve to absolute path first
-    const resolvedPath = path.resolve(filePath)
-    let esmModule = jiti(resolvedPath)
-
-    return esmModule
-  } catch (err) {
-    throw new Error(`Failed to load ESM file ${filePath}: ${err.message}`)
-  }
+  return executeESMFileSync(filePath, opts)
 }
 
 /**

package/src/parsers/typescript.js

@@ -8,54 +8,7 @@ const fs = require('fs')
  * @returns {Promise<*>} The exported module from the TypeScript file
  */
 async function executeTypeScriptFile(filePath, opts = {}) {
-  // Check if tsx is available first (preferred)
-  let useTsx = false
-  try {
-    require.resolve('tsx/cjs/api')
-    useTsx = true
-  } catch (err) {
-    // Fallback to ts-node if tsx is not available
-    try {
-      require.resolve('ts-node/register')
-    } catch (tsNodeErr) {
-      throw new Error(
-        'TypeScript support requires either "tsx" or "ts-node" to be installed. ' +
-        'Please install one of them:\n' +
-        '  npm install tsx --save-dev (recommended)\n' +
-        '  npm install ts-node typescript --save-dev'
-      )
-    }
-  }
-
-  // Clear require cache to ensure fresh execution
-  const resolvedPath = require.resolve(filePath)
-  delete require.cache[resolvedPath]
-
-  let tsFile
-  if (useTsx) {
-    // Use tsx for modern, fast TypeScript execution
-    // @ts-ignore - tsx doesn't have type declarations
-    const { register } = require('tsx/cjs/api')
-    const restore = register()
-    try {
-      tsFile = require(filePath)
-    } catch (err) {
-      throw new Error(`Failed to load TypeScript file: ${err.message}`)
-    } finally {
-      restore()
-    }
-  } else {
-    // Fallback to ts-node
-    try {
-      // @ts-ignore - ts-node is optional peer dependency
-      require('ts-node/register')
-      tsFile = require(filePath)
-    } catch (err) {
-      throw new Error(`Failed to load TypeScript file with ts-node: ${err.message}`)
-    }
-  }
-
-  return tsFile
+  return executeTypeScriptFileSync(filePath, opts)
 }
 
 /**

package/src/resolvers/valueFromCron.js

@@ -91,34 +91,13 @@ function parseCronExpression(input) {
     return `${minute} ${hour} * * *`
   }
 
-  // Parse "every X minutes/hours/days" patterns
-  const everyMatch = normalizedInput.match(/^every (\d+) (minute|minutes|hour|hours|day|days|week|weeks|month|months)s?$/i)
-  if (everyMatch) {
-    const interval = parseInt(everyMatch[1])
-    const unit = everyMatch[2].toLowerCase().replace(/s$/, '') // Remove trailing 's' if present
-    
-    switch (unit) {
-      case 'minute':
-        return `*/${interval} * * * *`
-      case 'hour':
-        return `0 */${interval} * * *`
-      case 'day':
-        return `0 0 */${interval} * *`
-      case 'week':
-        return `0 0 * * 0/${interval}`
-      case 'month':
-        return `0 0 1 */${interval} *`
-      default:
-        throw new Error(`Unsupported interval unit: ${unit}`)
-    }
-  }
-
-  // Parse "X minute(s)/hour(s)/day(s)" patterns (e.g., "1 minute", "5 minutes", "1 hour")
-  const intervalMatch = normalizedInput.match(/^(\d+) (minute|minutes|hour|hours|day|days|week|weeks|month|months)s?$/i)
+  // Parse "every X minutes/hours/days" and bare "X minute(s)/hour(s)/day(s)" patterns
+  // (e.g., "every 5 minutes", "1 minute", "5 minutes", "1 hour")
+  const intervalMatch = normalizedInput.match(/^(?:every )?(\d+) (minute|minutes|hour|hours|day|days|week|weeks|month|months)s?$/i)
   if (intervalMatch) {
     const interval = parseInt(intervalMatch[1])
     const unit = intervalMatch[2].toLowerCase().replace(/s$/, '') // Remove trailing 's' if present
-    
+
     switch (unit) {
       case 'minute':
         return `*/${interval} * * * *`

package/src/resolvers/valueFromFile.js

@@ -115,7 +115,9 @@ function parseFileContents(content, filePath) {
  */
 async function getValueFromFile(ctx, variableString, options) {
   const opts = options || {}
-  const syntax = opts.asRawText ? ctx.textRefSyntax : ctx.fileRefSyntax
+  // Pick syntax from the ref keyword, not the raw-text flag, so a file() ref can
+  // also be inlined as raw text (e.g. inside an Fn::Sub) without losing its match.
+  const syntax = /^\s*text\(/.test(variableString) ? ctx.textRefSyntax : ctx.fileRefSyntax
   // console.log('From file', `"${variableString}"`)
   let matchedFileString = variableString.match(syntax)[0]
   // console.log('matchedFileString', matchedFileString)

package/src/utils/paths/ignorePaths.js

@@ -1,5 +1,6 @@
 const DEFAULT_IGNORE_PATHS = [
   '**.Fn::Sub',
+  '**.Fn::Sub.0',
   '**.Properties.Code.ZipFile',
   '**.Properties.FunctionCode',
   '**.Properties.UserData',