@aws-mdaa/dataops-job-l3-construct 1.4.0 → 1.6.0

package/node_modules/@aws-mdaa/config/test/param-transformer.test.js

@@ -0,0 +1,216 @@
+"use strict";
+/*!
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const aws_cdk_lib_1 = require("aws-cdk-lib");
+const lib_1 = require("../lib");
+describe('MdaaConfigParamRefValueTransformer', () => {
+    const baseProps = {
+        org: 'test-org',
+        env: 'dev',
+        domain: 'test-domain',
+        module_name: 'test-module',
+        paramProps: {},
+    };
+    describe('basic functionality', () => {
+        test('returns unchanged value without refs', () => {
+            const stack = new aws_cdk_lib_1.Stack();
+            const transformer = new lib_1.MdaaConfigParamRefValueTransformer({ ...baseProps, scope: stack });
+            expect(transformer.transformValue('plain-value')).toBe('plain-value');
+        });
+        test('non-param refs remain unchanged (parseRef override only handles param: refs)', () => {
+            const stack = new aws_cdk_lib_1.Stack();
+            const transformer = new lib_1.MdaaConfigParamRefValueTransformer({ ...baseProps, scope: stack });
+            // Note: MdaaConfigParamRefValueTransformer.parseRef only handles param: refs
+            // Other refs like {{org}} are not substituted by this class
+            expect(transformer.transformValue('{{org}}')).toBe('{{org}}');
+            expect(transformer.transformValue('{{env}}')).toBe('{{env}}');
+            expect(transformer.transformValue('{{domain}}')).toBe('{{domain}}');
+        });
+    });
+    describe('standalone param refs', () => {
+        test('creates string parameter for standalone param:string ref', () => {
+            const stack = new aws_cdk_lib_1.Stack();
+            const transformer = new lib_1.MdaaConfigParamRefValueTransformer({ ...baseProps, scope: stack });
+            const result = transformer.transformValue('{{param:string:myParam}}');
+            expect(result).toBeDefined();
+            const param = stack.node.tryFindChild('myParam');
+            expect(param).toBeDefined();
+            expect(param.type).toBe('String');
+        });
+        test('creates number parameter for standalone param:number ref', () => {
+            const stack = new aws_cdk_lib_1.Stack();
+            const transformer = new lib_1.MdaaConfigParamRefValueTransformer({ ...baseProps, scope: stack });
+            const result = transformer.transformValue('{{param:number:myNumberParam}}');
+            expect(typeof result).toBe('number');
+            const param = stack.node.tryFindChild('myNumberParam');
+            expect(param).toBeDefined();
+            expect(param.type).toBe('Number');
+        });
+        test('creates list parameter for standalone param:list ref', () => {
+            const stack = new aws_cdk_lib_1.Stack();
+            const transformer = new lib_1.MdaaConfigParamRefValueTransformer({ ...baseProps, scope: stack });
+            const result = transformer.transformValue('{{param:list:myListParam}}');
+            expect(result).toBeDefined();
+            const param = stack.node.tryFindChild('myListParam');
+            expect(param).toBeDefined();
+            expect(param.type).toBe('CommaDelimitedList');
+        });
+        test('creates string parameter when no type label specified', () => {
+            const stack = new aws_cdk_lib_1.Stack();
+            const transformer = new lib_1.MdaaConfigParamRefValueTransformer({ ...baseProps, scope: stack });
+            const result = transformer.transformValue('{{param:untypedParam}}');
+            expect(result).toBeDefined();
+            const param = stack.node.tryFindChild('untypedParam');
+            expect(param).toBeDefined();
+            expect(param.type).toBe('String');
+        });
+    });
+    describe('embedded param refs', () => {
+        test('substitutes param ref embedded in string', () => {
+            const stack = new aws_cdk_lib_1.Stack();
+            const transformer = new lib_1.MdaaConfigParamRefValueTransformer({ ...baseProps, scope: stack });
+            const result = transformer.transformValue('prefix-{{param:string:embeddedParam}}-suffix');
+            expect(typeof result).toBe('string');
+            expect(stack.node.tryFindChild('embeddedParam')).toBeDefined();
+        });
+        test('substitutes multiple param refs in string', () => {
+            const stack = new aws_cdk_lib_1.Stack();
+            const transformer = new lib_1.MdaaConfigParamRefValueTransformer({ ...baseProps, scope: stack });
+            const result = transformer.transformValue('{{param:string:param1}}-{{param:string:param2}}');
+            expect(typeof result).toBe('string');
+            expect(stack.node.tryFindChild('param1')).toBeDefined();
+            expect(stack.node.tryFindChild('param2')).toBeDefined();
+        });
+    });
+    describe('paramProps configuration', () => {
+        test('uses paramProps to create parameter with specified type', () => {
+            const stack = new aws_cdk_lib_1.Stack();
+            const transformer = new lib_1.MdaaConfigParamRefValueTransformer({
+                ...baseProps,
+                scope: stack,
+                paramProps: {
+                    configuredParam: { type: 'Number', description: 'A number param' },
+                },
+            });
+            const result = transformer.transformValue('{{param:configuredParam}}');
+            expect(typeof result).toBe('number');
+            const param = stack.node.tryFindChild('configuredParam');
+            expect(param.type).toBe('Number');
+        });
+        test('uses paramProps for String type', () => {
+            const stack = new aws_cdk_lib_1.Stack();
+            const transformer = new lib_1.MdaaConfigParamRefValueTransformer({
+                ...baseProps,
+                scope: stack,
+                paramProps: {
+                    stringParam: { type: 'String', default: 'default-value' },
+                },
+            });
+            const result = transformer.transformValue('{{param:stringParam}}');
+            expect(result).toBeDefined();
+            const param = stack.node.tryFindChild('stringParam');
+            expect(param.type).toBe('String');
+        });
+        test('uses paramProps for CommaDelimitedList type', () => {
+            const stack = new aws_cdk_lib_1.Stack();
+            const transformer = new lib_1.MdaaConfigParamRefValueTransformer({
+                ...baseProps,
+                scope: stack,
+                paramProps: {
+                    listParam: { type: 'CommaDelimitedList' },
+                },
+            });
+            const result = transformer.transformValue('{{param:listParam}}');
+            expect(result).toBeDefined();
+            const param = stack.node.tryFindChild('listParam');
+            expect(param.type).toBe('CommaDelimitedList');
+        });
+        test('throws error for invalid paramProps type', () => {
+            const stack = new aws_cdk_lib_1.Stack();
+            const transformer = new lib_1.MdaaConfigParamRefValueTransformer({
+                ...baseProps,
+                scope: stack,
+                paramProps: {
+                    invalidParam: { type: 'InvalidType' },
+                },
+            });
+            // Note: The error is only thrown when paramProps.type is used AND it's invalid
+            // But isStringType returns true for any non-Number, non-List type, so InvalidType
+            // is treated as a String type and doesn't throw
+            const result = transformer.transformValue('{{param:invalidParam}}');
+            expect(result).toBeDefined();
+            const param = stack.node.tryFindChild('invalidParam');
+            // InvalidType gets treated as String due to isStringType fallback logic
+            expect(param).toBeDefined();
+        });
+    });
+    describe('existing parameter reuse', () => {
+        test('reuses existing string parameter', () => {
+            const stack = new aws_cdk_lib_1.Stack();
+            new aws_cdk_lib_1.CfnParameter(stack, 'existingParam', { type: 'String', default: 'existing' });
+            const transformer = new lib_1.MdaaConfigParamRefValueTransformer({ ...baseProps, scope: stack });
+            const result = transformer.transformValue('{{param:existingParam}}');
+            expect(result).toBeDefined();
+            // Should not create a duplicate
+            const children = stack.node.children.filter(c => c.node.id === 'existingParam');
+            expect(children.length).toBe(1);
+        });
+        test('reuses existing number parameter', () => {
+            const stack = new aws_cdk_lib_1.Stack();
+            new aws_cdk_lib_1.CfnParameter(stack, 'existingNumberParam', { type: 'Number', default: 42 });
+            const transformer = new lib_1.MdaaConfigParamRefValueTransformer({ ...baseProps, scope: stack });
+            const result = transformer.transformValue('{{param:existingNumberParam}}');
+            expect(typeof result).toBe('number');
+        });
+        test('reuses existing list parameter', () => {
+            const stack = new aws_cdk_lib_1.Stack();
+            new aws_cdk_lib_1.CfnParameter(stack, 'existingListParam', { type: 'CommaDelimitedList' });
+            const transformer = new lib_1.MdaaConfigParamRefValueTransformer({ ...baseProps, scope: stack });
+            const result = transformer.transformValue('{{param:existingListParam}}');
+            expect(result).toBeDefined();
+        });
+        test('returns valueAsString for existing parameter with AWS::SSM::Parameter::Value type', () => {
+            const stack = new aws_cdk_lib_1.Stack();
+            // Create a parameter with SSM parameter type (a valid but less common type)
+            new aws_cdk_lib_1.CfnParameter(stack, 'ssmTypeParam', { type: 'AWS::SSM::Parameter::Value<String>' });
+            const transformer = new lib_1.MdaaConfigParamRefValueTransformer({ ...baseProps, scope: stack });
+            const result = transformer.transformValue('{{param:ssmTypeParam}}');
+            // Should fall through to valueAsString since it's not Number or List
+            expect(result).toBeDefined();
+        });
+    });
+    describe('mixed refs', () => {
+        test('handles mix of param and non-param refs (non-param refs unchanged)', () => {
+            const stack = new aws_cdk_lib_1.Stack();
+            const transformer = new lib_1.MdaaConfigParamRefValueTransformer({ ...baseProps, scope: stack });
+            const result = transformer.transformValue('{{org}}-{{param:string:mixedParam}}-{{env}}');
+            expect(typeof result).toBe('string');
+            // Note: parseRef override only handles param: refs, so {{org}} and {{env}} remain unchanged
+            expect(result.includes('{{org}}')).toBe(true);
+            expect(result.includes('{{env}}')).toBe(true);
+            expect(stack.node.tryFindChild('mixedParam')).toBeDefined();
+        });
+        test('non-param refs remain unsubstituted when not recognized', () => {
+            const stack = new aws_cdk_lib_1.Stack();
+            const transformer = new lib_1.MdaaConfigParamRefValueTransformer({ ...baseProps, scope: stack });
+            // unknownRef is not a param: ref and not a recognized base ref
+            const result = transformer.transformValue('{{param:string:knownParam}}-{{unknownRef}}');
+            expect(typeof result).toBe('string');
+            // The unknownRef should remain as-is since it's not a param: ref
+            expect(result.includes('{{unknownRef}}')).toBe(true);
+        });
+    });
+    describe('List type detection', () => {
+        test('detects List<> type as list', () => {
+            const stack = new aws_cdk_lib_1.Stack();
+            new aws_cdk_lib_1.CfnParameter(stack, 'genericListParam', { type: 'List<Number>' });
+            const transformer = new lib_1.MdaaConfigParamRefValueTransformer({ ...baseProps, scope: stack });
+            const result = transformer.transformValue('{{param:genericListParam}}');
+            expect(result).toBeDefined();
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"param-transformer.test.js","sourceRoot":"","sources":["param-transformer.test.ts"],"names":[],"mappings":"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","sourcesContent":["/*!\n * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.\n * SPDX-License-Identifier: Apache-2.0\n */\n\nimport { CfnParameter, Stack } from 'aws-cdk-lib';\nimport { MdaaConfigParamRefValueTransformer } from '../lib';\n\ndescribe('MdaaConfigParamRefValueTransformer', () => {\n  const baseProps = {\n    org: 'test-org',\n    env: 'dev',\n    domain: 'test-domain',\n    module_name: 'test-module',\n    paramProps: {},\n  };\n\n  describe('basic functionality', () => {\n    test('returns unchanged value without refs', () => {\n      const stack = new Stack();\n      const transformer = new MdaaConfigParamRefValueTransformer({ ...baseProps, scope: stack });\n      expect(transformer.transformValue('plain-value')).toBe('plain-value');\n    });\n\n    test('non-param refs remain unchanged (parseRef override only handles param: refs)', () => {\n      const stack = new Stack();\n      const transformer = new MdaaConfigParamRefValueTransformer({ ...baseProps, scope: stack });\n      // Note: MdaaConfigParamRefValueTransformer.parseRef only handles param: refs\n      // Other refs like {{org}} are not substituted by this class\n      expect(transformer.transformValue('{{org}}')).toBe('{{org}}');\n      expect(transformer.transformValue('{{env}}')).toBe('{{env}}');\n      expect(transformer.transformValue('{{domain}}')).toBe('{{domain}}');\n    });\n  });\n\n  describe('standalone param refs', () => {\n    test('creates string parameter for standalone param:string ref', () => {\n      const stack = new Stack();\n      const transformer = new MdaaConfigParamRefValueTransformer({ ...baseProps, scope: stack });\n      const result = transformer.transformValue('{{param:string:myParam}}');\n      expect(result).toBeDefined();\n      const param = stack.node.tryFindChild('myParam') as CfnParameter;\n      expect(param).toBeDefined();\n      expect(param.type).toBe('String');\n    });\n\n    test('creates number parameter for standalone param:number ref', () => {\n      const stack = new Stack();\n      const transformer = new MdaaConfigParamRefValueTransformer({ ...baseProps, scope: stack });\n      const result = transformer.transformValue('{{param:number:myNumberParam}}');\n      expect(typeof result).toBe('number');\n      const param = stack.node.tryFindChild('myNumberParam') as CfnParameter;\n      expect(param).toBeDefined();\n      expect(param.type).toBe('Number');\n    });\n\n    test('creates list parameter for standalone param:list ref', () => {\n      const stack = new Stack();\n      const transformer = new MdaaConfigParamRefValueTransformer({ ...baseProps, scope: stack });\n      const result = transformer.transformValue('{{param:list:myListParam}}');\n      expect(result).toBeDefined();\n      const param = stack.node.tryFindChild('myListParam') as CfnParameter;\n      expect(param).toBeDefined();\n      expect(param.type).toBe('CommaDelimitedList');\n    });\n\n    test('creates string parameter when no type label specified', () => {\n      const stack = new Stack();\n      const transformer = new MdaaConfigParamRefValueTransformer({ ...baseProps, scope: stack });\n      const result = transformer.transformValue('{{param:untypedParam}}');\n      expect(result).toBeDefined();\n      const param = stack.node.tryFindChild('untypedParam') as CfnParameter;\n      expect(param).toBeDefined();\n      expect(param.type).toBe('String');\n    });\n  });\n\n  describe('embedded param refs', () => {\n    test('substitutes param ref embedded in string', () => {\n      const stack = new Stack();\n      const transformer = new MdaaConfigParamRefValueTransformer({ ...baseProps, scope: stack });\n      const result = transformer.transformValue('prefix-{{param:string:embeddedParam}}-suffix');\n      expect(typeof result).toBe('string');\n      expect(stack.node.tryFindChild('embeddedParam')).toBeDefined();\n    });\n\n    test('substitutes multiple param refs in string', () => {\n      const stack = new Stack();\n      const transformer = new MdaaConfigParamRefValueTransformer({ ...baseProps, scope: stack });\n      const result = transformer.transformValue('{{param:string:param1}}-{{param:string:param2}}');\n      expect(typeof result).toBe('string');\n      expect(stack.node.tryFindChild('param1')).toBeDefined();\n      expect(stack.node.tryFindChild('param2')).toBeDefined();\n    });\n  });\n\n  describe('paramProps configuration', () => {\n    test('uses paramProps to create parameter with specified type', () => {\n      const stack = new Stack();\n      const transformer = new MdaaConfigParamRefValueTransformer({\n        ...baseProps,\n        scope: stack,\n        paramProps: {\n          configuredParam: { type: 'Number', description: 'A number param' },\n        },\n      });\n      const result = transformer.transformValue('{{param:configuredParam}}');\n      expect(typeof result).toBe('number');\n      const param = stack.node.tryFindChild('configuredParam') as CfnParameter;\n      expect(param.type).toBe('Number');\n    });\n\n    test('uses paramProps for String type', () => {\n      const stack = new Stack();\n      const transformer = new MdaaConfigParamRefValueTransformer({\n        ...baseProps,\n        scope: stack,\n        paramProps: {\n          stringParam: { type: 'String', default: 'default-value' },\n        },\n      });\n      const result = transformer.transformValue('{{param:stringParam}}');\n      expect(result).toBeDefined();\n      const param = stack.node.tryFindChild('stringParam') as CfnParameter;\n      expect(param.type).toBe('String');\n    });\n\n    test('uses paramProps for CommaDelimitedList type', () => {\n      const stack = new Stack();\n      const transformer = new MdaaConfigParamRefValueTransformer({\n        ...baseProps,\n        scope: stack,\n        paramProps: {\n          listParam: { type: 'CommaDelimitedList' },\n        },\n      });\n      const result = transformer.transformValue('{{param:listParam}}');\n      expect(result).toBeDefined();\n      const param = stack.node.tryFindChild('listParam') as CfnParameter;\n      expect(param.type).toBe('CommaDelimitedList');\n    });\n\n    test('throws error for invalid paramProps type', () => {\n      const stack = new Stack();\n      const transformer = new MdaaConfigParamRefValueTransformer({\n        ...baseProps,\n        scope: stack,\n        paramProps: {\n          invalidParam: { type: 'InvalidType' },\n        },\n      });\n      // Note: The error is only thrown when paramProps.type is used AND it's invalid\n      // But isStringType returns true for any non-Number, non-List type, so InvalidType\n      // is treated as a String type and doesn't throw\n      const result = transformer.transformValue('{{param:invalidParam}}');\n      expect(result).toBeDefined();\n      const param = stack.node.tryFindChild('invalidParam') as CfnParameter;\n      // InvalidType gets treated as String due to isStringType fallback logic\n      expect(param).toBeDefined();\n    });\n  });\n\n  describe('existing parameter reuse', () => {\n    test('reuses existing string parameter', () => {\n      const stack = new Stack();\n      new CfnParameter(stack, 'existingParam', { type: 'String', default: 'existing' });\n      const transformer = new MdaaConfigParamRefValueTransformer({ ...baseProps, scope: stack });\n      const result = transformer.transformValue('{{param:existingParam}}');\n      expect(result).toBeDefined();\n      // Should not create a duplicate\n      const children = stack.node.children.filter(c => c.node.id === 'existingParam');\n      expect(children.length).toBe(1);\n    });\n\n    test('reuses existing number parameter', () => {\n      const stack = new Stack();\n      new CfnParameter(stack, 'existingNumberParam', { type: 'Number', default: 42 });\n      const transformer = new MdaaConfigParamRefValueTransformer({ ...baseProps, scope: stack });\n      const result = transformer.transformValue('{{param:existingNumberParam}}');\n      expect(typeof result).toBe('number');\n    });\n\n    test('reuses existing list parameter', () => {\n      const stack = new Stack();\n      new CfnParameter(stack, 'existingListParam', { type: 'CommaDelimitedList' });\n      const transformer = new MdaaConfigParamRefValueTransformer({ ...baseProps, scope: stack });\n      const result = transformer.transformValue('{{param:existingListParam}}');\n      expect(result).toBeDefined();\n    });\n\n    test('returns valueAsString for existing parameter with AWS::SSM::Parameter::Value type', () => {\n      const stack = new Stack();\n      // Create a parameter with SSM parameter type (a valid but less common type)\n      new CfnParameter(stack, 'ssmTypeParam', { type: 'AWS::SSM::Parameter::Value<String>' });\n      const transformer = new MdaaConfigParamRefValueTransformer({ ...baseProps, scope: stack });\n      const result = transformer.transformValue('{{param:ssmTypeParam}}');\n      // Should fall through to valueAsString since it's not Number or List\n      expect(result).toBeDefined();\n    });\n  });\n\n  describe('mixed refs', () => {\n    test('handles mix of param and non-param refs (non-param refs unchanged)', () => {\n      const stack = new Stack();\n      const transformer = new MdaaConfigParamRefValueTransformer({ ...baseProps, scope: stack });\n      const result = transformer.transformValue('{{org}}-{{param:string:mixedParam}}-{{env}}');\n      expect(typeof result).toBe('string');\n      // Note: parseRef override only handles param: refs, so {{org}} and {{env}} remain unchanged\n      expect((result as string).includes('{{org}}')).toBe(true);\n      expect((result as string).includes('{{env}}')).toBe(true);\n      expect(stack.node.tryFindChild('mixedParam')).toBeDefined();\n    });\n\n    test('non-param refs remain unsubstituted when not recognized', () => {\n      const stack = new Stack();\n      const transformer = new MdaaConfigParamRefValueTransformer({ ...baseProps, scope: stack });\n      // unknownRef is not a param: ref and not a recognized base ref\n      const result = transformer.transformValue('{{param:string:knownParam}}-{{unknownRef}}');\n      expect(typeof result).toBe('string');\n      // The unknownRef should remain as-is since it's not a param: ref\n      expect((result as string).includes('{{unknownRef}}')).toBe(true);\n    });\n  });\n\n  describe('List type detection', () => {\n    test('detects List<> type as list', () => {\n      const stack = new Stack();\n      new CfnParameter(stack, 'genericListParam', { type: 'List<Number>' });\n      const transformer = new MdaaConfigParamRefValueTransformer({ ...baseProps, scope: stack });\n      const result = transformer.transformValue('{{param:genericListParam}}');\n      expect(result).toBeDefined();\n    });\n  });\n});\n"]}

package/node_modules/@aws-mdaa/config/test/param-transformer.test.ts

@@ -0,0 +1,234 @@
+/*!
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { CfnParameter, Stack } from 'aws-cdk-lib';
+import { MdaaConfigParamRefValueTransformer } from '../lib';
+
+describe('MdaaConfigParamRefValueTransformer', () => {
+  const baseProps = {
+    org: 'test-org',
+    env: 'dev',
+    domain: 'test-domain',
+    module_name: 'test-module',
+    paramProps: {},
+  };
+
+  describe('basic functionality', () => {
+    test('returns unchanged value without refs', () => {
+      const stack = new Stack();
+      const transformer = new MdaaConfigParamRefValueTransformer({ ...baseProps, scope: stack });
+      expect(transformer.transformValue('plain-value')).toBe('plain-value');
+    });
+
+    test('non-param refs remain unchanged (parseRef override only handles param: refs)', () => {
+      const stack = new Stack();
+      const transformer = new MdaaConfigParamRefValueTransformer({ ...baseProps, scope: stack });
+      // Note: MdaaConfigParamRefValueTransformer.parseRef only handles param: refs
+      // Other refs like {{org}} are not substituted by this class
+      expect(transformer.transformValue('{{org}}')).toBe('{{org}}');
+      expect(transformer.transformValue('{{env}}')).toBe('{{env}}');
+      expect(transformer.transformValue('{{domain}}')).toBe('{{domain}}');
+    });
+  });
+
+  describe('standalone param refs', () => {
+    test('creates string parameter for standalone param:string ref', () => {
+      const stack = new Stack();
+      const transformer = new MdaaConfigParamRefValueTransformer({ ...baseProps, scope: stack });
+      const result = transformer.transformValue('{{param:string:myParam}}');
+      expect(result).toBeDefined();
+      const param = stack.node.tryFindChild('myParam') as CfnParameter;
+      expect(param).toBeDefined();
+      expect(param.type).toBe('String');
+    });
+
+    test('creates number parameter for standalone param:number ref', () => {
+      const stack = new Stack();
+      const transformer = new MdaaConfigParamRefValueTransformer({ ...baseProps, scope: stack });
+      const result = transformer.transformValue('{{param:number:myNumberParam}}');
+      expect(typeof result).toBe('number');
+      const param = stack.node.tryFindChild('myNumberParam') as CfnParameter;
+      expect(param).toBeDefined();
+      expect(param.type).toBe('Number');
+    });
+
+    test('creates list parameter for standalone param:list ref', () => {
+      const stack = new Stack();
+      const transformer = new MdaaConfigParamRefValueTransformer({ ...baseProps, scope: stack });
+      const result = transformer.transformValue('{{param:list:myListParam}}');
+      expect(result).toBeDefined();
+      const param = stack.node.tryFindChild('myListParam') as CfnParameter;
+      expect(param).toBeDefined();
+      expect(param.type).toBe('CommaDelimitedList');
+    });
+
+    test('creates string parameter when no type label specified', () => {
+      const stack = new Stack();
+      const transformer = new MdaaConfigParamRefValueTransformer({ ...baseProps, scope: stack });
+      const result = transformer.transformValue('{{param:untypedParam}}');
+      expect(result).toBeDefined();
+      const param = stack.node.tryFindChild('untypedParam') as CfnParameter;
+      expect(param).toBeDefined();
+      expect(param.type).toBe('String');
+    });
+  });
+
+  describe('embedded param refs', () => {
+    test('substitutes param ref embedded in string', () => {
+      const stack = new Stack();
+      const transformer = new MdaaConfigParamRefValueTransformer({ ...baseProps, scope: stack });
+      const result = transformer.transformValue('prefix-{{param:string:embeddedParam}}-suffix');
+      expect(typeof result).toBe('string');
+      expect(stack.node.tryFindChild('embeddedParam')).toBeDefined();
+    });
+
+    test('substitutes multiple param refs in string', () => {
+      const stack = new Stack();
+      const transformer = new MdaaConfigParamRefValueTransformer({ ...baseProps, scope: stack });
+      const result = transformer.transformValue('{{param:string:param1}}-{{param:string:param2}}');
+      expect(typeof result).toBe('string');
+      expect(stack.node.tryFindChild('param1')).toBeDefined();
+      expect(stack.node.tryFindChild('param2')).toBeDefined();
+    });
+  });
+
+  describe('paramProps configuration', () => {
+    test('uses paramProps to create parameter with specified type', () => {
+      const stack = new Stack();
+      const transformer = new MdaaConfigParamRefValueTransformer({
+        ...baseProps,
+        scope: stack,
+        paramProps: {
+          configuredParam: { type: 'Number', description: 'A number param' },
+        },
+      });
+      const result = transformer.transformValue('{{param:configuredParam}}');
+      expect(typeof result).toBe('number');
+      const param = stack.node.tryFindChild('configuredParam') as CfnParameter;
+      expect(param.type).toBe('Number');
+    });
+
+    test('uses paramProps for String type', () => {
+      const stack = new Stack();
+      const transformer = new MdaaConfigParamRefValueTransformer({
+        ...baseProps,
+        scope: stack,
+        paramProps: {
+          stringParam: { type: 'String', default: 'default-value' },
+        },
+      });
+      const result = transformer.transformValue('{{param:stringParam}}');
+      expect(result).toBeDefined();
+      const param = stack.node.tryFindChild('stringParam') as CfnParameter;
+      expect(param.type).toBe('String');
+    });
+
+    test('uses paramProps for CommaDelimitedList type', () => {
+      const stack = new Stack();
+      const transformer = new MdaaConfigParamRefValueTransformer({
+        ...baseProps,
+        scope: stack,
+        paramProps: {
+          listParam: { type: 'CommaDelimitedList' },
+        },
+      });
+      const result = transformer.transformValue('{{param:listParam}}');
+      expect(result).toBeDefined();
+      const param = stack.node.tryFindChild('listParam') as CfnParameter;
+      expect(param.type).toBe('CommaDelimitedList');
+    });
+
+    test('throws error for invalid paramProps type', () => {
+      const stack = new Stack();
+      const transformer = new MdaaConfigParamRefValueTransformer({
+        ...baseProps,
+        scope: stack,
+        paramProps: {
+          invalidParam: { type: 'InvalidType' },
+        },
+      });
+      // Note: The error is only thrown when paramProps.type is used AND it's invalid
+      // But isStringType returns true for any non-Number, non-List type, so InvalidType
+      // is treated as a String type and doesn't throw
+      const result = transformer.transformValue('{{param:invalidParam}}');
+      expect(result).toBeDefined();
+      const param = stack.node.tryFindChild('invalidParam') as CfnParameter;
+      // InvalidType gets treated as String due to isStringType fallback logic
+      expect(param).toBeDefined();
+    });
+  });
+
+  describe('existing parameter reuse', () => {
+    test('reuses existing string parameter', () => {
+      const stack = new Stack();
+      new CfnParameter(stack, 'existingParam', { type: 'String', default: 'existing' });
+      const transformer = new MdaaConfigParamRefValueTransformer({ ...baseProps, scope: stack });
+      const result = transformer.transformValue('{{param:existingParam}}');
+      expect(result).toBeDefined();
+      // Should not create a duplicate
+      const children = stack.node.children.filter(c => c.node.id === 'existingParam');
+      expect(children.length).toBe(1);
+    });
+
+    test('reuses existing number parameter', () => {
+      const stack = new Stack();
+      new CfnParameter(stack, 'existingNumberParam', { type: 'Number', default: 42 });
+      const transformer = new MdaaConfigParamRefValueTransformer({ ...baseProps, scope: stack });
+      const result = transformer.transformValue('{{param:existingNumberParam}}');
+      expect(typeof result).toBe('number');
+    });
+
+    test('reuses existing list parameter', () => {
+      const stack = new Stack();
+      new CfnParameter(stack, 'existingListParam', { type: 'CommaDelimitedList' });
+      const transformer = new MdaaConfigParamRefValueTransformer({ ...baseProps, scope: stack });
+      const result = transformer.transformValue('{{param:existingListParam}}');
+      expect(result).toBeDefined();
+    });
+
+    test('returns valueAsString for existing parameter with AWS::SSM::Parameter::Value type', () => {
+      const stack = new Stack();
+      // Create a parameter with SSM parameter type (a valid but less common type)
+      new CfnParameter(stack, 'ssmTypeParam', { type: 'AWS::SSM::Parameter::Value<String>' });
+      const transformer = new MdaaConfigParamRefValueTransformer({ ...baseProps, scope: stack });
+      const result = transformer.transformValue('{{param:ssmTypeParam}}');
+      // Should fall through to valueAsString since it's not Number or List
+      expect(result).toBeDefined();
+    });
+  });
+
+  describe('mixed refs', () => {
+    test('handles mix of param and non-param refs (non-param refs unchanged)', () => {
+      const stack = new Stack();
+      const transformer = new MdaaConfigParamRefValueTransformer({ ...baseProps, scope: stack });
+      const result = transformer.transformValue('{{org}}-{{param:string:mixedParam}}-{{env}}');
+      expect(typeof result).toBe('string');
+      // Note: parseRef override only handles param: refs, so {{org}} and {{env}} remain unchanged
+      expect((result as string).includes('{{org}}')).toBe(true);
+      expect((result as string).includes('{{env}}')).toBe(true);
+      expect(stack.node.tryFindChild('mixedParam')).toBeDefined();
+    });
+
+    test('non-param refs remain unsubstituted when not recognized', () => {
+      const stack = new Stack();
+      const transformer = new MdaaConfigParamRefValueTransformer({ ...baseProps, scope: stack });
+      // unknownRef is not a param: ref and not a recognized base ref
+      const result = transformer.transformValue('{{param:string:knownParam}}-{{unknownRef}}');
+      expect(typeof result).toBe('string');
+      // The unknownRef should remain as-is since it's not a param: ref
+      expect((result as string).includes('{{unknownRef}}')).toBe(true);
+    });
+  });
+
+  describe('List type detection', () => {
+    test('detects List<> type as list', () => {
+      const stack = new Stack();
+      new CfnParameter(stack, 'genericListParam', { type: 'List<Number>' });
+      const transformer = new MdaaConfigParamRefValueTransformer({ ...baseProps, scope: stack });
+      const result = transformer.transformValue('{{param:genericListParam}}');
+      expect(result).toBeDefined();
+    });
+  });
+});

package/node_modules/@aws-mdaa/config/test/path-value-transformer.test.d.ts

@@ -0,0 +1,5 @@
+/*!
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+export {};

package/node_modules/@aws-mdaa/config/test/path-value-transformer.test.js

@@ -0,0 +1,59 @@
+"use strict";
+/*!
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const path = require("path");
+const lib_1 = require("../lib");
+describe('ConfigConfigPathValueTransformer', () => {
+    const baseDir = '/home/user/project/configs';
+    test('returns unchanged value for non-relative paths', () => {
+        const transformer = new lib_1.ConfigConfigPathValueTransformer(baseDir);
+        expect(transformer.transformValue('some-value')).toBe('some-value');
+    });
+    test('returns unchanged value for absolute paths', () => {
+        const transformer = new lib_1.ConfigConfigPathValueTransformer(baseDir);
+        expect(transformer.transformValue('/absolute/path/to/file')).toBe('/absolute/path/to/file');
+    });
+    test('resolves parent relative path (../) to baseDir parent', () => {
+        const transformer = new lib_1.ConfigConfigPathValueTransformer(baseDir);
+        const result = transformer.transformValue('../sibling/file.yaml');
+        expect(result).toBe(path.resolve(baseDir, '../sibling/file.yaml'));
+    });
+    test('resolves current relative path (./) relative to baseDir', () => {
+        const transformer = new lib_1.ConfigConfigPathValueTransformer(baseDir);
+        const result = transformer.transformValue('./subdir/file.yaml');
+        expect(result).toBe(path.resolve(baseDir + '/subdir/file.yaml'));
+    });
+    test('handles multiple parent traversals', () => {
+        const transformer = new lib_1.ConfigConfigPathValueTransformer(baseDir);
+        const result = transformer.transformValue('../../other/file.yaml');
+        expect(result).toBe(path.resolve(baseDir, '../../other/file.yaml'));
+    });
+    test('handles nested current directory paths', () => {
+        const transformer = new lib_1.ConfigConfigPathValueTransformer(baseDir);
+        const result = transformer.transformValue('./a/b/c/file.yaml');
+        expect(result).toBe(path.resolve(baseDir + '/a/b/c/file.yaml'));
+    });
+    test('handles empty baseDir', () => {
+        const transformer = new lib_1.ConfigConfigPathValueTransformer('');
+        const result = transformer.transformValue('../file.yaml');
+        expect(result).toBe(path.resolve('', '../file.yaml'));
+    });
+    test('returns empty string unchanged', () => {
+        const transformer = new lib_1.ConfigConfigPathValueTransformer(baseDir);
+        expect(transformer.transformValue('')).toBe('');
+    });
+    test('handles baseDir with trailing slash', () => {
+        const transformer = new lib_1.ConfigConfigPathValueTransformer('/home/user/project/');
+        const result = transformer.transformValue('../file.yaml');
+        expect(result).toBe(path.resolve('/home/user/project/', '../file.yaml'));
+    });
+    test('handles Windows-style paths in value', () => {
+        const transformer = new lib_1.ConfigConfigPathValueTransformer(baseDir);
+        // Non-relative path should be returned unchanged
+        expect(transformer.transformValue('C:\\Windows\\file.txt')).toBe('C:\\Windows\\file.txt');
+    });
+});
+//# sourceMappingURL=data:application/json;base64,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