configorama 0.9.3 → 0.9.8

package/README.md

@@ -2,7 +2,7 @@
 
 Dynamic configuration values with variable support.
 
-Works with `yml`, `json`, `toml` config formats and anything that parsed down to a plain ol' javascript object
+Works with `yml`, `json`, `toml`, `hcl` (Terraform), and other config formats. Supports any format that can be parsed to a plain JavaScript object
 
 ## About
 
@@ -98,7 +98,7 @@ Configorama creates a graph of your config file and all its dependencies, then i
 
 ```mermaid
 flowchart TD
-    A[Load config file] --> B[Parse yml/json/toml to object]
+    A[Load config file] --> B[Parse yml/json/toml/hcl to object]
     B --> C[Preprocess: raw config file]
     C --> D{Return metadata only?}
     D -->|Yes| E[Collect variable metadata]
@@ -253,10 +253,10 @@ three: ${zaz.wow.cool} # Resolves to `2`
 
 ### File references
 
-Import values from external yml, json, or toml files by relative path.
+Import values from external yml, json, toml, or hcl files by relative path.
 
 ```yml
-# Import full yml/json/toml file via relative path
+# Import full yml/json/toml/hcl file via relative path
 fileRef: ${file(./subFile.yml)}
 
 # Import sub values from files. This imports other-config.yml `topLevel:` value
@@ -279,7 +279,7 @@ Supported file types (extensions are case-insensitive):
 | YAML | `.yml`, `.yaml` |
 | TOML | `.toml`, `.tml` |
 | INI | `.ini` |
-| JSON | `.json`, `.json5` |
+| JSON | `.json`, `.json5`, `.jsonc` |
 
 ### Sync/Async file references
 
@@ -533,6 +533,74 @@ npm install ts-node typescript --save-dev
 - Full TypeScript interface support
 - Comprehensive error handling with helpful dependency messages
 
+### Terraform HCL support
+
+Configorama supports Terraform HCL (HashiCorp Configuration Language) files, allowing you to parse `.tf`, `.tf.json`, and `.hcl` files.
+
+**Installation:**
+
+HCL parsing requires the optional `@cdktf/hcl2json` package:
+
+```bash
+npm install @cdktf/hcl2json
+```
+
+**Supported file types:**
+- `.tf` - Terraform configuration files
+- `.hcl` - Generic HCL files
+- `.tf.json` - Terraform JSON configuration files
+
+**Example:**
+
+```js
+const configorama = require('configorama')
+
+// Parse a Terraform configuration file
+const terraformConfig = await configorama('./main.tf')
+
+// Access Terraform variables, resources, locals, etc.
+console.log(terraformConfig.variable)  // Variables defined in the file
+console.log(terraformConfig.resource)  // Resources
+console.log(terraformConfig.locals)    // Local values
+console.log(terraformConfig.output)    // Outputs
+```
+
+**Importing Terraform files:**
+
+```yml
+# Import Terraform variables from a .tf file
+terraformVars: ${file(./terraform/variables.tf)}
+
+# Import specific variable from Terraform file
+region: ${file(./terraform/variables.tf):variable.region[0].default}
+```
+
+**Variable syntax:**
+When loading `.tf` or `.hcl` files directly, configorama automatically uses `$[...]` syntax instead of `${...}` to avoid conflicts with Terraform's native `${var.name}` interpolation. Terraform expressions like `${var.environment}` and `${map(string)}` are preserved as-is.
+
+```js
+// Loading .tf directly - uses $[...] syntax automatically
+const config = await configorama('./main.tf')
+// config.locals[0].app_name = "myapp-${var.environment}" (preserved)
+
+// Use $[...] for configorama variables in .tf files
+// myvar: $[env:MY_VAR]
+// myref: $[file(./other.yml)]  # referenced files also use $[...]
+```
+
+When importing `.tf` files from other config formats (yml, json, etc.) via `${file()}`, the parent file's syntax applies. Use `allowUnknownVariableTypes: true` if the imported `.tf` contains Terraform interpolations:
+
+```js
+const config = await configorama('./config.yml', {
+  allowUnknownVariableTypes: true
+})
+```
+
+**Read-only support:**
+Currently, HCL files can be read and parsed, but writing/generating HCL files is not supported.
+
+See [tests/hclTests](./tests/hclTests) for example Terraform files.
+
 ### Git references
 
 Access repository information from the current working directory's git data.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "configorama",
