configorama 0.7.2 → 0.9.0

package/src/main.js

@@ -2,19 +2,16 @@
 const os = require('os')
 const path = require('path')
 const fs = require('fs')
-
 /* // disable logs to find broken tests
 console.log = () => {}
 // process.exit(1)
 /** */
-
 /* External dependencies */
 const promiseFinallyShim = require('promise.prototype.finally').shim()
 const findUp = require('find-up')
 const traverse = require('traverse')
 const dotProp = require('dot-prop')
 const { makeBox, makeStackedBoxes } = require('@davidwells/box-logger')
-
 /* Utils - root */
 const {
   isArray, isString, isNumber, isObject, isDate, isRegExp, isFunction,
@@ -23,71 +20,56 @@ const {
 } = require('./utils/lodash')
 const PromiseTracker = require('./utils/PromiseTracker')
 const handleSignalEvents = require('./utils/handleSignalEvents')
-
 /* Utils - encoders */
 const { encodeUnknown, decodeUnknown } = require('./utils/encoders/unknown-values')
 const { decodeEncodedValue } = require('./utils/encoders')
-const { encodeJsSyntax, decodeJsSyntax, hasParenthesesPlaceholder, encodeJsonForVariable } = require('./utils/encoders/js-fixes')
-
+const { decodeJsSyntax, hasParenthesesPlaceholder, encodeJsonForVariable } = require('./utils/encoders/js-fixes')
 /* Utils - parsing */
 const enrichMetadata = require('./utils/parsing/enrichMetadata')
 const preProcess = require('./utils/parsing/preProcess')
 const { parseFileContents } = require('./utils/parsing/parse')
 const { mergeByKeys } = require('./utils/parsing/mergeByKeys')
 const { arrayToJsonPath } = require('./utils/parsing/arrayToJsonPath')
-
 /* Utils - paths */
 const { normalizePath, extractFilePath, resolveInnerVariables } = require('./utils/paths/filePathUtils')
-const { resolveAlias } = require('./utils/paths/resolveAlias')
-const { resolveFilePathFromMatch } = require('./utils/paths/getFullFilePath')
 const { findLineForKey } = require('./utils/paths/findLineForKey')
-
 /* Utils - regex */
-const { combineRegexes, funcRegex, funcStartOfLineRegex, subFunctionRegex } = require('./utils/regex')
-
+const { combineRegexes, funcRegex } = require('./utils/regex')
 /* Utils - strings */
 const formatFunctionArgs = require('./utils/strings/formatFunctionArgs')
-
 const { splitByComma } = require('./utils/strings/splitByComma')
 const { splitCsv } = require('./utils/strings/splitCsv')
 const { replaceAll } = require('./utils/strings/replaceAll')
 const { getTextAfterOccurrence, findNestedVariable } = require('./utils/strings/textUtils')
-const { trimSurroundingQuotes, ensureQuote, isSurroundedByQuotes, startsWithQuotedPipe } = require('./utils/strings/quoteUtils')
-
+const { ensureQuote, isSurroundedByQuotes, startsWithQuotedPipe } = require('./utils/strings/quoteUtils')
 /* Utils - ui */
 const chalk = require('./utils/ui/chalk')
 const deepLog = require('./utils/ui/deep-log')
 const { logHeader } = require('./utils/ui/logs')
 const { createEditorLink } = require('./utils/ui/createEditorLink')
 const { runConfigWizard, isSensitiveVariable } = require('./utils/ui/configWizard')
-
 /* Utils - validation */
 const { warnIfNotFound, isValidValue } = require('./utils/validation/warnIfNotFound')
-
 /* Utils - variables */
 const cleanVariable = require('./utils/variables/cleanVariable')
 const appendDeepVariable = require('./utils/variables/appendDeepVariable')
-const { extractVariableWrapper, getFallbackString, verifyVariable } = require('./utils/variables/variableUtils')
+const { extractVariableWrapper, getFallbackString, verifyVariable, buildVariableSyntax } = require('./utils/variables/variableUtils')
 const { findNestedVariables } = require('./utils/variables/findNestedVariables')
-
 /* Resolvers */
 const getValueFromString = require('./resolvers/valueFromString')
 const getValueFromNumber = require('./resolvers/valueFromNumber')
 const getValueFromEnv = require('./resolvers/valueFromEnv')
 const getValueFromOptions = require('./resolvers/valueFromOptions')
+const getValueFromParam = require('./resolvers/valueFromParam')
 const getValueFromCron = require('./resolvers/valueFromCron')
 const getValueFromEval = require('./resolvers/valueFromEval')
 const createGitResolver = require('./resolvers/valueFromGit')
 const { getValueFromFile: getValueFromFileResolver } = require('./resolvers/valueFromFile')
-
 /* Parsers */
-const YAML = require('./parsers/yaml')
-const TOML = require('./parsers/toml')
-const INI = require('./parsers/ini')
 const JSON5 = require('./parsers/json5')
-
 /* Functions */
 const md5Function = require('./functions/md5')
+
 /**
  * Maintainer's notes:
  *
@@ -102,6 +84,7 @@ const md5Function = require('./functions/md5')
  *   pause population, noting the continued depth to traverse.  This motivated "deep" variables.
  *   Original issue #4687
  */
+
 const deepRefSyntax = RegExp(/(\${)?deep:\d+(\.[^}]+)*()}?/)
 const deepIndexReplacePattern = new RegExp(/^deep:|(\.[^}]+)*$/g)
 const deepIndexPattern = /deep\:(\d*)/
