configorama 0.9.5 → 0.9.11

package/src/parsers/hcl-parse-script.js

@@ -0,0 +1,40 @@
+#!/usr/bin/env node
+/**
+ * Standalone script to parse HCL content
+ * Used by hcl.js for synchronous parsing via child_process
+ */
+
+async function main() {
+  try {
+    const args = process.argv.slice(2)
+    const filename = args[0] || 'config.tf'
+    const contents = args[1] || ''
+
+    if (!contents) {
+      throw new Error('HCL content is required')
+    }
+
+    let hcl2json
+    try {
+      hcl2json = require('@cdktf/hcl2json')
+    } catch (err) {
+      if (err.code === 'MODULE_NOT_FOUND') {
+        throw new Error(
+          'HCL/Terraform file support requires "@cdktf/hcl2json" to be installed. ' +
+          'Please install it: npm install @cdktf/hcl2json'
+        )
+      }
+      throw err
+    }
+
+    const result = await hcl2json.parse(filename, contents)
+
+    // Output result as JSON
+    console.log(JSON.stringify(result))
+  } catch (error) {
+    console.error(JSON.stringify({ error: error.message }))
+    process.exit(1)
+  }
+}
+
+main()

package/src/parsers/hcl.js

@@ -1,3 +1,131 @@
-// TODO hashicorp HCL
-// https://www.npmjs.com/package/hcl-to-json
-// https://www.npmjs.com/package/hcl2json
+const YAML = require('./yaml')
+const JSON = require('./json5')
+
+/**
+ * Get the hcl2json module, throwing helpful error if not installed
+ * @returns {{ parse: Function }} The hcl2json module
+ * @throws {Error} If @cdktf/hcl2json is not installed
+ */
+function getHcl2Json() {
+  try {
+    return require('@cdktf/hcl2json')
+  } catch (err) {
+    if (err.code === 'MODULE_NOT_FOUND') {
+      throw new Error(
+        'HCL/Terraform file support requires "@cdktf/hcl2json" to be installed.\n' +
+        'Please install it:\n' +
+        '  npm install @cdktf/hcl2json'
+      )
+    }
+    throw err
+  }
+}
+
+/**
+ * Parse HCL content into JavaScript object
+ * Uses @cdktf/hcl2json to convert HCL to JSON
+ * @param {string} hclContents - HCL string to parse
+ * @param {string} [filename='config.tf'] - Filename for context
+ * @returns {Promise<Object>} Parsed HCL object
+ * @throws {Error} If HCL parsing fails
+ */
+async function parse(hclContents, filename = 'config.tf') {
+  let hclObject = {}
+  try {
+    const { parse: hclParse } = getHcl2Json()
+    const result = await hclParse(filename, hclContents)
+    hclObject = result
+  } catch (e) {
+    throw new Error(`Failed to parse HCL: ${e.message}`)
+  }
+  return hclObject
+}
+
+/**
+ * Synchronous HCL parsing using child process
+ * @param {string} hclContents - HCL string to parse
+ * @param {string} [filename='config.tf'] - Filename for context
+ * @returns {Object} Parsed HCL object
+ * @throws {Error} If HCL parsing fails
+ */
+function parseSync(hclContents, filename = 'config.tf') {
+  const { execFileSync } = require('child_process')
+  const scriptPath = require.resolve('./hcl-parse-script.js')
+
+  try {
+    const result = execFileSync(process.execPath, [scriptPath, filename, hclContents], {
+      encoding: 'utf8',
+      maxBuffer: 10 * 1024 * 1024  // 10MB buffer
+    })
+    return JSON.parse(result.trim())
+  } catch (error) {
+    // Check if error output contains JSON error
+    if (error.stderr) {
+      try {
+        const errorData = JSON.parse(error.stderr)
+        throw new Error(`Failed to parse HCL: ${errorData.error}`)
+      } catch (parseErr) {
+        // If stderr is not JSON, use original error
+        throw new Error(`Failed to parse HCL: ${error.message}`)
+      }
+    }
+    throw new Error(`Failed to parse HCL: ${error.message}`)
+  }
+}
+
+/**
+ * Convert JavaScript object to HCL string
+ * Note: HCL generation is complex and not fully supported
+ * This is a placeholder for potential future implementation
+ * @param {Object} object - Object to convert to HCL
+ * @returns {string} HCL string representation
+ * @throws {Error} Always throws - HCL generation not implemented
+ */
+function dump(object) {
+  throw new Error('HCL generation (dump) is not currently supported. HCL files can be read but not written.')
+}
+
+/**
+ * Convert HCL content to YAML format
+ * @param {string} hclContents - HCL string to convert
+ * @param {string} [filename='config.tf'] - Filename for context
+ * @returns {Promise<string>} YAML string representation
+ * @throws {Error} If conversion fails
+ */
+async function toYaml(hclContents, filename = 'config.tf') {
+  let yml
+  try {
+    const parsed = await parse(hclContents, filename)
+    yml = YAML.dump(parsed)
+  } catch (e) {
+    throw new Error(`Failed to convert HCL to YAML: ${e.message}`)
+  }
+  return yml
+}
+
+/**
+ * Convert HCL content to JSON format
+ * @param {string} hclContents - HCL string to convert
+ * @param {string} [filename='config.tf'] - Filename for context
+ * @returns {Promise<string>} JSON string representation
+ * @throws {Error} If conversion fails
+ */
+async function toJson(hclContents, filename = 'config.tf') {
+  let json
+  try {
+    const parsed = await parse(hclContents, filename)
+    json = JSON.dump(parsed)
+  } catch (e) {
+    throw new Error(`Failed to convert HCL to JSON: ${e.message}`)
+  }
+  return json
+}
+
+module.exports = {
+  parse: parseSync,  // Export sync version for compatibility with existing parsers
+  parseAsync: parse,  // Export async version for direct use
+  parseSync: parseSync,
+  dump: dump,
+  toYaml: toYaml,
+  toJson: toJson
+}