-  "version": "0.9.3",
+  "version": "0.9.8",
   "description": "Variable support for configuration files",
   "main": "src/index.js",
   "types": "index.d.ts",
@@ -25,10 +25,11 @@
     "info": "repomix --include \"cli.js,src/**/*.js\" --ignore \"**/*.test.js\" --copy",
     "docs": "node ./scripts/docs.js",
     "t": "./scripts/run-tests.sh",
-    "test": "npm run test:lib && uvu tests \".*\\.test.js$\" ",
+    "test": "npm run test:slow && npm run test:lib && uvu tests \".*\\.test.js$\"",
     "test:tests": "uvu tests \".*\\.test.js$\" ",
     "test:api": "uvu tests/api api.test.js",
     "test:lib": "uvu src \".*\\.test.js$\"",
+    "test:slow": "uvu src \".*\\.slow-test.js$\" && uvu tests \".*\\.slow-test.js$\"",
     "watch": "watchlist tests -- npm test",
     "typecheck": "tsc --noEmit",
     "types": "tsc",
@@ -84,11 +85,28 @@
     "traverse": "^0.6.8"
   },
   "devDependencies": {
+    "@cdktf/hcl2json": "^0.21.0",
     "@types/node": "^24.10.1",
     "markdown-magic": "^3.4.0",
     "tsx": "^4.7.0",
     "typescript": "^5.8.3",
     "uvu": "^0.5.6",
     "watchlist": "^0.3.1"
+  },
+  "peerDependencies": {
+    "@cdktf/hcl2json": ">=0.20.0",
+    "tsx": ">=4.0.0",
+    "ts-node": ">=10.0.0"
+  },
+  "peerDependenciesMeta": {
+    "@cdktf/hcl2json": {
+      "optional": true
+    },
+    "tsx": {
+      "optional": true
+    },
+    "ts-node": {
+      "optional": true
+    }
   }
 }

package/src/main.js