@@ -110,8 +93,6 @@ const fileRefSyntax = RegExp(/^file\((~?[@\{\}\:\$a-zA-Z0-9._\-\/,'" =+]+?)\)/g)
 const textRefSyntax = RegExp(/^text\((~?[@\{\}\:\$a-zA-Z0-9._\-\/,'" =+]+?)\)/g)
 // TODO update file regex ^file\((~?[a-zA-Z0-9._\-\/, ]+?)\)
 // To match file(asyncValue.js, lol) input params
-const envRefSyntax = RegExp(/^env:/g)
-const optRefSyntax = RegExp(/^opt:/g)
 const selfRefSyntax = RegExp(/^self:/g)
 const base64WrapperRegex = /\[_\[([A-Za-z0-9+/=\s]*)\]_\]/g
 const logLines = '─────────────────────────────────────────────────'
@@ -133,13 +114,14 @@ class Configorama {
     const options = opts || {}
     // Set opts to pass into JS file calls
     this.settings = Object.assign({}, {
-      // Allow for unknown variable syntax to pass through without throwing errors
-      allowUnknownVariables: false,
-      // Allow undefined to be an end result.
+      // Allow unknown ${xyz:...} syntax where xyz is not a registered resolver
+      // Can be: false | true | ['ssm', 'cf', ...]
+      allowUnknownVariableTypes: false,
+      // Allow undefined to be an end result
       allowUndefinedValues: false,
-      // Allow unknown file refs to pass through without throwing errors
-      allowUnknownFileRefs: false,
       // Allow known variable types that can't be resolved to pass through
+      // Can be: false | true | ['param', 'file', 'env', ...]
+      // Note: Does not apply to self: or dotprop refs - those always error
       allowUnresolvedVariables: false,
       // Return metadata
       returnMetadata: false,
@@ -147,10 +129,26 @@ class Configorama {
       returnPreResolvedVariableDetails: false,
     }, options)
 
-    // Backward compat: allowUnknownVars -> allowUnknownVariables
-    if (options.allowUnknownVars !== undefined && options.allowUnknownVariables === undefined) {
-      this.settings.allowUnknownVariables = options.allowUnknownVars
+    // Backward compat: allowUnknownVars -> allowUnknownVariableTypes
+    if (options.allowUnknownVars !== undefined && options.allowUnknownVariableTypes === undefined) {
+      this.settings.allowUnknownVariableTypes = options.allowUnknownVars
+    }
+    // Backward compat: allowUnknownVariables -> allowUnknownVariableTypes
+    if (options.allowUnknownVariables !== undefined && options.allowUnknownVariableTypes === undefined) {
+      this.settings.allowUnknownVariableTypes = options.allowUnknownVariables
+    }
+
+    // Merge legacy allowUnknownParams and allowUnknownFileRefs into allowUnresolvedVariables
+    let unresolvedSetting = this.settings.allowUnresolvedVariables
+    if (unresolvedSetting !== true) {
+      const specificTypes = Array.isArray(unresolvedSetting) ? [...unresolvedSetting] : []
+      if (options.allowUnknownParams) specificTypes.push('param')
+      if (options.allowUnknownFileRefs) specificTypes.push('file')
+      if (specificTypes.length > 0) {
+        unresolvedSetting = [...new Set(specificTypes)]
+      }
     }
+    this.settings.allowUnresolvedVariables = unresolvedSetting
 
     this.filterCache = {}
 
@@ -160,8 +158,8 @@ class Configorama {
     // Track variable resolutions for metadata (keyed by path)
     this.resolutionTracking = {}
 
-    const defaultSyntax = '\\${((?!AWS|stageVariables)[ ~:a-zA-Z0-9=+!@#%*<>?._\'",|\\-\\/\\(\\)\\\\]+?)}'
-  
+    const defaultSyntax = buildVariableSyntax('${', '}', ['AWS', 'stageVariables'])
+
     const varSyntax = options.syntax || defaultSyntax
     let varRegex
     if (typeof varSyntax === 'string') {
@@ -229,6 +227,14 @@ class Configorama {
        */
       getValueFromOptions,
 
+      /**
+       * Parameters
+       * Usage:
+       * ${param:domain}
+       * ${param:key, "fallbackValue"}
+       */
+      getValueFromParam,
+
       /**
        * Cron expressions
        * Usage:
@@ -542,6 +548,56 @@ class Configorama {
     this.callCount = 0
   }
 
+  /**
+   * Check if unresolved variables of a given type should pass through
+   * @param {string} type - The resolver type (e.g., 'param', 'file', 'env')
+   * @returns {boolean}
+   */
+  isUnresolvedAllowed(type) {
+    const setting = this.settings.allowUnresolvedVariables
+    if (setting === true) return true
+    if (setting === false || setting === undefined) return false
+    if (Array.isArray(setting) && setting.includes(type)) return true
+    return false
+  }
+
+  /**
+   * Extract type prefix from a variable string
+   * @param {string} varString - Variable string like 'ssm:path/to/thing' or 'custom:value'
+   * @returns {string|null} The type prefix or null if not found
+   */
+  extractTypePrefix(varString) {
+    if (!varString || typeof varString !== 'string') return null
+    const colonIndex = varString.indexOf(':')
+    if (colonIndex === -1) return null
+    return varString.substring(0, colonIndex)
+  }
+
+  /**
+   * Check if unknown variable types should pass through
+   * @param {string} varString - Variable string like 'ssm:path' or full '${ssm:path}'
+   * @returns {boolean}
+   */
+  isUnknownTypeAllowed(varString) {
+    const setting = this.settings.allowUnknownVariableTypes
+    if (setting === true) return true
+    if (setting === false || setting === undefined) return false
+    if (Array.isArray(setting)) {
+      // Extract type prefix from variable string
+      // Handle both 'ssm:path' and '${ssm:path}' formats
+      let cleanVar = varString
+      if (cleanVar.startsWith(this.varPrefix)) {
+        cleanVar = cleanVar.slice(this.varPrefix.length)
+      }
+      if (cleanVar.endsWith(this.varSuffix)) {
+        cleanVar = cleanVar.slice(0, -this.varSuffix.length)
+      }
+      const typePrefix = this.extractTypePrefix(cleanVar)
+      if (typePrefix && setting.includes(typePrefix)) return true
+    }
+    return false
+  }
+
   // ################
   // ## PUBLIC API ##
   // ################
@@ -1941,8 +1997,8 @@ class Configorama {
     for (let i = 0; i < matches.length; i += 1) {
       warnIfNotFound(matches[i].variable, results[i], {
         patterns: {
-          env: envRefSyntax,
-          opt: optRefSyntax,
+          env: getValueFromEnv.match,
+          opt: getValueFromOptions.match,
           self: selfRefSyntax,
           file: fileRefSyntax,
           deep: deepRefSyntax,
@@ -2380,7 +2436,7 @@ class Configorama {
 
       if (nestedVar) {
         const fallbackStr = getFallbackString(splitVars, nestedVar)
-        if (!this.settings.allowUnknownVariables) {
+        if (!this.isUnknownTypeAllowed(nestedVar)) {
           verifyVariable(nestedVar, valueObject, this.variableTypes, this.config)
         }
 
@@ -2712,6 +2768,25 @@ Missing Value ${missingValue} - ${matchedString}
 
     // console.log('getValueFromSrc propertyString', propertyString)
     // console.log(`tracker contains ${variableString}`, this.tracker.contains(variableString))
+
+    // Cycle detection: track dependencies and check for cycles
+    const fromPath = valueObject.path ? valueObject.path.join('.') : null
+    // Extract target path from variableString (e.g., 'self:b' → 'b', 'b.c' → 'b.c')
+    let toPath = variableString
+    if (variableString.startsWith('self:')) {
+      toPath = variableString.slice(5)
+    }
+    // For cycle detection, only track self-references
+    if (fromPath && (variableString.startsWith('self:') || !variableString.includes(':'))) {
+      if (this.tracker.wouldCreateCycle(fromPath, toPath)) {
+        const cyclePath = this.tracker.getCyclePath(fromPath, toPath)
+        return Promise.reject(new Error(
+          `Circular variable dependency detected: ${cyclePath.join(' → ')}`
+        ))
+      }
+      this.tracker.addDependency(fromPath, toPath)
+    }
+
     if (this.tracker.contains(variableString)) {
       // console.log('try to get', variableString)
       return this.tracker.get(variableString, propertyString)
@@ -2864,14 +2939,21 @@ Missing Value ${missingValue} - ${matchedString}
           // console.log('nestedVars', nestedVars)
           const noNestedVars = nestedVars.length < 2
 
-          if (this.settings.allowUnknownFileRefs && variableString.match(fileRefSyntax)) {
-            // Encode the unknown file variable to pass through resolution
+          // Check if this unresolved variable type should pass through
+          const isFileRef = variableString.match(fileRefSyntax)
+          const isParamRef = variableString.match(getValueFromParam.match)
+
+          // Params pass through entirely (including fallbacks) for third-party resolution
+          if (isParamRef && this.isUnresolvedAllowed('param')) {
             return Promise.resolve(encodeUnknown(propertyString))
           }
 
-          if (this.settings.allowUnresolvedVariables) {
+          const isUnresolvedAllowed =
+            this.settings.allowUnresolvedVariables === true ||
+            (isFileRef && this.isUnresolvedAllowed('file'))
+
+          if (isUnresolvedAllowed) {
             // Check if outer expression has fallbacks we can use
-            // valueCount[0] is the primary var, valueCount[1+] are fallbacks
             if (valueCount.length > 1) {
               const primaryVar = valueCount[0]
               // If the unresolvable variableString is used INSIDE the primary var,
@@ -2880,7 +2962,6 @@ Missing Value ${missingValue} - ${matchedString}
                 return Promise.resolve(undefined)
               }
             }
-            // Encode unresolved variable to pass through resolution
             return Promise.resolve(encodeUnknown(propertyString))
           }
 
@@ -3046,7 +3127,7 @@ Missing Value ${missingValue} - ${matchedString}
       // console.log('nestedVar', nestedVar)
 
       if (nestedVar) {
-        if (!this.settings.allowUnknownVariables) {
+        if (!this.isUnknownTypeAllowed(nestedVar)) {
           verifyVariable(nestedVar, valueObject, this.variableTypes, this.config)
         }
         const fallbackStr = getFallbackString(split, nestedVar)
@@ -3148,8 +3229,8 @@ Missing Value ${missingValue} - ${matchedString}
 
 
 
-    /* Pass through unknown variables */
-    if (this.settings.allowUnknownVariables || allowSpecialCase) {
+    /* Pass through unknown variable types */
+    if (allowSpecialCase || this.isUnknownTypeAllowed(propertyString)) {
       // console.log('allowUnknownVars propertyString', propertyString)
       const varMatches = propertyString.match(this.variableSyntax)
       let allowUnknownVars = propertyString
@@ -3192,6 +3273,7 @@ Missing Value ${missingValue} - ${matchedString}
         // console.log('self fixed deepProperties', deepProperties)
       }
     }
+
     return this.getDeeperValue(deepProperties, valueToPopulate).then((res) => {
       /*
       console.log('self getDeeperValue variableString', variableString)

package/src/resolvers/valueFromFile.js

@@ -197,7 +197,13 @@ async function getValueFromFile(ctx, variableString, options) {
     // console.log('NO FILE FOUND', fullFilePath)
     // console.log('variableString', variableString)
 
-    if (!hasFallback && !ctx.opts.allowUnknownFileRefs) {
+    // Check if file refs are allowed to pass through unresolved
+    const allowUnresolved = ctx.opts.allowUnresolvedVariables
+    const isFileAllowed = allowUnresolved === true ||
+      (Array.isArray(allowUnresolved) && allowUnresolved.includes('file')) ||
+      ctx.opts.allowUnknownFileRefs // backward compat
+
+    if (!hasFallback && !isFileAllowed) {
       const errorMsg = makeBox({
         title: `File Not Found in ${originalVar}`,
         minWidth: '100%',

package/src/resolvers/valueFromParam.js

@@ -0,0 +1,91 @@
+
+const paramRefSyntax = RegExp(/^param:/g)
+
+/**
+ * Resolves parameter values following the Serverless Framework parameter resolution hierarchy:
+ * 1. CLI params (--param="key=value")
+ * 2. Stage-specific params (stages.<stage>.params)
+ * 3. Default params (stages.default.params)
+ *
+ * @param {string} variableString - The variable string (e.g., "param:domain")
+ * @param {Object} options - CLI options that may contain params
+ * @param {Object} config - The full config object for stage-specific params
+ * @returns {Promise<any>} The resolved parameter value
+ */
+function getValueFromParam(variableString, options = {}, config = {}) {
+  const requestedParam = variableString.split(':')[1]
+
+  if (requestedParam === '') {
+    throw new Error(`Invalid variable syntax for parameter reference "${variableString}".
+
+\${param} variable must have a key path.
+
+Example: \${param:domain}
+`)
+  }
+
+  let valueToPopulate
+
+  // 1. First, check CLI params (--param="key=value")
+  // The param option can be either a string or an array of strings
+  if (options.param) {
+    const params = Array.isArray(options.param) ? options.param : [options.param]
+
+    // Parse param flags in the format "key=value"
+    for (const param of params) {
+      const [key, ...valueParts] = param.split('=')
+      if (key === requestedParam) {
+        valueToPopulate = valueParts.join('=') // rejoin in case value contains =
+        return Promise.resolve(valueToPopulate)
+      }
+    }
+  }
+
+  // 2. Check for stage-specific params (stages.<stage>.params)
+  const stage = options.stage || 'dev'
+  if (config.stages && config.stages[stage] && config.stages[stage].params) {
+    valueToPopulate = config.stages[stage].params[requestedParam]
+    if (valueToPopulate !== undefined) {
+      return Promise.resolve(valueToPopulate)
+    }
+  }
+
+  // 3. Check for default params (stages.default.params)
+  if (config.stages && config.stages.default && config.stages.default.params) {
+    valueToPopulate = config.stages.default.params[requestedParam]
+    if (valueToPopulate !== undefined) {
+      return Promise.resolve(valueToPopulate)
+    }
+  }
+
+  // 4. Check top-level params property (for backwards compatibility)
+  if (config.params) {
+    // Check stage-specific params first
+    if (config.params[stage]) {
+      valueToPopulate = config.params[stage][requestedParam]
+      if (valueToPopulate !== undefined) {
+        return Promise.resolve(valueToPopulate)
+      }
+    }
+
+    // Then check default params
+    if (config.params.default) {
+      valueToPopulate = config.params.default[requestedParam]
+      if (valueToPopulate !== undefined) {
+        return Promise.resolve(valueToPopulate)
+      }
+    }
+  }
+
+  // If not found, return undefined (will trigger fallback if specified)
+  return Promise.resolve(valueToPopulate)
+}
+
+module.exports = {
+  type: 'param',
+  source: 'user',
+  syntax: '${param:paramName}',
+  description: 'Resolves parameter values from CLI flags, stage-specific params, or default params. Examples: ${param:domain}, ${param:key, "fallbackValue"}',
+  match: paramRefSyntax,
+  resolver: getValueFromParam
+}

package/src/resolvers/valueFromParam.test.js

@@ -0,0 +1,207 @@
+const { test } = require('uvu')
+const assert = require('uvu/assert')
+const { resolver } = require('./valueFromParam')
+
+test('Resolves parameter from CLI flag', async () => {
+  const options = { param: 'domain=myapp.com' }
+  const result = await resolver('param:domain', options)
+  assert.is(result, 'myapp.com')
+})
+
+test('Resolves parameter from multiple CLI flags', async () => {
+  const options = { param: ['domain=myapp.com', 'key=value'] }
+  const result = await resolver('param:key', options)
+  assert.is(result, 'value')
+})
+
+test('Resolves parameter with equals sign in value', async () => {
+  const options = { param: 'connectionString=Server=localhost;Port=5432' }
+  const result = await resolver('param:connectionString', options)
+  assert.is(result, 'Server=localhost;Port=5432')
+})
+
+test('Resolves parameter from stage-specific params', async () => {
+  const options = { stage: 'prod' }
+  const config = {
+    stages: {
+      prod: {
+        params: {
+          domain: 'production.myapp.com'
+        }
+      }
+    }
+  }
+  const result = await resolver('param:domain', options, config)
+  assert.is(result, 'production.myapp.com')
+})
+
+test('Resolves parameter from default stage params', async () => {
+  const options = { stage: 'dev' }
+  const config = {
+    stages: {
+      default: {
+        params: {
+          domain: 'default.myapp.com'
+        }
+      }
+    }
+  }
+  const result = await resolver('param:domain', options, config)
+  assert.is(result, 'default.myapp.com')
+})
+
+test('CLI params override stage params', async () => {
+  const options = {
+    stage: 'prod',
+    param: 'domain=cli-override.com'
+  }
+  const config = {
+    stages: {
+      prod: {
+        params: {
+          domain: 'production.myapp.com'
+        }
+      }
+    }
+  }
+  const result = await resolver('param:domain', options, config)
+  assert.is(result, 'cli-override.com')
+})
+
+test('Stage-specific params override default params', async () => {
+  const options = { stage: 'prod' }
+  const config = {
+    stages: {
+      default: {
+        params: {
+          domain: 'default.myapp.com'
+        }
+      },
+      prod: {
+        params: {
+          domain: 'production.myapp.com'
+        }
+      }
+    }
+  }
+  const result = await resolver('param:domain', options, config)
+  assert.is(result, 'production.myapp.com')
+})
+
+test('Returns undefined for non-existent parameter', async () => {
+  const options = { stage: 'dev' }
+  const config = { stages: { dev: { params: {} } } }
+  const result = await resolver('param:nonExistent', options, config)
+  assert.is(result, undefined)
+})
+
+test('Throws error for empty parameter name', async () => {
+  try {
+    await resolver('param:')
+    assert.unreachable('Should have thrown an error')
+  } catch (error) {
+    assert.ok(error.message.includes('Invalid variable syntax'))
+    assert.ok(error.message.includes('must have a key path'))
+  }
+})
+
+test('Defaults to dev stage when no stage specified', async () => {
+  const options = {}
+  const config = {
+    stages: {
+      dev: {
+        params: {
+          domain: 'dev.myapp.com'
+        }
+      }
+    }
+  }
+  const result = await resolver('param:domain', options, config)
+  assert.is(result, 'dev.myapp.com')
+})
+
+test('Supports top-level params property (backwards compatibility)', async () => {
+  const options = { stage: 'prod' }
+  const config = {
+    params: {
+      prod: {
+        domain: 'production.myapp.com'
+      }
+    }
+  }
+  const result = await resolver('param:domain', options, config)
+  assert.is(result, 'production.myapp.com')
+})
+
+test('Supports top-level params default property', async () => {
+  const options = { stage: 'dev' }
+  const config = {
+    params: {
+      default: {
+        domain: 'default.myapp.com'
+      }
+    }
+  }
+  const result = await resolver('param:domain', options, config)
+  assert.is(result, 'default.myapp.com')
+})
+
+test('Prefers stages property over params property', async () => {
+  const options = { stage: 'prod' }
+  const config = {
+    stages: {
+      prod: {
+        params: {
+          domain: 'stages.prod.myapp.com'
+        }
+      }
+    },
+    params: {
+      prod: {
+        domain: 'params.prod.myapp.com'
+      }
+    }
+  }
+  const result = await resolver('param:domain', options, config)
+  assert.is(result, 'stages.prod.myapp.com')
+})
+
+test('Returns Promise that resolves to value', async () => {
+  const options = { param: 'test=promise-value' }
+  const promise = resolver('param:test', options)
+  assert.ok(promise instanceof Promise)
+  const result = await promise
+  assert.is(result, 'promise-value')
+})
+
+test('Handles parameter with special characters in value', async () => {
+  const options = { param: 'special=value-with-special-chars-!@#$%' }
+  const result = await resolver('param:special', options)
+  assert.is(result, 'value-with-special-chars-!@#$%')
+})
+
+test('Handles empty string parameter value', async () => {
+  const options = { param: 'empty=' }
+  const result = await resolver('param:empty', options)
+  assert.is(result, '')
+})
+
+test('Handles numeric parameter value', async () => {
+  const options = { param: 'port=3000' }
+  const result = await resolver('param:port', options)
+  assert.is(result, '3000')
+})
+
+test('Handles parameter with underscore', async () => {
+  const options = { param: 'my_param=underscore-value' }
+  const result = await resolver('param:my_param', options)
+  assert.is(result, 'underscore-value')
+})
+
+test('Handles parameter with numbers', async () => {
+  const options = { param: 'param123=numeric-value' }
+  const result = await resolver('param:param123', options)
+  assert.is(result, 'numeric-value')
+})
+
+test.run()