configorama 0.9.0 → 0.9.5

package/src/utils/parsing/cloudformationSchema.test.js

@@ -0,0 +1,236 @@
+/**
+ * Tests for CloudFormation YAML schema intrinsic functions
+ */
+const { test } = require('uvu')
+const assert = require('uvu/assert')
+const YAML = require('js-yaml')
+const cloudFormationSchema = require('./cloudformationSchema')
+
+// Helper to parse YAML with CloudFormation schema
+function parseCfYaml(yamlString) {
+  return YAML.load(yamlString, { schema: cloudFormationSchema.schema })
+}
+
+// ==========================================
+// !GetAtt - Simple attributes (single dot)
+// ==========================================
+
+test('!GetAtt - simple attribute (dot syntax)', () => {
+  const yaml = `Value: !GetAtt MyDBInstance.DBInstanceArn`
+  const parsed = parseCfYaml(yaml)
+  assert.equal(parsed.Value['Fn::GetAtt'], ['MyDBInstance', 'DBInstanceArn'])
+})
+
+test('!GetAtt - simple attribute (array syntax)', () => {
+  const yaml = `Value: !GetAtt [MyDBInstance, DBInstanceArn]`
+  const parsed = parseCfYaml(yaml)
+  assert.equal(parsed.Value['Fn::GetAtt'], ['MyDBInstance', 'DBInstanceArn'])
+})
+
+// ==========================================
+// !GetAtt - Nested attributes (bug fix)
+// AWS resources have attributes like Endpoint.Address that contain dots
+// ==========================================
+
+test('!GetAtt - nested attribute Endpoint.Address (dot syntax)', () => {
+  const yaml = `Value: !GetAtt MyDBInstance.Endpoint.Address`
+  const parsed = parseCfYaml(yaml)
+  assert.equal(parsed.Value['Fn::GetAtt'], ['MyDBInstance', 'Endpoint.Address'])
+})
+
+test('!GetAtt - nested attribute Endpoint.Port (dot syntax)', () => {
+  const yaml = `Value: !GetAtt MyDBInstance.Endpoint.Port`
+  const parsed = parseCfYaml(yaml)
+  assert.equal(parsed.Value['Fn::GetAtt'], ['MyDBInstance', 'Endpoint.Port'])
+})
+
+test('!GetAtt - nested attribute CertificateDetails.CAIdentifier (dot syntax)', () => {
+  const yaml = `Value: !GetAtt MyDBInstance.CertificateDetails.CAIdentifier`
+  const parsed = parseCfYaml(yaml)
+  assert.equal(parsed.Value['Fn::GetAtt'], ['MyDBInstance', 'CertificateDetails.CAIdentifier'])
+})
+
+test('!GetAtt - nested attribute ReadEndpoint.Address (dot syntax)', () => {
+  const yaml = `Value: !GetAtt MyDBCluster.ReadEndpoint.Address`
+  const parsed = parseCfYaml(yaml)
+  assert.equal(parsed.Value['Fn::GetAtt'], ['MyDBCluster', 'ReadEndpoint.Address'])
+})
+
+test('!GetAtt - nested attribute MasterUserSecret.SecretArn (dot syntax)', () => {
+  const yaml = `Value: !GetAtt MyDBCluster.MasterUserSecret.SecretArn`
+  const parsed = parseCfYaml(yaml)
+  assert.equal(parsed.Value['Fn::GetAtt'], ['MyDBCluster', 'MasterUserSecret.SecretArn'])
+})
+
+test('!GetAtt - nested attribute (array syntax - should still work)', () => {
+  const yaml = `Value: !GetAtt [MyDBInstance, Endpoint.Address]`
+  const parsed = parseCfYaml(yaml)
+  assert.equal(parsed.Value['Fn::GetAtt'], ['MyDBInstance', 'Endpoint.Address'])
+})
+
+// ==========================================
+// !GetAtt - Edge cases
+// ==========================================
+
+test('!GetAtt - resource name only (no attribute)', () => {
+  const yaml = `Value: !GetAtt MyResource`
+  const parsed = parseCfYaml(yaml)
+  assert.equal(parsed.Value['Fn::GetAtt'], ['MyResource'])
+})
+
+test('!GetAtt - three-level nested attribute', () => {
+  const yaml = `Value: !GetAtt MyResource.Level1.Level2.Level3`
+  const parsed = parseCfYaml(yaml)
+  assert.equal(parsed.Value['Fn::GetAtt'], ['MyResource', 'Level1.Level2.Level3'])
+})
+
+// ==========================================
+// !Ref - Basic reference
+// ==========================================
+
+test('!Ref - basic reference', () => {
+  const yaml = `Value: !Ref MyResource`
+  const parsed = parseCfYaml(yaml)
+  assert.equal(parsed.Value['Ref'], 'MyResource')
+})
+
+// ==========================================
+// !Sub - String substitution
+// ==========================================
+
+test('!Sub - simple substitution', () => {
+  const yaml = `Value: !Sub 'Hello \${Name}'`
+  const parsed = parseCfYaml(yaml)
+  assert.is(parsed.Value['Fn::Sub'], 'Hello ${Name}')
+})
+
+test('!Sub - with array form', () => {
+  const yaml = `Value: !Sub ['Hello \${Name}', {Name: World}]`
+  const parsed = parseCfYaml(yaml)
+  assert.equal(parsed.Value['Fn::Sub'], ['Hello ${Name}', { Name: 'World' }])
+})
+
+// ==========================================
+// !Join - Join values
+// ==========================================
+
+test('!Join - basic join', () => {
+  const yaml = `Value: !Join [',', [a, b, c]]`
+  const parsed = parseCfYaml(yaml)
+  assert.equal(parsed.Value['Fn::Join'], [',', ['a', 'b', 'c']])
+})
+
+// ==========================================
+// !If - Conditional
+// ==========================================
+
+test('!If - basic conditional', () => {
+  const yaml = `Value: !If [IsProduction, prod-value, dev-value]`
+  const parsed = parseCfYaml(yaml)
+  assert.equal(parsed.Value['Fn::If'], ['IsProduction', 'prod-value', 'dev-value'])
+})
+
+// ==========================================
+// !FindInMap - Map lookup
+// ==========================================
+
+test('!FindInMap - basic lookup', () => {
+  const yaml = `Value: !FindInMap [MapName, TopKey, SecondKey]`
+  const parsed = parseCfYaml(yaml)
+  assert.equal(parsed.Value['Fn::FindInMap'], ['MapName', 'TopKey', 'SecondKey'])
+})
+
+// ==========================================
+// !Select - Select from list
+// ==========================================
+
+test('!Select - basic select', () => {
+  const yaml = `Value: !Select [0, [a, b, c]]`
+  const parsed = parseCfYaml(yaml)
+  assert.equal(parsed.Value['Fn::Select'], [0, ['a', 'b', 'c']])
+})
+
+// ==========================================
+// !Base64 - Base64 encoding
+// ==========================================
+
+test('!Base64 - basic encoding', () => {
+  const yaml = `Value: !Base64 'Hello World'`
+  const parsed = parseCfYaml(yaml)
+  assert.is(parsed.Value['Fn::Base64'], 'Hello World')
+})
+
+// ==========================================
+// !Condition - Condition reference
+// ==========================================
+
+test('!Condition - basic condition', () => {
+  const yaml = `Value: !Condition IsProduction`
+  const parsed = parseCfYaml(yaml)
+  assert.is(parsed.Value['Condition'], 'IsProduction')
+})
+
+// ==========================================
+// !Transform - Macro processing
+// ==========================================
+
+test('!Transform - basic transform', () => {
+  const yaml = `Value: !Transform { Name: 'AWS::Include', Parameters: { Location: 's3://bucket/file.yaml' } }`
+  const parsed = parseCfYaml(yaml)
+  assert.equal(parsed.Value['Fn::Transform'], {
+    Name: 'AWS::Include',
+    Parameters: { Location: 's3://bucket/file.yaml' }
+  })
+})
+
+// ==========================================
+// AWS::LanguageExtensions functions
+// ==========================================
+
+test('!Length - array length', () => {
+  const yaml = `Value: !Length [a, b, c]`
+  const parsed = parseCfYaml(yaml)
+  assert.equal(parsed.Value['Fn::Length'], ['a', 'b', 'c'])
+})
+
+test('!ToJsonString - convert to JSON', () => {
+  const yaml = `Value: !ToJsonString { key: value }`
+  const parsed = parseCfYaml(yaml)
+  assert.equal(parsed.Value['Fn::ToJsonString'], { key: 'value' })
+})
+
+test('!ForEach - iteration', () => {
+  const yaml = `Value: !ForEach [Identifier, [a, b, c], Content]`
+  const parsed = parseCfYaml(yaml)
+  assert.equal(parsed.Value['Fn::ForEach'], ['Identifier', ['a', 'b', 'c'], 'Content'])
+})
+
+// ==========================================
+// Rule-specific functions
+// ==========================================
+
+test('!ValueOf - rule value lookup', () => {
+  const yaml = `Value: !ValueOf [ParameterLogicalId, AttributeKey]`
+  const parsed = parseCfYaml(yaml)
+  assert.equal(parsed.Value['Fn::ValueOf'], ['ParameterLogicalId', 'AttributeKey'])
+})
+
+test('!ValueOfAll - all values lookup', () => {
+  const yaml = `Value: !ValueOfAll ['AWS::EC2::VPC::Id', Tags.Name]`
+  const parsed = parseCfYaml(yaml)
+  assert.equal(parsed.Value['Fn::ValueOfAll'], ['AWS::EC2::VPC::Id', 'Tags.Name'])
+})
+
+test('!EachMemberEquals - member equality check', () => {
+  const yaml = `Value: !EachMemberEquals [[a, b], value]`
+  const parsed = parseCfYaml(yaml)
+  assert.equal(parsed.Value['Fn::EachMemberEquals'], [['a', 'b'], 'value'])
+})
+
+test('!EachMemberIn - member inclusion check', () => {
+  const yaml = `Value: !EachMemberIn [[a, b], [a, b, c]]`
+  const parsed = parseCfYaml(yaml)
+  assert.equal(parsed.Value['Fn::EachMemberIn'], [['a', 'b'], ['a', 'b', 'c']])
+})
+
+test.run()