@@ -158,17 +158,25 @@ class Configorama {
     // Track variable resolutions for metadata (keyed by path)
     this.resolutionTracking = {}
 
-    const defaultSyntax = buildVariableSyntax('${', '}', ['AWS', 'stageVariables'])
+    // Detect file type early to determine default syntax
+    let detectedFileType = null
+    if (typeof fileOrObject === 'string') {
+      detectedFileType = path.extname(fileOrObject).toLowerCase()
+    }
+
+    // Use $[...] syntax for HCL/Terraform files to avoid conflicts with Terraform's ${} syntax
+    const isHclFile = detectedFileType === '.tf' || detectedFileType === '.hcl'
+    const defaultSyntax = isHclFile
+      ? buildVariableSyntax('$[', ']', ['AWS', 'stageVariables'])
+      : buildVariableSyntax('${', '}', ['AWS', 'stageVariables'])
 
     const varSyntax = options.syntax || defaultSyntax
     let varRegex
     if (typeof varSyntax === 'string') {
       varRegex = new RegExp(varSyntax, 'g')
-      // this.variableSyntax = /\${((?!AWS)([ ~:a-zA-Z0-9=+!@#%*<>?._'",|\-\/\(\)\\]+?|(\w+)\s*\(((?:[^()]+)*)?\s*\)\s*))}/
     } else if (varSyntax instanceof RegExp) {
       varRegex = varSyntax
     }
-    // console.log('varRegex', varRegex)
     const variableSyntax = varRegex
     this.variableSyntax = variableSyntax
 
@@ -1255,8 +1263,8 @@ class Configorama {
   Config error:\n
   Path "${configValuePath}" resolved to "undefined".\n
   Verify the ${varDisplay} in config at "${configValuePath}".\n
-  ${leaf ? `See:\n  ${leaf.originalValuePath}: ${leaf.originalSource} ` : ''}
-  ${leaf && leaf.isFileRef ? `\n  The error could be deeper in the referenced file at ${configValuePath.replace(leaf.originalValuePath, '').replace(/^\./, '')} key.\n` : ''}`
+  ${leaf ? `See:\n  ${configValuePath}: ${leaf.originalSource} ` : ''}
+  ${leaf && leaf.isFileRef ? `\n  The error could be deeper in the referenced file at ${configValuePath.replace(leaf.originalValuePath || configValuePath, '').replace(/^\./, '')} key.\n` : ''}`
                 throw new Error(errorMessage)
               }
               if (typeof rawValue === 'string') {
@@ -3298,7 +3306,9 @@ Missing Value ${missingValue} - ${matchedString}
       config: this.config,
       getDeeperValue: this.getDeeperValue.bind(this),
       fileRefSyntax: fileRefSyntax,
-      textRefSyntax: textRefSyntax
+      textRefSyntax: textRefSyntax,
+      varPrefix: this.varPrefix,
+      varSuffix: this.varSuffix
     }
     return getValueFromFileResolver(ctx, variableString, options)
   }

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/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>}
@@ -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/utils/parsing/parse.js

@@ -5,6 +5,7 @@ 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')
 const { executeTypeScriptFileSync } = require('../../parsers/typescript')
 const { executeESMFileSync } = require('../../parsers/esm')
 const cloudFormationSchema = require('./cloudformationSchema')