package/src/parsers/hcl.slow-test.js

@@ -0,0 +1,141 @@
+/* eslint-disable no-template-curly-in-string */
+const { test } = require('uvu')
+const assert = require('uvu/assert')
+const hcl = require('./hcl')
+const JSON5 = require('json5')
+const path = require('path')
+const fs = require('fs')
+
+function normalize(obj) {
+  return JSON.parse(JSON.stringify(obj))
+}
+
+test('hcl parse basic variable', async () => {
+  const hclContent = `variable "name" {
+  description = "Name to be used"
+  type = string
+  default = "test"
+}`
+  const result = hcl.parse(hclContent, 'test.tf')
+  console.log('basic result', JSON.stringify(result, null, 2))
+
+  assert.ok(result, 'result should exist')
+  assert.ok(result.variable, 'should have variable section')
+})
+
+test('hcl parse multiple variables', async () => {
+  const hclContent = `variable "region" {
+  description = "AWS region"
+  type = string
+  default = "us-east-1"
+}
+
+variable "count" {
+  description = "Number of instances"
+  type = number
+  default = 2
+}
+
+variable "enabled" {
+  description = "Feature flag"
+  type = bool
+  default = true
+}`
+  const result = hcl.parse(hclContent, 'test.tf')
+  console.log('multiple vars result', JSON.stringify(result, null, 2))
+
+  assert.ok(result, 'result should exist')
+  assert.ok(result.variable, 'should have variable section')
+})
+
+test('hcl parse with locals', async () => {
+  const hclContent = `variable "environment" {
+  type = string
+  default = "dev"
+}
+
+locals {
+  app_name = "myapp-\${var.environment}"
+}`
+  const result = hcl.parse(hclContent, 'test.tf')
+  console.log('locals result', JSON.stringify(result, null, 2))
+
+  assert.ok(result, 'result should exist')
+  assert.ok(result.variable || result.locals, 'should have variable or locals section')
+})
+
+test('hcl parse resource block', async () => {
+  const hclContent = `resource "aws_instance" "app" {
+  ami = "ami-12345678"
+  instance_type = "t3.micro"
+
+  tags = {
+    Name = "MyApp"
+    Environment = "dev"
+  }
+}`
+  const result = hcl.parse(hclContent, 'test.tf')
+  console.log('resource result', JSON.stringify(result, null, 2))
+
+  assert.ok(result, 'result should exist')
+  assert.ok(result.resource, 'should have resource section')
+})
+
+test('hcl parse from file - simple.tf', async () => {
+  const filePath = path.join(__dirname, '../../tests/hclTests/simple.tf')
+
+  // Skip if file doesn't exist
+  if (!fs.existsSync(filePath)) {
+    console.log('Skipping test - fixture file not found')
+    return
+  }
+
+  const contents = fs.readFileSync(filePath, 'utf8')
+  const result = hcl.parse(contents, 'simple.tf')
+  console.log('file parse result', JSON.stringify(result, null, 2))
+
+  assert.ok(result, 'result should exist')
+  assert.ok(result.variable, 'should have variable section')
+})
+
+test('hcl dump should throw error', () => {
+  let error
+  try {
+    hcl.dump({ foo: 'bar' })
+  } catch (e) {
+    error = e
+  }
+  assert.ok(error instanceof Error, 'should throw error')
+  assert.ok(error.message.includes('not currently supported'), 'error message should indicate not supported')
+})
+
+test('hcl toJson basic', async () => {
+  const hclContent = `variable "test" {
+  type = string
+  default = "value"
+}`
+
+  const result = await hcl.toJson(hclContent, 'test.tf')
+  console.log('toJson result', result)
+
+  assert.ok(result, 'result should exist')
+  assert.ok(typeof result === 'string', 'result should be string')
+
+  const parsed = JSON5.parse(result)
+  assert.ok(parsed, 'should be valid JSON5')
+})
+
+test('hcl toYaml basic', async () => {
+  const hclContent = `variable "test" {
+  type = string
+  default = "value"
+}`
+
+  const result = await hcl.toYaml(hclContent, 'test.tf')
+  console.log('toYaml result', result)
+
+  assert.ok(result, 'result should exist')
+  assert.ok(typeof result === 'string', 'result should be string')
+})
+
+test.run()