package/src/utils/parsing/mergeByKeys.js

@@ -12,16 +12,17 @@ function mergeByKeys(data, path, keysToMerge) {
   const mergeAll = !keysToMerge || !Array.isArray(keysToMerge) || keysToMerge.length === 0
   
   for (const item of items) {
-    const key = Object.keys(item)[0]
-    
-    if (mergeAll || keysToMerge.includes(key)) {
-      if (!result[key]) {
-        result[key] = Object.assign({}, item[key])
+    const keys = Object.keys(item)
+    for (const key of keys) {
+      if (mergeAll || keysToMerge.includes(key)) {
+        if (!result[key]) {
+          result[key] = Object.assign({}, item[key])
+        } else {
+          result[key] = Object.assign({}, result[key], item[key])
+        }
       } else {
-        result[key] = Object.assign({}, result[key], item[key])
+        result[key] = item[key]
       }
-    } else {
-      result[key] = item[key]
     }
   }
   return result

package/src/utils/parsing/mergeByKeys.test.js

@@ -0,0 +1,189 @@
+const { test } = require('uvu')
+const assert = require('uvu/assert')
+const { mergeByKeys } = require('./mergeByKeys')
+
+// ==========================================
+// Basic functionality tests
+// ==========================================
+
+test('mergeByKeys - should merge objects with matching keys', () => {
+  const data = {
+    items: [
+      { Resources: { A: { type: 'a' } } },
+      { Resources: { B: { type: 'b' } } }
+    ]
+  }
+  const result = mergeByKeys(data, 'items', ['Resources'])
+  assert.equal(result, {
+    Resources: { A: { type: 'a' }, B: { type: 'b' } }
+  })
+})
+
+test('mergeByKeys - should pass through non-matching keys unchanged', () => {
+  const data = {
+    items: [
+      { Resources: { A: { type: 'a' } } },
+      { Outputs: { Out1: { value: 'v1' } } }
+    ]
+  }
+  const result = mergeByKeys(data, 'items', ['Resources'])
+  assert.equal(result, {
+    Resources: { A: { type: 'a' } },
+    Outputs: { Out1: { value: 'v1' } }
+  })
+})
+
+test('mergeByKeys - should return empty object for null/undefined data', () => {
+  assert.equal(mergeByKeys(null, 'items', ['Resources']), {})
+  assert.equal(mergeByKeys(undefined, 'items', ['Resources']), {})
+})
+
+test('mergeByKeys - should return data unchanged if path is not an array', () => {
+  const data = { items: 'not an array' }
+  assert.equal(mergeByKeys(data, 'items', ['Resources']), data)
+})
+
+// ==========================================
+// Bug fix tests: Multiple keys per item
+// ==========================================
+
+test('mergeByKeys - should process ALL keys in each item, not just the first', () => {
+  // Simulating a CloudFormation/Serverless pattern where a config file
+  // might define both Resources and Outputs in the same section
+  const data = {
+    cloudformation: [
+      {
+        Resources: {
+          MyAPI: { Type: 'AWS::ApiGateway::RestApi' }
+        },
+        Outputs: {
+          ApiEndpoint: { Value: 'https://api.example.com' }
+        }
+      },
+      {
+        Resources: {
+          MyBucket: { Type: 'AWS::S3::Bucket' }
+        }
+      }
+    ]
+  }
+
+  const result = mergeByKeys(data, 'cloudformation', ['Resources'])
+
+  // Expected behavior:
+  // - Resources should be merged (both MyAPI and MyBucket)
+  // - Outputs should be preserved (not merged, just passed through)
+  const expected = {
+    Resources: {
+      MyAPI: { Type: 'AWS::ApiGateway::RestApi' },
+      MyBucket: { Type: 'AWS::S3::Bucket' }
+    },
+    Outputs: {
+      ApiEndpoint: { Value: 'https://api.example.com' }
+    }
+  }
+
+  assert.equal(result, expected)
+})
+
+test('mergeByKeys - should handle items with multiple keys when none match mergeKeys', () => {
+  const data = {
+    items: [
+      {
+        Foo: { a: 1 },
+        Bar: { b: 2 }
+      },
+      {
+        Baz: { c: 3 }
+      }
+    ]
+  }
+
+  // We want to merge 'Baz' only, so Foo and Bar should pass through unchanged
+  const result = mergeByKeys(data, 'items', ['Baz'])
+
+  const expected = {
+    Foo: { a: 1 },
+    Bar: { b: 2 },
+    Baz: { c: 3 }
+  }
+
+  assert.equal(result, expected)
+})
+
+test('mergeByKeys - should preserve all keys when mergeAll is true (empty array)', () => {
+  const data = {
+    items: [
+      {
+        Resources: { API: { Type: 'API' } },
+        Outputs: { Out1: { Value: 'v1' } }
+      },
+      {
+        Resources: { S3: { Type: 'S3' } }
+      }
+    ]
+  }
+
+  // Empty array means merge all keys
+  const result = mergeByKeys(data, 'items', [])
+
+  const expected = {
+    Resources: {
+      API: { Type: 'API' },
+      S3: { Type: 'S3' }
+    },
+    Outputs: {
+      Out1: { Value: 'v1' }
+    }
+  }
+
+  assert.equal(result, expected)
+})
+
+test('mergeByKeys - should merge multiple keys from same item when both are in mergeKeys', () => {
+  const data = {
+    items: [
+      {
+        Resources: { A: { type: 'a' } },
+        Outputs: { O1: { value: 'v1' } }
+      },
+      {
+        Resources: { B: { type: 'b' } },
+        Outputs: { O2: { value: 'v2' } }
+      }
+    ]
+  }
+
+  const result = mergeByKeys(data, 'items', ['Resources', 'Outputs'])
+
+  const expected = {
+    Resources: { A: { type: 'a' }, B: { type: 'b' } },
+    Outputs: { O1: { value: 'v1' }, O2: { value: 'v2' } }
+  }
+
+  assert.equal(result, expected)
+})
+
+test('mergeByKeys - should handle three keys in same item', () => {
+  const data = {
+    items: [
+      {
+        Resources: { R1: {} },
+        Outputs: { O1: {} },
+        Parameters: { P1: {} }
+      }
+    ]
+  }
+
+  const result = mergeByKeys(data, 'items', ['Resources'])
+
+  const expected = {
+    Resources: { R1: {} },
+    Outputs: { O1: {} },
+    Parameters: { P1: {} }
+  }
+
+  assert.equal(result, expected)
+})
+
+test.run()

package/src/utils/parsing/parse.js

@@ -34,8 +34,8 @@ function parseFileContents({ contents, filePath, varRegex, dynamicArgs }) {
       const ymlText = YAML.preProcess(contents)
       configObject = YAML.parse(ymlText)
     } catch (err) {
-      // Attempt to fix cloudformation refs
-      if (err.message.match(/YAMLException/)) {
+      // Attempt to fix cloudformation refs for YAML syntax errors
+      if (err.message && err.message.match(/YAMLException/)) {
         const ymlText = YAML.preProcess(contents)
         const result = YAML.load(ymlText, {
           filename: filePath,
@@ -45,6 +45,9 @@ function parseFileContents({ contents, filePath, varRegex, dynamicArgs }) {
           throw result.error
         }
         configObject = result.data
+      } else {
+        // Re-throw non-YAML errors (e.g., TypeError from null/undefined contents)
+        throw err
       }
     }
   } else if (fileType.match(/\.(toml|tml)/i)) {

package/src/utils/paths/getFullFilePath.js

@@ -17,8 +17,8 @@ function resolveFilePath(pathToResolve, basePath) {
   if (fs.existsSync(fullFilePath)) {
     // Get real path to handle potential symlinks (but don't fatal error)
     fullFilePath = fs.realpathSync(fullFilePath)
-  // Only match files that are relative
-  } else if (pathToResolve.match(/\.\//)) {
+  // Only use findUp for relative paths (not absolute paths)
+  } else if (!path.isAbsolute(pathToResolve)) {
     const cleanName = path.basename(pathToResolve)
     const findUpResult = findUp.sync(cleanName, { cwd: basePath })
     if (findUpResult) {

package/src/utils/paths/getFullFilePath.test.js

@@ -0,0 +1,152 @@
+/**
+ * Tests for getFullFilePath.js - file path resolution with findUp support
+ */
+const { test } = require('uvu')
+const assert = require('uvu/assert')
+const path = require('path')
+const fs = require('fs')
+const getFullPath = require('./getFullFilePath')
+const { resolveFilePath, resolveFilePathFromMatch } = require('./getFullFilePath')
+
+// ==========================================
+// Test directory setup/teardown
+// ==========================================
+
+const testDir = path.join(__dirname, '_test-getFullFilePath')
+const subDir = path.join(testDir, 'subdir')
+const deepDir = path.join(subDir, 'deepdir')
+
+test.before(() => {
+  // Cleanup any existing test directory
+  if (fs.existsSync(testDir)) {
+    fs.rmSync(testDir, { recursive: true })
+  }
+
+  // Create directory structure:
+  // _test-getFullFilePath/
+  //   config.yml         <- file at root
+  //   subdir/
+  //     local.yml        <- file in subdir
+  //     deepdir/
+  //       (empty - for testing findUp from here)
+  fs.mkdirSync(testDir, { recursive: true })
+  fs.mkdirSync(subDir, { recursive: true })
+  fs.mkdirSync(deepDir, { recursive: true })
+
+  // Create test files
+  fs.writeFileSync(path.join(testDir, 'config.yml'), 'root: true')
+  fs.writeFileSync(path.join(subDir, 'local.yml'), 'local: true')
+})
+
+test.after(() => {
+  // Cleanup
+  if (fs.existsSync(testDir)) {
+    fs.rmSync(testDir, { recursive: true })
+  }
+})
+
+// ==========================================
+// resolveFilePath - basic functionality
+// ==========================================
+
+test('resolveFilePath - returns file when it exists at computed path', () => {
+  const result = resolveFilePath('./config.yml', testDir)
+  assert.is(result, path.join(testDir, 'config.yml'))
+})
+
+test('resolveFilePath - handles absolute paths', () => {
+  const absolutePath = path.join(testDir, 'config.yml')
+  const result = resolveFilePath(absolutePath, '/some/other/path')
+  assert.is(result, absolutePath)
+})
+
+test('resolveFilePath - returns computed path when file does not exist', () => {
+  const result = resolveFilePath('./nonexistent.yml', testDir)
+  assert.is(result, path.join(testDir, 'nonexistent.yml'))
+})
+
+// ==========================================
+// resolveFilePath - findUp with "./" prefix
+// ==========================================
+
+test('resolveFilePath - with "./" prefix triggers findUp and finds file in parent directory', () => {
+  // From deepDir, look for config.yml which is in testDir (grandparent)
+  const result = resolveFilePath('./config.yml', deepDir)
+  const expected = path.join(testDir, 'config.yml')
+  assert.is(result, expected)
+})
+
+test('resolveFilePath - with "./" prefix finds file in immediate parent', () => {
+  // From deepDir, look for local.yml which is in subDir (parent)
+  const result = resolveFilePath('./local.yml', deepDir)
+  const expected = path.join(subDir, 'local.yml')
+  assert.is(result, expected)
+})
+
+// ==========================================
+// resolveFilePath - findUp WITHOUT "./" prefix (bug fix tests)
+// ==========================================
+
+test('resolveFilePath - bare filename should also trigger findUp', () => {
+  // From deepDir, look for config.yml (bare filename) which is in testDir
+  const result = resolveFilePath('config.yml', deepDir)
+  const expected = path.join(testDir, 'config.yml')
+  assert.is(result, expected,
+    `Bare filename should trigger findUp. Got ${result} instead of ${expected}`)
+})
+
+test('resolveFilePath - bare filename finds file in immediate parent', () => {
+  // From deepDir, look for local.yml (bare filename) which is in subDir
+  const result = resolveFilePath('local.yml', deepDir)
+  const expected = path.join(subDir, 'local.yml')
+  assert.is(result, expected)
+})
+
+test('resolveFilePath - relative path without ./ prefix triggers findUp', () => {
+  // Path like "subdir/file.yml" should also trigger findUp if not found
+  const result = resolveFilePath('config.yml', deepDir)
+  const expected = path.join(testDir, 'config.yml')
+  assert.is(result, expected)
+})
+
+// ==========================================
+// getFullPath - wrapper function
+// ==========================================
+
+test('getFullPath - resolves file path using cwd', () => {
+  const result = getFullPath('./config.yml', testDir)
+  assert.is(result, path.join(testDir, 'config.yml'))
+})
+
+test('getFullPath - expands ~ to home directory', () => {
+  const os = require('os')
+  const result = getFullPath('~/somefile.yml', testDir)
+  assert.ok(result.startsWith(os.homedir()))
+})
+
+// ==========================================
+// resolveFilePathFromMatch - file() syntax parsing
+// ==========================================
+
+const fileRefSyntax = /^file\((~?[@\{\}\:\$a-zA-Z0-9._\-\/,'" =+]+?)\)/g
+
+test('resolveFilePathFromMatch - extracts path from file() syntax', () => {
+  const result = resolveFilePathFromMatch('file(./config.yml)', fileRefSyntax, testDir)
+  assert.is(result.relativePath, './config.yml')
+  assert.is(result.fullFilePath, path.join(testDir, 'config.yml'))
+})
+
+test('resolveFilePathFromMatch - handles quoted paths', () => {
+  const result = resolveFilePathFromMatch("file('./config.yml')", fileRefSyntax, testDir)
+  assert.is(result.relativePath, './config.yml')
+})
+
+test('resolveFilePathFromMatch - handles bare filename in file() syntax', () => {
+  // This tests the bug fix - bare filename should work with findUp
+  const result = resolveFilePathFromMatch('file(config.yml)', fileRefSyntax, deepDir)
+  const expected = path.join(testDir, 'config.yml')
+  assert.is(result.fullFilePath, expected,
+    `file(config.yml) should find file via findUp. Got ${result.fullFilePath}`)
+})
+
+test.run()