configorama 0.6.3 → 0.6.5

package/src/parsers/esm.js

@@ -0,0 +1,69 @@
+const path = require('path')
+
+/**
+ * Execute ESM file and return its export using jiti
+ * @param {string} filePath - Full path to the ESM file
+ * @param {Object} opts - Additional options including dynamicArgs
+ * @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)
+
+    // Handle different export patterns - jiti returns { default: Function } for ESM default exports
+    if (esmModule && typeof esmModule === 'object' && esmModule.default) {
+      esmModule = esmModule.default
+    }
+
+    // For ESM files, we just return the module (object or function)
+    // The calling code will determine whether to execute it or not
+    return esmModule
+  } catch (err) {
+    throw new Error(`Failed to load ESM file ${filePath}: ${err.message}`)
+  }
+}
+
+/**
+ * Synchronous ESM file execution using jiti
+ * @param {string} filePath - Full path to the ESM file
+ * @param {Object} opts - Additional options including dynamicArgs
+ * @returns {*} The result of executing the ESM file
+ */
+function executeESMFileSync(filePath, opts = {}) {
+  try {
+    // Use jiti to handle ESM syntax synchronously
+    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)
+
+    // Handle different export patterns - jiti returns { default: Function } for ESM default exports
+    if (esmModule && typeof esmModule === 'object' && esmModule.default) {
+      esmModule = esmModule.default
+    }
+
+    // For ESM files, we just return the module (object or function)
+    // The calling code will determine whether to execute it or not
+    return esmModule
+  } catch (err) {
+    throw new Error(`Failed to load ESM file ${filePath}: ${err.message}`)
+  }
+}
+
+module.exports = {
+  executeESMFile,
+  executeESMFileSync
+}

package/src/parsers/index.js

@@ -1,9 +1,11 @@
 const json = require('./json5')
 const toml = require('./toml')
 const yaml = require('./yaml')
+const ini = require('./ini')
 
 module.exports = {
   json: json,
   toml: toml,
-  yaml: yaml
+  yaml: yaml,
+  ini: ini
 }

package/src/parsers/ini.js

@@ -0,0 +1,51 @@
+const INI = require('ini')
+const YAML = require('./yaml')
+const JSON5 = require('./json5')
+
+function parse(contents) {
+  let object
+  try {
+    object = JSON.parse(JSON.stringify(INI.parse(contents)))
+  } catch (e) {
+    throw new Error(e)
+  }
+  return object
+}
+
+function dump(object) {
+  let ini
+  try {
+    ini = INI.stringify(object)
+  } catch (e) {
+    throw new Error(e)
+  }
+  return ini
+}
+
+function toYaml(iniContents) {
+  let yml
+  try {
+    yml = YAML.dump(parse(iniContents))
+  } catch (e) {
+    throw new Error(e)
+  }
+  return yml
+}
+
+function toJson(iniContents) {
+  let json
+  try {
+    json = JSON.stringify(parse(iniContents))
+  } catch (e) {
+    throw new Error(e)
+  }
+  return json
+}
+
+module.exports = {
+  parse: parse,
+  dump: dump,
+  toYaml: toYaml,
+  toYml: toYaml,
+  toJson: toJson
+}

package/src/parsers/ini.test.js