@@ -54,8 +55,17 @@ function parseFileContents({ contents, filePath, varRegex, dynamicArgs }) {
     configObject = TOML.parse(contents)
   } else if (fileType.match(/\.(ini)/i)) {
     configObject = INI.parse(contents)
-  } else if (fileType.match(/\.(json|json5)/i)) {
+  } else if (fileType.match(/\.(json|json5|jsonc)/i)) {
     configObject = JSON5.parse(contents)
+  } else if (fileType.match(/\.(tf|hcl)$/i) || filePath.match(/\.tf\.json$/i)) {
+    // Handle Terraform HCL files (.tf, .hcl) and Terraform JSON (.tf.json)
+    if (filePath.match(/\.tf\.json$/i)) {
+      // .tf.json files are just JSON
+      configObject = JSON5.parse(contents)
+    } else {
+      // .tf and .hcl files need HCL parsing
+      configObject = HCL.parse(contents, path.basename(filePath))
+    }
   // TODO detect js syntax and use appropriate parser
   } else if (fileType.match(/\.(js|cjs)/i)) {
     let jsFile

package/src/utils/validation/warnIfNotFound.js

@@ -4,7 +4,7 @@
 const isEmpty = require('lodash.isempty')
 
 function isValidValue(val) {
-  if (typeof val === 'object' && (val.hasOwnProperty('__internal_only_flag') || val.hasOwnProperty('__internal_metadata'))) {
+  if (val !== null && typeof val === 'object' && (val.hasOwnProperty('__internal_only_flag') || val.hasOwnProperty('__internal_metadata'))) {
     return false
   }
   return val !== null && typeof val !== 'undefined' && !(typeof val === 'object' && isEmpty(val))

package/types/src/main.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../../src/main.js"],"names":[],"mappings":";AA0GA;IACE,0CA6bC;IArbC,cAcW;IAuBX,gBAAqB;IAErB,sBAAwB;IACxB,qBAAuB;IAGvB,uBAA4B;IAc5B,uBAAoC;IAIpC,kBAAqC;IACrC,kBAAqC;IAErC,yBAA+F;IAC/F,yBAAuD;IACvD,kCAAyE;IAKvE,YAA0B;IAE1B,oBAA6C;IAE7C,gBAAoD;IAOpD,uBAAkC;IAElC,uBAA8B;IAE9B,uBAAkC;IASpC,wBAAmC;IAGnC,mBA8GC;IAwED,4BAA8C;IAO9C,aA2EC;IAUD,oBAEC;IAGD,eAkDC;IAOD,YAAc;IACd,cAAgB;IAChB,kBAAkB;IAGpB;;;;OAIG;IACH,0BAHW,MAAM,GACJ,OAAO,CAQnB;IAED;;;;OAIG;IACH,6BAHW,MAAM,GACJ,MAAM,GAAC,IAAI,CAOvB;IAED;;;;OAIG;IACH,gCAHW,MAAM,GACJ,OAAO,CAoBnB;IAKD;;;;;OAKG;IACH,oBAFa,OAAO,CAAC,GAAG,CAAC,CAqsBxB;IAlsBC,aAA4B;IAc1B,2BAA4B;IAQ5B,uBAAgD;IA8qBpD;;;OAGG;IACH,2BAFa,MAAM,CA8alB;IAvBC;;;;;;;;;;;;;;;MAoBC;IAIH;;;;OAIG;IACH,uCAFa,OAAO,CAAC,GAAG,CAAC,CAIxB;IACD,+CAsBC;IAKD;;;;;;;;;;;;;;;;;;;OAmBG;IACH;;;;;;;;;;;OAWG;IACH,mFAHa;;;;cAZC,QAAQ;;;;eACR,IAAI,GAAC,MAAM,SAAO;OAWD,CA+D9B;IACD;;;OAGG;IACH;;;;;OAKG;IACH,oCAHa,OAAO,CAAC;;;;cAnFP,QAAQ;;;;eACR,IAAI,GAAC,MAAM,SAAO;OAkFgB,CAAC,EAAE,CA6BlD;IACD;;;;;OAKG;IACH,iDAFa,OAAO,CAAC,IAAI,CAAC,CAWzB;IAID;;;;;OAKG;IACH;;;;OAIG;IACH,2BAFa,eAAc;;;;;;;;;;OAAa,CAavC;IACD;;;;;OAKG;IACH,yBAHW;;;;;;;;;;OAAa,gCACX,cAAS,CAOrB;IACD;;;;;;OAMG;IACH,6DAFa,GAAC,CA+Kb;IAKD;;;;;;;OAOG;IACH,yDAHa,OAAO,CAAC,GAAG,CAAC,CAiCxB;IACD;;;;OAIG;IAOH;;;;;;OAMG;IACH,wFA2BC;IACD;;;;;;;;;;;OAWG;IACH,8BARG;QAAyB,KAAK,EAAtB,GAAG;QACoB,IAAI,GAA3B,MAAM,EAAE;QACa,cAAc,GAAnC,MAAM;QACc,iBAAiB;KAC7C,6CAEU;QAAC,KAAK,EAAE,GAAG,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;QAAC,cAAc,CAAC,EAAE,MAAM,CAAC;QAAC,iBAAiB,CAAC,QAAQ;QAAC,oBAAoB,CAAC,EAAE,OAAO,CAAC;QAAC,MAAM,CAAC,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,CAAA;KAAC,CAmY9J;IAID;;;;;;;;OAQG;IACH,qEAHa,OAAO,CAAC,GAAG,CAAC,CAoExB;IAKD;;;;;;;OAOG;IACH,0FAFa,OAAO,CAAC,GAAG,CAAC,CA6gBxB;IACD,+EA+BC;IACD,yDAeC;IACD,oEA6BC;IAKD,8CAQC;IACD,kDAyBC;IACD;;;;;;;;;;;;;OAaG;IACH,wEAoDC;IAKD,4BAOC;IACD,sCA2DC;CACF"}
+{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../../src/main.js"],"names":[],"mappings":";AA0GA;IACE,0CAqcC;IA7bC,cAcW;IAuBX,gBAAqB;IAErB,sBAAwB;IACxB,qBAAuB;IAGvB,uBAA4B;IAsB5B,uBAAoC;IAIpC,kBAAqC;IACrC,kBAAqC;IAErC,yBAA+F;IAC/F,yBAAuD;IACvD,kCAAyE;IAKvE,YAA0B;IAE1B,oBAA6C;IAE7C,gBAAoD;IAOpD,uBAAkC;IAElC,uBAA8B;IAE9B,uBAAkC;IASpC,wBAAmC;IAGnC,mBA8GC;IAwED,4BAA8C;IAO9C,aA2EC;IAUD,oBAEC;IAGD,eAkDC;IAOD,YAAc;IACd,cAAgB;IAChB,kBAAkB;IAGpB;;;;OAIG;IACH,0BAHW,MAAM,GACJ,OAAO,CAQnB;IAED;;;;OAIG;IACH,6BAHW,MAAM,GACJ,MAAM,GAAC,IAAI,CAOvB;IAED;;;;OAIG;IACH,gCAHW,MAAM,GACJ,OAAO,CAoBnB;IAKD;;;;;OAKG;IACH,oBAFa,OAAO,CAAC,GAAG,CAAC,CAqsBxB;IAlsBC,aAA4B;IAc1B,2BAA4B;IAQ5B,uBAAgD;IA8qBpD;;;OAGG;IACH,2BAFa,MAAM,CA8alB;IAvBC;;;;;;;;;;;;;;;MAoBC;IAIH;;;;OAIG;IACH,uCAFa,OAAO,CAAC,GAAG,CAAC,CAIxB;IACD,+CAsBC;IAKD;;;;;;;;;;;;;;;;;;;OAmBG;IACH;;;;;;;;;;;OAWG;IACH,mFAHa;;;;cAZC,QAAQ;;;;eACR,IAAI,GAAC,MAAM,SAAO;OAWD,CA+D9B;IACD;;;OAGG;IACH;;;;;OAKG;IACH,oCAHa,OAAO,CAAC;;;;cAnFP,QAAQ;;;;eACR,IAAI,GAAC,MAAM,SAAO;OAkFgB,CAAC,EAAE,CA6BlD;IACD;;;;;OAKG;IACH,iDAFa,OAAO,CAAC,IAAI,CAAC,CAWzB;IAID;;;;;OAKG;IACH;;;;OAIG;IACH,2BAFa,eAAc;;;;;;;;;;OAAa,CAavC;IACD;;;;;OAKG;IACH,yBAHW;;;;;;;;;;OAAa,gCACX,cAAS,CAOrB;IACD;;;;;;OAMG;IACH,6DAFa,GAAC,CA+Kb;IAKD;;;;;;;OAOG;IACH,yDAHa,OAAO,CAAC,GAAG,CAAC,CAiCxB;IACD;;;;OAIG;IAOH;;;;;;OAMG;IACH,wFA2BC;IACD;;;;;;;;;;;OAWG;IACH,8BARG;QAAyB,KAAK,EAAtB,GAAG;QACoB,IAAI,GAA3B,MAAM,EAAE;QACa,cAAc,GAAnC,MAAM;QACc,iBAAiB;KAC7C,6CAEU;QAAC,KAAK,EAAE,GAAG,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;QAAC,cAAc,CAAC,EAAE,MAAM,CAAC;QAAC,iBAAiB,CAAC,QAAQ;QAAC,oBAAoB,CAAC,EAAE,OAAO,CAAC;QAAC,MAAM,CAAC,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,CAAA;KAAC,CAmY9J;IAID;;;;;;;;OAQG;IACH,qEAHa,OAAO,CAAC,GAAG,CAAC,CAoExB;IAKD;;;;;;;OAOG;IACH,0FAFa,OAAO,CAAC,GAAG,CAAC,CA6gBxB;IACD,+EA+BC;IACD,yDAiBC;IACD,oEA6BC;IAKD,8CAQC;IACD,kDAyBC;IACD;;;;;;;;;;;;;OAaG;IACH,wEAoDC;IAKD,4BAOC;IACD,sCA2DC;CACF"}

package/types/src/parsers/hcl-parse-script.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=hcl-parse-script.d.ts.map

package/types/src/parsers/hcl-parse-script.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hcl-parse-script.d.ts","sourceRoot":"","sources":["../../../src/parsers/hcl-parse-script.js"],"names":[],"mappings":""}

package/types/src/parsers/hcl.d.ts

@@ -1 +1,44 @@
+/**
+ * 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
+ */
+export function parseSync(hclContents: string, filename?: string): any;
+/**
+ * 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
+ */
+declare function parse(hclContents: string, filename?: string): Promise<any>;
+/**
+ * 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
+ */
+export function dump(object: any): string;
+/**
+ * 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
+ */
+export function toYaml(hclContents: string, filename?: string): Promise<string>;
+/**
+ * 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
+ */
+export function toJson(hclContents: string, filename?: string): Promise<string>;
+export { parseSync as parse, parse as parseAsync };
 //# sourceMappingURL=hcl.d.ts.map

package/types/src/parsers/hcl.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"hcl.d.ts","sourceRoot":"","sources":["../../../src/parsers/hcl.js"],"names":[],"mappings":""}
+{"version":3,"file":"hcl.d.ts","sourceRoot":"","sources":["../../../src/parsers/hcl.js"],"names":[],"mappings":"AA2CA;;;;;;GAMG;AACH,uCALW,MAAM,aACN,MAAM,OA2BhB;AAlDD;;;;;;;GAOG;AACH,oCALW,MAAM,aACN,MAAM,GACJ,OAAO,KAAQ,CAa3B;AAkCD;;;;;;;GAOG;AACH,mCAHa,MAAM,CAKlB;AAED;;;;;;GAMG;AACH,oCALW,MAAM,aACN,MAAM,GACJ,OAAO,CAAC,MAAM,CAAC,CAY3B;AAED;;;;;;GAMG;AACH,oCALW,MAAM,aACN,MAAM,GACJ,OAAO,CAAC,MAAM,CAAC,CAY3B"}

package/types/src/parsers/hcl.slow-test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=hcl.slow-test.d.ts.map

package/types/src/parsers/hcl.slow-test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hcl.slow-test.d.ts","sourceRoot":"","sources":["../../../src/parsers/hcl.slow-test.js"],"names":[],"mappings":""}

package/types/src/resolvers/valueFromFile.d.ts

@@ -12,6 +12,8 @@
  * @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>}
@@ -28,6 +30,8 @@ export function getValueFromFile(ctx: {
     getDeeperValue: Function;
     fileRefSyntax: RegExp;
     textRefSyntax: RegExp;
+    varPrefix: string;
+    varSuffix: string;
 }, variableString: string, options: object): Promise<any>;
 /**
  * Parse file contents based on file extension

package/types/src/resolvers/valueFromFile.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"valueFromFile.d.ts","sourceRoot":"","sources":["../../../src/resolvers/valueFromFile.js"],"names":[],"mappings":"AAkEA;;;;;;;;;;;;;;;;;GAiBG;AACH,sCAfG;IAAoB,UAAU,EAAtB,MAAM;IACK,aAAa;IACZ,cAAc,EAA1B,MAAM;IACM,mBAAmB,EAA/B,MAAM;IACM,aAAa,EAAzB,MAAM;IACM,IAAI,EAAhB,MAAM;IACM,cAAc,EAA1B,MAAM;IACM,MAAM,EAAlB,MAAM;IACQ,cAAc;IAChB,aAAa,EAAzB,MAAM;IACM,aAAa,EAAzB,MAAM;CACd,kBAAQ,MAAM,WACN,MAAM,GACJ,OAAO,CAAC,GAAG,CAAC,CAiUxB;AA3WD;;;;;GAKG;AACH,2CAJW,MAAM,YACN,MAAM,GACJ,GAAC,CAoBb;AAqVD;;;;;;GAMG;AACH,qDAJW,MAAM,qBACN,MAAM,GACJ;IAAE,aAAa,EAAE,MAAM,EAAE,CAAC;IAAC,UAAU,EAAE,MAAM,GAAC,IAAI,CAAA;CAAE,CAkBhE;AAED;;;;;;GAMG;AACH,sDALW,MAAM,qBACN,MAAM,yBACN,OAAO,GACL,MAAM,EAAE,CAcpB"}
+{"version":3,"file":"valueFromFile.d.ts","sourceRoot":"","sources":["../../../src/resolvers/valueFromFile.js"],"names":[],"mappings":"AA8FA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,sCAjBG;IAAoB,UAAU,EAAtB,MAAM;IACK,aAAa;IACZ,cAAc,EAA1B,MAAM;IACM,mBAAmB,EAA/B,MAAM;IACM,aAAa,EAAzB,MAAM;IACM,IAAI,EAAhB,MAAM;IACM,cAAc,EAA1B,MAAM;IACM,MAAM,EAAlB,MAAM;IACQ,cAAc;IAChB,aAAa,EAAzB,MAAM;IACM,aAAa,EAAzB,MAAM;IACM,SAAS,EAArB,MAAM;IACM,SAAS,EAArB,MAAM;CACd,kBAAQ,MAAM,WACN,MAAM,GACJ,OAAO,CAAC,GAAG,CAAC,CAwVxB;AApYD;;;;;GAKG;AACH,2CAJW,MAAM,YACN,MAAM,GACJ,GAAC,CAoBb;AA8WD;;;;;;GAMG;AACH,qDAJW,MAAM,qBACN,MAAM,GACJ;IAAE,aAAa,EAAE,MAAM,EAAE,CAAC;IAAC,UAAU,EAAE,MAAM,GAAC,IAAI,CAAA;CAAE,CAkBhE;AAED;;;;;;GAMG;AACH,sDALW,MAAM,qBACN,MAAM,yBACN,OAAO,GACL,MAAM,EAAE,CAcpB"}

package/types/src/utils/parsing/parse.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"parse.d.ts","sourceRoot":"","sources":["../../../../src/utils/parsing/parse.js"],"names":[],"mappings":";;;;cAec,MAAM;;;;cACN,MAAM;;;;eACN,MAAM;;;;kBACN,cAAe;;;;;;eAqGf,MAAM;;;;kBACN,cAAe;;AA3G7B;;;;;;GAMG;AAEH;;;;GAIG;AACH,iFAHW,YAAY,OA4FtB;AAED;;;;GAIG;AAEH;;;;;GAKG;AACH,oCAJW,MAAM,SACN,gBAAgB,OAW1B"}
+{"version":3,"file":"parse.d.ts","sourceRoot":"","sources":["../../../../src/utils/parsing/parse.js"],"names":[],"mappings":";;;;cAgBc,MAAM;;;;cACN,MAAM;;;;eACN,MAAM;;;;kBACN,cAAe;;;;;;eA8Gf,MAAM;;;;kBACN,cAAe;;AApH7B;;;;;;GAMG;AAEH;;;;GAIG;AACH,iFAHW,YAAY,OAqGtB;AAED;;;;GAIG;AAEH;;;;;GAKG;AACH,oCAJW,MAAM,SACN,gBAAgB,OAW1B"}