configorama 0.8.0 → 0.9.3

package/src/utils/lodash.test.js

@@ -0,0 +1,172 @@
+/**
+ * Tests for custom lodash utility implementations
+ */
+const { test } = require('uvu')
+const assert = require('uvu/assert')
+const { set, trim } = require('./lodash')
+
+// ==========================================
+// set() - basic functionality
+// ==========================================
+
+test('set - sets value at simple path', () => {
+  const obj = {}
+  set(obj, 'a', 'value')
+  assert.is(obj.a, 'value')
+})
+
+test('set - sets value at nested path', () => {
+  const obj = {}
+  set(obj, 'a.b.c', 'value')
+  assert.is(obj.a.b.c, 'value')
+})
+
+test('set - creates intermediate objects', () => {
+  const obj = {}
+  set(obj, 'a.b.c', 'value')
+  assert.type(obj.a, 'object')
+  assert.type(obj.a.b, 'object')
+})
+
+test('set - handles array path', () => {
+  const obj = {}
+  set(obj, ['a', 'b', 'c'], 'value')
+  assert.is(obj.a.b.c, 'value')
+})
+
+test('set - creates arrays for numeric keys', () => {
+  const obj = {}
+  set(obj, 'items.0.name', 'first')
+  assert.ok(Array.isArray(obj.items))
+  assert.is(obj.items[0].name, 'first')
+})
+
+test('set - overwrites existing value', () => {
+  const obj = { a: { b: 'old' } }
+  set(obj, 'a.b', 'new')
+  assert.is(obj.a.b, 'new')
+})
+
+test('set - returns the object', () => {
+  const obj = {}
+  const result = set(obj, 'a', 'value')
+  assert.is(result, obj)
+})
+
+test('set - returns object unchanged if object is null', () => {
+  const result = set(null, 'a.b', 'value')
+  assert.is(result, null)
+})
+
+test('set - returns object unchanged if object is primitive', () => {
+  const result = set('string', 'a.b', 'value')
+  assert.is(result, 'string')
+})
+
+// ==========================================
+// set() - null intermediate values (bug fix)
+// ==========================================
+
+test('set - overwrites null intermediate value with object', () => {
+  const obj = { a: null }
+  set(obj, 'a.b.c', 'value')
+  assert.type(obj.a, 'object')
+  assert.is(obj.a.b.c, 'value')
+})
+
+test('set - overwrites null at deeper level', () => {
+  const obj = { a: { b: null } }
+  set(obj, 'a.b.c', 'value')
+  assert.type(obj.a.b, 'object')
+  assert.is(obj.a.b.c, 'value')
+})
+
+// ==========================================
+// set() - primitive intermediate values (bug fix)
+// ==========================================
+
+test('set - overwrites string intermediate value', () => {
+  const obj = { a: 'string' }
+  set(obj, 'a.b.c', 'value')
+  assert.type(obj.a, 'object')
+  assert.is(obj.a.b.c, 'value')
+})
+
+test('set - overwrites number intermediate value', () => {
+  const obj = { a: 42 }
+  set(obj, 'a.b.c', 'value')
+  assert.type(obj.a, 'object')
+  assert.is(obj.a.b.c, 'value')
+})
+
+test('set - overwrites boolean intermediate value', () => {
+  const obj = { a: true }
+  set(obj, 'a.b.c', 'value')
+  assert.type(obj.a, 'object')
+  assert.is(obj.a.b.c, 'value')
+})
+
+test('set - overwrites false intermediate value', () => {
+  const obj = { a: false }
+  set(obj, 'a.b.c', 'value')
+  assert.type(obj.a, 'object')
+  assert.is(obj.a.b.c, 'value')
+})
+
+test('set - overwrites zero intermediate value', () => {
+  const obj = { a: 0 }
+  set(obj, 'a.b.c', 'value')
+  assert.type(obj.a, 'object')
+  assert.is(obj.a.b.c, 'value')
+})
+
+test('set - overwrites empty string intermediate value', () => {
+  const obj = { a: '' }
+  set(obj, 'a.b.c', 'value')
+  assert.type(obj.a, 'object')
+  assert.is(obj.a.b.c, 'value')
+})
+
+// ==========================================
+// set() - array handling with null/primitives
+// ==========================================
+
+test('set - creates array when overwriting null for numeric path', () => {
+  const obj = { items: null }
+  set(obj, 'items.0.name', 'value')
+  assert.ok(Array.isArray(obj.items))
+  assert.is(obj.items[0].name, 'value')
+})
+
+test('set - creates array when overwriting primitive for numeric path', () => {
+  const obj = { items: 'not an array' }
+  set(obj, 'items.0.name', 'value')
+  assert.ok(Array.isArray(obj.items))
+  assert.is(obj.items[0].name, 'value')
+})
+
+// ==========================================
+// trim() - basic functionality
+// ==========================================
+
+test('trim - removes whitespace from both ends', () => {
+  assert.is(trim('  hello  '), 'hello')
+})
+
+test('trim - handles null', () => {
+  assert.is(trim(null), '')
+})
+
+test('trim - handles undefined', () => {
+  assert.is(trim(undefined), '')
+})
+
+test('trim - removes custom characters', () => {
+  assert.is(trim('---hello---', '-'), 'hello')
+})
+
+test('trim - handles string with no trim needed', () => {
+  assert.is(trim('hello'), 'hello')
+})
+
+test.run()

package/src/utils/parsing/cloudformationSchema.js

@@ -6,6 +6,7 @@ const flatten = require('lodash.flatten');
 const map = require('lodash.map');
 
 const functionNames = [
+  // Standard intrinsic functions
   'And',
   'Base64',
   'Cidr',
@@ -23,6 +24,16 @@ const functionNames = [
   'Select',
   'Split',
   'Sub',
+  'Transform',
+  // AWS::LanguageExtensions functions
+  'ForEach',
+  'Length',
+  'ToJsonString',
+  // Rule-specific functions (valid in Rules section)
+  'EachMemberEquals',
+  'EachMemberIn',
+  'ValueOf',
+  'ValueOfAll',
 ];
 
 const yamlType = (name, kind) => {
@@ -31,8 +42,19 @@ const yamlType = (name, kind) => {
     kind,
     construct: data => {
       if (name === 'GetAtt') {
-        // special GetAtt dot syntax
-        return { [functionName]: isString(data) ? split(data, '.', 2) : data };
+        // special GetAtt dot syntax - split only at FIRST dot
+        // Attribute names can contain dots (e.g., Endpoint.Address, CertificateDetails.CAIdentifier)
+        if (isString(data)) {
+          const dotIndex = data.indexOf('.');
+          if (dotIndex === -1) {
+            return { [functionName]: [data] };
+          }
+          return { [functionName]: [
+            data.substring(0, dotIndex),      // Resource name (before first dot)
+            data.substring(dotIndex + 1)      // Attribute name (after first dot, may contain dots)
+          ]};
+        }
+        return { [functionName]: data };
       }
       return { [functionName]: data };
     },

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)) {