@@ -0,0 +1,133 @@
+/* eslint-disable no-template-curly-in-string */
+const { test } = require('uvu')
+const assert = require('uvu/assert')
+const ini = require('./ini')
+
+function normalize(obj) {
+  return JSON.parse(JSON.stringify(obj))
+}
+
+test('ini parse basic', () => {
+  const iniContent = `
+key=value
+number=123
+boolean=true
+
+[section]
+sectionKey=sectionValue
+`
+  const result = ini.parse(iniContent)
+  console.log('result', result)
+  
+  assert.is(result.key, 'value', 'key should be value')
+  assert.is(result.number, '123', 'number should be 123')
+  assert.is(result.boolean, true, 'boolean should be true')
+  assert.equal(normalize(result.section), normalize({
+    sectionKey: 'sectionValue'
+  }), 'section should be sectionValue')
+})
+
+test('ini dump basic', () => {
+  const obj = {
+    key: 'value',
+    number: 123,
+    section: {
+      sectionKey: 'sectionValue'
+    }
+  }
+  
+  const result = ini.dump(obj)
+  assert.ok(result.includes('key=value'))
+  assert.ok(result.includes('number=123'))
+  assert.ok(result.includes('[section]'))
+  assert.ok(result.includes('sectionKey=sectionValue'))
+})
+
+test('ini toYaml', () => {
+  const iniContent = `
+key=value
+[section]
+sectionKey=sectionValue
+`
+  
+  const result = ini.toYaml(iniContent)
+  assert.ok(result.includes('key: value'))
+  assert.ok(result.includes('section:'))
+  assert.ok(result.includes('sectionKey: sectionValue'))
+})
+
+test('ini toJson', () => {
+  const iniContent = `
+key=value
+[section]
+sectionKey=sectionValue
+`
+  
+  const result = ini.toJson(iniContent)
+  console.log('result', result)
+
+  const parsed = JSON.parse(result)
+  assert.is(parsed.key, 'value')
+  assert.equal(parsed.section,{
+    sectionKey: 'sectionValue'
+  })
+})
+
+test.skip('ini toYaml complex', () => {
+  const iniContent = `
+# Top level values
+string=hello world
+number=42
+boolean=true
+float=3.14
+
+[main]
+nestedString=test
+nestedNumber=123
+nestedBoolean=false
+
+[main.subsection]
+deeplyNested=value
+array=1,2,3,4,5
+
+[another]
+key=value
+`
+  
+  const result = ini.toYaml(iniContent)
+  console.log('complex yaml result', result)
+
+  // Check top level values
+  assert.ok(result.includes('string: hello world'), 'string should be hello world')
+  assert.ok(result.includes('number: 42'), 'number should be 42')
+  assert.ok(result.includes('boolean: true'), 'boolean should be true')
+  assert.ok(result.includes('float: 3.14'), 'float should be 3.14')
+
+  // Check nested structure
+  assert.ok(result.includes('main:'))
+  assert.ok(result.includes('nestedString: test'), 'nestedString should be test')
+  assert.ok(result.includes('nestedNumber: 123'), 'nestedNumber should be 123')
+  assert.ok(result.includes('nestedBoolean: false'), 'nestedBoolean should be false')
+
+  // Check deeply nested structure
+  assert.ok(result.includes('subsection:'), 'subsection should be present')
+  assert.ok(result.includes('deeplyNested: value'), 'deeplyNested should be value')
+  assert.ok(result.includes('array: 1,2,3,4,5'), 'array should be 1,2,3,4,5')
+
+  // Check another section
+  assert.ok(result.includes('another:'))
+  assert.ok(result.includes('key: value'))
+})
+
+test.skip('ini parse error handling', () => {
+  let error
+  try {
+    const result = ini.parse('invalid ini content')
+    console.log('ini parse error handling', result)
+  } catch (e) {
+    error = e
+  }
+  assert.ok(error instanceof Error)
+})
+
+test.run()

package/src/parsers/json5.js

@@ -45,6 +45,7 @@ function toToml(jsonContents) {
 module.exports = {
   parse: parse,
   dump: dump,
+  stringify: JSON.stringify,
   toYaml: toYaml,
   toYml: toYaml,
   toToml: toToml

package/src/parsers/typescript.js

@@ -0,0 +1,154 @@
+const path = require('path')
+const fs = require('fs')
+
+/**
+ * Execute TypeScript file and return its export
+ * @param {string} filePath - Full path to the TypeScript file
+ * @param {Object} opts - Additional options including dynamicArgs
+ * @returns {Promise<*>} The result of executing 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
+    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 {
+      require('ts-node/register')
+      tsFile = require(filePath)
+    } catch (err) {
+      throw new Error(`Failed to load TypeScript file with ts-node: ${err.message}`)
+    }
+  }
+
+  if (typeof tsFile !== 'function') {
+    return tsFile
+  } else {
+    let tsArgs = opts.dynamicArgs || {}
+    if (tsArgs && typeof tsArgs === 'function') {
+      tsArgs = tsArgs()
+    }
+    
+    try {
+      const result = tsFile(tsArgs)
+      
+      // Handle promises
+      if (result && typeof result.then === 'function') {
+        return await result
+      }
+      
+      return result
+    } catch (err) {
+      throw new Error(`Error executing TypeScript function: ${err.message}`)
+    }
+  }
+}
+
+/**
+ * Synchronous TypeScript file execution (using tsx with sync API)
+ * @param {string} filePath - Full path to the TypeScript file
+ * @param {Object} opts - Additional options including dynamicArgs
+ * @returns {*} The result of executing the TypeScript file
+ */
+function executeTypeScriptFileSync(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
+    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 {
+      require('ts-node/register')
+      tsFile = require(filePath)
+    } catch (err) {
+      throw new Error(`Failed to load TypeScript file with ts-node: ${err.message}`)
+    }
+  }
+
+  if (typeof tsFile !== 'function') {
+    return tsFile
+  } else {
+    let tsArgs = opts.dynamicArgs || {}
+    if (tsArgs && typeof tsArgs === 'function') {
+      tsArgs = tsArgs()
+    }
+    
+    try {
+      const result = tsFile(tsArgs)
+      
+      // Note: For sync execution, we don't await promises
+      // If the function returns a promise, it will be resolved by the calling code
+      return result
+    } catch (err) {
+      throw new Error(`Error executing TypeScript function: ${err.message}`)
+    }
+  }
+}
+
+module.exports = {
+  executeTypeScriptFile,
+  executeTypeScriptFileSync
+}

package/src/parsers/yaml.test.js

@@ -110,7 +110,7 @@ resolvedDomainNameTwo: \${domainsTwo.\${opt:stage, "prod"}}
   assert.equal(result, expected)
 })
 