package/src/parsers/index.js

@@ -8,6 +8,7 @@ const json = require('./json5')
 const toml = require('./toml')
 const yaml = require('./yaml')
 const ini = require('./ini')
+const hcl = require('./hcl')
 
 /**
  * Collection of format parsers for different config file types
@@ -17,5 +18,6 @@ module.exports = {
   json: json,
   toml: toml,
   yaml: yaml,
-  ini: ini
+  ini: ini,
+  hcl: hcl
 }

package/src/parsers/typescript.js

@@ -55,11 +55,6 @@ async function executeTypeScriptFile(filePath, opts = {}) {
     }
   }
 
-  // Handle ES module default exports
-  if (tsFile && typeof tsFile === 'object' && 'default' in tsFile) {
-    tsFile = tsFile.default
-  }
-
   return tsFile
 }
 
@@ -117,11 +112,6 @@ function executeTypeScriptFileSync(filePath, opts = {}) {
     }
   }
 
-  // Handle ES module default exports
-  if (tsFile && typeof tsFile === 'object' && 'default' in tsFile) {
-    tsFile = tsFile.default
-  }
-
   return tsFile
 }
 

package/src/resolvers/valueFromEval.js

@@ -1,29 +1,86 @@
 // const evalRefSyntax = RegExp(/^eval\((~?[\{\}\:\${}a-zA=>+!-Z0-9._\-\/,'"\*\` ]+?)?\)/g)
 const evalRefSyntax = RegExp(/^eval\((.*)?\)/g)
+const { replaceOutsideQuotes } = require('../utils/strings/quoteAware')
+
+// Pattern for encoded objects/arrays: __OBJ:base64__ or __ARR:base64__
+const ENCODED_PATTERN = /__(?:OBJ|ARR):([A-Za-z0-9+/=]+)__/g
+
+// Encode object/array for embedding in eval expressions
+function encodeValue(value) {
+  const prefix = Array.isArray(value) ? 'ARR' : 'OBJ'
+  const encoded = Buffer.from(JSON.stringify(value)).toString('base64')
+  return `__${prefix}:${encoded}__`
+}
+
+// Decode encoded values and build context for subscript
+function decodeValues(expression) {
+  const context = {}
+  let idx = 0
+
+  const processed = expression.replace(ENCODED_PATTERN, (match, base64) => {
+    const decoded = JSON.parse(Buffer.from(base64, 'base64').toString('utf8'))
+    const placeholder = `__VAL${idx}__`
+    context[`__VAL${idx}__`] = decoded
+    idx++
+    return placeholder
+  })
+
+  return { processed, context }
+}
+
+// Wrap individual comparisons in parentheses for correct precedence with && / ||
+// Subscript has operator precedence issues without explicit parens
+function wrapComparisons(expr) {
+  if (!/&&|\|\|/.test(expr)) return expr
+
+  // Match comparisons: value op value (where op is ===, !==, ==, !=, >=, <=, >, <)
+  // Values can be: quoted strings, numbers, identifiers, or __VAL0__ placeholders
+  const compPattern = /((?:"[^"]*"|'[^']*'|__VAL\d+__|__NULL__|[a-zA-Z_][a-zA-Z0-9_]*|[\d.]+))\s*(===|!==|==|!=|>=|<=|>|<)\s*((?:"[^"]*"|'[^']*'|__VAL\d+__|__NULL__|[a-zA-Z_][a-zA-Z0-9_]*|[\d.]+))/g
+
+  return expr.replace(compPattern, '($1 $2 $3)')
+}
 
 async function getValueFromEval(variableString) {
-  // console.log('getValueFromEval variableString', variableString)
-  // console.log('getValueFromEval variableString', variableString)
   // Extract the expression inside eval()
   const match = variableString.match(/^eval\((.+)\)$/)
-  // console.log('match', match)
   if (!match) {
     throw new Error(`Invalid eval syntax: ${variableString}. Expected format: eval(expression)`)
   }
-  
+
   const expression = match[1].trim()
-  // console.log('expression', expression)
-  
+  if (process.env.DEBUG_EVAL) console.log('eval expression:', expression)
+
   // Use "justin" variant to support strict comparison (===, !==) and other JS-like operators
   try {
     const { default: subscript } = await import('subscript/justin')
-    
+
     // Handle string comparisons by ensuring both sides are quoted
-    const processedExpression = expression.replace(/([a-zA-Z0-9_]+)\s*([=!<>]=?)\s*['"]([^'"]+)['"]/g, '"$1"$2"$3"')
-    
-    // console.log('processedExpression', processedExpression)
+    let processedExpression = expression.replace(/([a-zA-Z0-9_]+)\s*([=!<>]=?)\s*['"]([^'"]+)['"]/g, '"$1"$2"$3"')
+
+    // Decode any encoded objects/arrays
+    const { processed: withDecodedValues, context: valueContext } = decodeValues(processedExpression)
+    processedExpression = withDecodedValues
+
+    // Workaround: subscript doesn't handle null keyword correctly
+    // Replace null with placeholder and inject via context (but not inside quoted strings)
+    const hasNull = /\bnull\b/.test(processedExpression)
+    if (hasNull) {
+      processedExpression = replaceOutsideQuotes(processedExpression, 'null', '__NULL__')
+    }
+
+    // Build context with null and any decoded values
+    /** @type {Record<string, unknown>} */
+    const context = { ...valueContext }
+    if (hasNull) {
+      context.__NULL__ = null
+    }
+
+    // Wrap comparisons in parens for correct precedence with && / ||
+    processedExpression = wrapComparisons(processedExpression)
+
+    if (process.env.DEBUG_EVAL) console.log('eval processed:', processedExpression)
     const fn = subscript(processedExpression)
-    const result = fn()
+    const result = fn(Object.keys(context).length > 0 ? context : undefined)
     return result
   } catch (error) {
     throw new Error(`Error evaluating expression "${expression}": ${error.message}`)
@@ -33,6 +90,7 @@ async function getValueFromEval(variableString) {
 module.exports = {
   type: 'eval',
   source: 'readonly',
+  encodeValue,
   description: '${eval(expression)} - Evaluates mathematical expressions',
   match: evalRefSyntax,
   resolver: getValueFromEval

package/src/resolvers/valueFromFile.js

@@ -14,6 +14,34 @@ const YAML = require('../parsers/yaml')
 const TOML = require('../parsers/toml')
 const INI = require('../parsers/ini')
 const JSON5 = require('../parsers/json5')
+const HCL = require('../parsers/hcl')
+
+/**
+ * Convert HCL $[...] syntax to the main config's variable syntax
+ * This allows configorama variables in .tf files to work when imported from other formats
+ * @param {*} obj - Object to convert
+ * @param {string} varPrefix - Variable prefix (e.g., '${')
+ * @param {string} varSuffix - Variable suffix (e.g., '}')
+ * @returns {*} Converted object
+ */
+function convertHclVarSyntax(obj, varPrefix, varSuffix) {
+  if (!obj) return obj
+  if (typeof obj === 'string') {
+    // Convert $[...] to the main config's syntax (e.g., ${...})
+    return obj.replace(/\$\[([^\]]+)\]/g, `${varPrefix}$1${varSuffix}`)
+  }
+  if (Array.isArray(obj)) {
+    return obj.map(item => convertHclVarSyntax(item, varPrefix, varSuffix))
+  }
+  if (typeof obj === 'object') {
+    const converted = {}
+    for (const key of Object.keys(obj)) {
+      converted[key] = convertHclVarSyntax(obj[key], varPrefix, varSuffix)
+    }
+    return converted
+  }
+  return obj
+}
 
 /**
  * Recursively clean encoded JSON from an object
@@ -78,6 +106,8 @@ function parseFileContents(content, filePath) {
  * @param {Function} ctx.getDeeperValue - Method for nested lookups
  * @param {RegExp} ctx.fileRefSyntax - Regex for file() syntax
  * @param {RegExp} ctx.textRefSyntax - Regex for text() syntax
+ * @param {string} ctx.varPrefix - Variable prefix (e.g., '${')
+ * @param {string} ctx.varSuffix - Variable suffix (e.g., '}')
  * @param {string} variableString - The variable string to resolve
  * @param {object} options - Resolution options
  * @returns {Promise<any>}
@@ -228,7 +258,7 @@ ${JSON.stringify(options.context, null, 2)}`,
 
   /* handle case for referencing raw JS files to inline them */
   if (argsToPass.length
-    && (argsToPass && argsToPass[0] && argsToPass[0].toLowerCase() === 'raw')
+    && (argsToPass && argsToPass[0] && typeof argsToPass[0] === 'string' && argsToPass[0].toLowerCase() === 'raw')
     || opts.asRawText
   ) {
     // Encode foo() to foo__PH_PAREN_OPEN__) to avoid function collisions
@@ -365,6 +395,19 @@ ${JSON.stringify(options.context, null, 2)}`,
       if (fileExtension === 'ini') {
         valueToPopulate = INI.toJson(valueToPopulate)
       }
+      if (fileExtension === 'tf' || fileExtension === 'hcl') {
+        // Parse HCL and convert $[...] to main config's syntax for variable resolution
+        const parsed = convertHclVarSyntax(HCL.parse(valueToPopulate, relativePath), ctx.varPrefix, ctx.varSuffix)
+        valueToPopulate = JSON.stringify(parsed)
+      }
+      if (fileExtension === 'json' || fileExtension === 'json5') {
+        let parsed = JSON5.parse(valueToPopulate)
+        // Convert $[...] to main config's syntax for .tf.json files
+        if (relativePath.endsWith('.tf.json')) {
+          parsed = convertHclVarSyntax(parsed, ctx.varPrefix, ctx.varSuffix)
+        }
+        valueToPopulate = JSON.stringify(parsed)
+      }
       // console.log('deep', variableString)
       // console.log('matchedFileString', matchedFileString)
       const deepPropertiesStr = variableString.replace(matchedFileString, '')
@@ -396,6 +439,16 @@ Please use ":" or "." to reference sub properties. ${deepPropertiesStr}`
 
     if (fileExtension === 'json' || fileExtension === 'json5') {
       valueToPopulate = JSON5.parse(valueToPopulate)
+      // Convert $[...] to main config's syntax for .tf.json files (Terraform JSON format)
+      if (relativePath.endsWith('.tf.json')) {
+        valueToPopulate = convertHclVarSyntax(valueToPopulate, ctx.varPrefix, ctx.varSuffix)
+      }
+      return Promise.resolve(valueToPopulate)
+    }
+
+    if (fileExtension === 'tf' || fileExtension === 'hcl') {
+      // Parse HCL and convert $[...] to main config's syntax for variable resolution
+      valueToPopulate = convertHclVarSyntax(HCL.parse(valueToPopulate, relativePath), ctx.varPrefix, ctx.varSuffix)
       return Promise.resolve(valueToPopulate)
     }
   }

package/src/resolvers/valueFromIf.js

@@ -0,0 +1,75 @@
+/* ${if(...)} syntax - alias for eval() with more intuitive name for conditionals */
+const { resolver: evalResolver } = require('./valueFromEval')
+const { findOutsideQuotes } = require('../utils/strings/quoteAware')
+
+// Match both:
+//   if(condition ? trueVal : falseVal)  - ternary inside
+//   if(condition) ? trueVal : falseVal  - ternary outside
+const ifRefSyntax = RegExp(/^if\s*\(.*\)(\s*\?.*)?/g)
+
+async function getValueFromIf(variableString) {
+  if (process.env.DEBUG_IF) console.log('if resolver input:', variableString)
+
+  // Validate: check for empty condition
+  const emptyConditionMatch = variableString.match(/^if\s*\(\s*\)/)
+  if (emptyConditionMatch) {
+    throw new Error('Empty condition in ${if()}. Expected: ${if(condition) ? trueVal : falseVal}')
+  }
+
+  // Check for external ternary: if(condition) ? trueVal : falseVal
+  // Must properly balance parentheses to find where if() ends
+  const match = variableString.match(/^if\s*\(/)
+  if (match) {
+    const afterIf = variableString.substring(match[0].length)
+    let depth = 1
+    let i = 0
+
+    // Find the matching closing paren
+    while (i < afterIf.length && depth > 0) {
+      if (afterIf[i] === '(') depth++
+      else if (afterIf[i] === ')') depth--
+      if (depth > 0) i++
+    }
+
+    if (depth === 0) {
+      // Check what comes after the if() block
+      const afterCondition = afterIf.substring(i + 1).trim()
+
+      if (afterCondition.startsWith('?')) {
+        // External ternary: if(condition) ? trueVal : falseVal
+        const condition = afterIf.substring(0, i)
+        const ternaryPart = afterCondition.substring(1).trim() // after ?
+
+        // Find the colon separating trueVal and falseVal (outside quotes and encoded patterns)
+        const colonIdx = findOutsideQuotes(ternaryPart, (str, idx) => {
+          if (str[idx] !== ':') return 0
+          // Skip colons inside encoded patterns __OBJ:...__ or __ARR:...__
+          const before = str.substring(0, idx)
+          if (/__(?:OBJ|ARR|VAL\d+)$/.test(before)) return 0
+          return 1
+        })
+
+        if (colonIdx !== -1) {
+          const trueVal = ternaryPart.substring(0, colonIdx).trim()
+          const falseVal = ternaryPart.substring(colonIdx + 1).trim()
+          const expression = `(${condition}) ? ${trueVal} : ${falseVal}`
+          if (process.env.DEBUG_IF) console.log('if resolver external ternary:', expression)
+          return evalResolver(`eval(${expression})`)
+        }
+      }
+    }
+  }
+
+  // Standard syntax: if(condition ? trueVal : falseVal) or if(boolExpr)
+  const converted = variableString.replace(/^if\s*\(/, 'eval(')
+  if (process.env.DEBUG_IF) console.log('if resolver standard syntax:', converted)
+  return evalResolver(converted)
+}
+
+module.exports = {
+  type: 'if',
+  source: 'readonly',
+  description: '${if(condition) ? "yes" : "no"} - Conditional expressions',
+  match: ifRefSyntax,
+  resolver: getValueFromIf
+}

package/src/resolvers/valueFromIf.test.js

@@ -0,0 +1,66 @@
+/* Tests for ${if(...)} syntax - alias for eval */
+const { test } = require('uvu')
+const assert = require('uvu/assert')
+const configorama = require('../../src')
+
+test('if() basic ternary', async () => {
+  const result = await configorama({
+    yes: '${if(5 > 3 ? "yes" : "no")}',
+    no: '${if(3 > 5 ? "yes" : "no")}'
+  })
+  assert.is(result.yes, 'yes')
+  assert.is(result.no, 'no')
+})
+
+test('if() with parentheses around condition', async () => {
+  const result = await configorama({
+    result: '${if((10 < 20) ? "smaller" : "bigger")}'
+  })
+  assert.is(result.result, 'smaller')
+})
+
+test('if() boolean result', async () => {
+  const result = await configorama({
+    isTrue: '${if(10 == 10)}',
+    isFalse: '${if(10 == 5)}'
+  })
+  assert.is(result.isTrue, true)
+  assert.is(result.isFalse, false)
+})
+
+test('if() with variables', async () => {
+  const result = await configorama({
+    threshold: 50,
+    value: 75,
+    status: '${if(${self:value} > ${self:threshold} ? "above" : "below")}'
+  })
+  assert.is(result.status, 'above')
+})
+
+test('if() nested ternary', async () => {
+  const result = await configorama({
+    score: 85,
+    grade: '${if(${self:score} >= 90 ? "A" : ${self:score} >= 80 ? "B" : "C")}'
+  })
+  assert.is(result.grade, 'B')
+})
+
+test('if() with logical operators', async () => {
+  const result = await configorama({
+    both: '${if(true && true)}',
+    either: '${if(false || true)}',
+    neither: '${if(false && false)}'
+  })
+  assert.is(result.both, true)
+  assert.is(result.either, true)
+  assert.is(result.neither, false)
+})
+
+test('if() arithmetic in condition', async () => {
+  const result = await configorama({
+    result: '${if((5 + 5) > 8 ? "big" : "small")}'
+  })
+  assert.is(result.result, 'big')
+})
+
+test.run()