-test('preProcess - should wrap variables in quotes inside array brackets', () => {
+test('preProcess - should wrap variables in quotes inside array brackets two', () => {
   const input = `
 service: my-service
 custom:

package/src/resolvers/valueFromCron.js

@@ -0,0 +1,252 @@
+const cronRefSyntax = RegExp(/^cron\((~?[\{\}\:\$a-zA-Z0-9._\-\/,'"\*\` ]+?)?\)/g)
+
+/**
+ * Convert human-readable strings to cron expressions
+ * Based on common patterns and schedules
+ */
+function parseCronExpression(input) {
+  if (!input || typeof input !== 'string') {
+    throw new Error('Cron input must be a non-empty string')
+  }
+
+  const normalizedInput = input.toLowerCase().trim()
+
+  // Pre-defined common cron expressions
+  const cronMap = {
+    // Every minute/hour/day patterns
+    'every minute': '* * * * *',
+    'every hour': '0 * * * *',
+    'every day': '0 0 * * *',
+    'every week': '0 0 * * 0',
+    'every month': '0 0 1 * *',
+    'every year': '0 0 1 1 *',
+    'yearly': '0 0 1 1 *',
+    'annually': '0 0 1 1 *',
+    'monthly': '0 0 1 * *',
+    'weekly': '0 0 * * 0',
+    'daily': '0 0 * * *',
+    'hourly': '0 * * * *',
+
+    // Common business schedules
+    'weekdays': '0 0 * * 1-5',
+    'weekends': '0 0 * * 0,6',
+    'business hours': '0 9-17 * * 1-5',
+    'after hours': '0 18-8 * * *',
+    
+    // Specific times
+    'midnight': '0 0 * * *',
+    'noon': '0 12 * * *',
+    'morning': '0 9 * * *',
+    'evening': '0 18 * * *',
+    
+    // Interval patterns
+    'every 5 minutes': '*/5 * * * *',
+    'every 10 minutes': '*/10 * * * *',
+    'every 15 minutes': '*/15 * * * *',
+    'every 30 minutes': '*/30 * * * *',
+    'every 2 hours': '0 */2 * * *',
+    'every 3 hours': '0 */3 * * *',
+    'every 6 hours': '0 */6 * * *',
+    'every 12 hours': '0 */12 * * *',
+    
+    // Days of week
+    'monday': '0 0 * * 1',
+    'tuesday': '0 0 * * 2',
+    'wednesday': '0 0 * * 3',
+    'thursday': '0 0 * * 4',
+    'friday': '0 0 * * 5',
+    'saturday': '0 0 * * 6',
+    'sunday': '0 0 * * 0',
+    
+    // Monthly patterns
+    'first day of month': '0 0 1 * *',
+    'last day of month': '0 0 L * *',
+    'middle of month': '0 0 15 * *',
+    
+    // Special patterns
+    'never': '0 0 30 2 *', // Feb 30th (never occurs)
+    'reboot': '@reboot',
+    'startup': '@reboot'
+  }
+
+  // Check direct mapping first
+  if (cronMap[normalizedInput]) {
+    return cronMap[normalizedInput]
+  }
+
+  // Parse "at X:XX" patterns (e.g., "at 9:30", "at 14:00")
+  const atTimeMatch = normalizedInput.match(/^at (\d{1,2}):(\d{2})(\s*(am|pm))?$/i)
+  if (atTimeMatch) {
+    let hour = parseInt(atTimeMatch[1])
+    const minute = parseInt(atTimeMatch[2])
+    const amPm = atTimeMatch[4]
+    
+    if (amPm && amPm.toLowerCase() === 'pm' && hour !== 12) {
+      hour += 12
+    } else if (amPm && amPm.toLowerCase() === 'am' && hour === 12) {
+      hour = 0
+    }
+    
+    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)
+  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} * * * *`
+      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 "on Xst/nd/rd/th of month at time" patterns (e.g., "on 1st of month at 00:00")
+  const ordinalDateMatch = normalizedInput.match(/^on (\d+)(?:st|nd|rd|th) of month at (\d{1,2}):(\d{2})(\s*(am|pm))?$/i)
+  if (ordinalDateMatch) {
+    const dayOfMonth = parseInt(ordinalDateMatch[1])
+    let hour = parseInt(ordinalDateMatch[2])
+    const minute = parseInt(ordinalDateMatch[3])
+    const amPm = ordinalDateMatch[5]
+    
+    if (amPm && amPm.toLowerCase() === 'pm' && hour !== 12) {
+      hour += 12
+    } else if (amPm && amPm.toLowerCase() === 'am' && hour === 12) {
+      hour = 0
+    }
+    
+    return `${minute} ${hour} ${dayOfMonth} * *`
+  }
+
+  // Parse "on weekday at time" patterns (e.g., "on monday at 9:00")
+  const weekdayTimeMatch = normalizedInput.match(/^on ((?:monday|tuesday|wednesday|thursday|friday|saturday|sunday)(?:,(?:monday|tuesday|wednesday|thursday|friday|saturday|sunday))*?) at (\d{1,2}):(\d{2})(\s*(am|pm))?$/i)
+  if (weekdayTimeMatch) {
+    const dayMap = {
+      'sunday': 0, 'monday': 1, 'tuesday': 2, 'wednesday': 3,
+      'thursday': 4, 'friday': 5, 'saturday': 6
+    }
+    
+    // Extract all days from the match
+    const days = weekdayTimeMatch[1].split(',').map(day => day.trim())
+    const dayOfWeek = days.map(day => dayMap[day.toLowerCase()]).join(',')
+    
+    let hour = parseInt(weekdayTimeMatch[2])
+    const minute = parseInt(weekdayTimeMatch[3])
+    const amPm = weekdayTimeMatch[5]
+    
+    if (amPm && amPm.toLowerCase() === 'pm' && hour !== 12) {
+      hour += 12
+    } else if (amPm && amPm.toLowerCase() === 'am' && hour === 12) {
+      hour = 0
+    }
+    
+    return `${minute} ${hour} * * ${dayOfWeek}`
+  }
+
+  // Parse "on weekdays/weekends at time" patterns (e.g., "on weekdays at 9:00")
+  const weekdaysTimeMatch = normalizedInput.match(/^on (weekdays|weekends) at (\d{1,2}):(\d{2})(\s*(am|pm))?$/i)
+  if (weekdaysTimeMatch) {
+    const dayRange = weekdaysTimeMatch[1].toLowerCase() === 'weekdays' ? '1-5' : '0,6'
+    let hour = parseInt(weekdaysTimeMatch[2])
+    const minute = parseInt(weekdaysTimeMatch[3])
+    const amPm = weekdaysTimeMatch[5]
+    
+    if (amPm && amPm.toLowerCase() === 'pm' && hour !== 12) {
+      hour += 12
+    } else if (amPm && amPm.toLowerCase() === 'am' && hour === 12) {
+      hour = 0
+    }
+    
+    return `${minute} ${hour} * * ${dayRange}`
+  }
+
+  // Check if it's already a valid cron expression (5 or 6 parts)
+  const parts = normalizedInput.split(/\s+/)
+  if (parts.length === 5 || parts.length === 6) {
+    // Basic validation for cron format
+    if (parts.every(part => /^[@*\d,\-\/]+$/.test(part) || part.startsWith('@'))) {
+      return normalizedInput
+    }
+  }
+
+  // If no pattern matches, throw an error with suggestions
+  const suggestions = Object.keys(cronMap).slice(0, 10).join(', ')
+  throw new Error(`Unrecognized cron pattern: "${input}". Supported patterns include: ${suggestions}`)
+}
+
+function getValueFromCron(variableString) {
+  // Get value from cron(expression)
+  const cronExpression = variableString.match(/cron\((.*)\)/)[1]
+  // console.log('cronExpression', cronExpression)
+  
+  if (!cronExpression || cronExpression.trim() === '') {
+    throw new Error(`Invalid variable syntax for cron reference "${variableString}". 
+
+\${cron} variable must have a pattern. 
+
+Examples: 
+  \${cron("every minute")}
+  \${cron("weekdays")}
+  \${cron("at 9:30")}
+  \${cron("every 5 minutes")}
+`)
+  }
+  
+  // Remove surrounding quotes if present
+  const cleanExpression = cronExpression.replace(/^['"`](.*)['"`]$/, '$1')
+  
+  // If already a cron expression, return it
+  if (cleanExpression.match(/^[\*\/,\-\d]+$/)) {
+    return cleanExpression
+  }
+
+  try {
+    const resolvedCron = parseCronExpression(cleanExpression)
+    // console.log('resolvedCron', resolvedCron)
+    return Promise.resolve(resolvedCron)
+  } catch (error) {
+    throw new Error(`Failed to parse cron expression "${cleanExpression}": ${error.message}`)
+  }
+}
+
+module.exports = {
+  type: 'cron',
+  prefix: 'cron',
+  match: cronRefSyntax,
+  resolver: getValueFromCron,
+  // Export the parser for testing
+  _parseCronExpression: parseCronExpression
+}