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

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

@@ -0,0 +1,224 @@
+"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('MdaaConfigBlueprintRefValueTransformer', () => {
+    let mockNaming;
+    let stack;
+    beforeEach(() => {
+        stack = new aws_cdk_lib_1.Stack();
+        mockNaming = {
+            props: {
+                org: 'test-org',
+                env: 'test-env',
+                domain: 'test-domain',
+                moduleName: 'test-module',
+            },
+            withModuleName: jest.fn().mockReturnThis(),
+            withDomain: jest.fn().mockReturnThis(),
+            withOrg: jest.fn().mockReturnThis(),
+            withEnv: jest.fn().mockReturnThis(),
+            withSuffix: jest.fn().mockReturnThis(),
+            ssmDomainPath: jest.fn().mockReturnValue('/test/domain/path'),
+            ssmEnvPath: jest.fn().mockReturnValue('/test/env/path'),
+            ssmOrgPath: jest.fn().mockReturnValue('/test-org/'),
+            resourceName: jest
+                .fn()
+                .mockImplementation((suffix) => (suffix ? `test-resource-${suffix}` : 'test-resource')),
+            ssmPath: jest.fn().mockImplementation((path) => `/test/${path}`),
+            stackName: jest.fn().mockImplementation((name) => (name ? `test-stack-${name}` : 'test-stack')),
+            exportName: jest.fn().mockImplementation((path) => `test-export-${path}`),
+        };
+    });
+    test('returns unchanged value without refs', () => {
+        const transformer = new lib_1.MdaaConfigBlueprintRefValueTransformer({
+            naming: mockNaming,
+            scope: stack,
+        });
+        expect(transformer.transformValue('plain-value')).toBe('plain-value');
+    });
+    test('returns unchanged value with empty string', () => {
+        const transformer = new lib_1.MdaaConfigBlueprintRefValueTransformer({
+            naming: mockNaming,
+            scope: stack,
+        });
+        expect(transformer.transformValue('')).toBe('');
+    });
+    test('transforms blueprint ref', () => {
+        const transformer = new lib_1.MdaaConfigBlueprintRefValueTransformer({
+            naming: mockNaming,
+            scope: stack,
+        });
+        const result = transformer.transformValue('{{blueprint:/some/path}}');
+        expect(result).toContain('{{resolve:ssm:/test-org/');
+        expect(result).toContain('/some/path}}');
+        expect(mockNaming.ssmOrgPath).toHaveBeenCalledWith('', false);
+    });
+    test('transforms blueprint ref with prefix and suffix', () => {
+        const transformer = new lib_1.MdaaConfigBlueprintRefValueTransformer({
+            naming: mockNaming,
+            scope: stack,
+        });
+        const result = transformer.transformValue('prefix-{{blueprint:/path}}-suffix');
+        expect(result).toContain('prefix-');
+        expect(result).toContain('-suffix');
+        expect(result).toContain('{{resolve:ssm:');
+    });
+    test('handles multiple blueprint refs', () => {
+        const transformer = new lib_1.MdaaConfigBlueprintRefValueTransformer({
+            naming: mockNaming,
+            scope: stack,
+        });
+        const result = transformer.transformValue('{{blueprint:/path1}}-{{blueprint:/path2}}');
+        expect(result).toContain('/path1}}');
+        expect(result).toContain('/path2}}');
+    });
+    test('reuses existing CfnParameter for datazoneEnvironmentProjectId', () => {
+        const transformer = new lib_1.MdaaConfigBlueprintRefValueTransformer({
+            naming: mockNaming,
+            scope: stack,
+        });
+        // First call creates the parameter
+        transformer.transformValue('{{blueprint:/path1}}');
+        // Second call should reuse the same parameter
+        transformer.transformValue('{{blueprint:/path2}}');
+        // Should only have one datazoneEnvironmentProjectId parameter
+        const params = stack.node.children.filter(child => child.node.id === 'datazoneEnvironmentProjectId');
+        expect(params.length).toBe(1);
+    });
+    test('ignores non-blueprint refs', () => {
+        const transformer = new lib_1.MdaaConfigBlueprintRefValueTransformer({
+            naming: mockNaming,
+            scope: stack,
+        });
+        const result = transformer.transformValue('{{other:value}}');
+        // Non-blueprint refs should remain unchanged
+        expect(result).toBe('{{other:value}}');
+    });
+    test('handles nested refs in blueprint path', () => {
+        const transformer = new lib_1.MdaaConfigBlueprintRefValueTransformer({
+            naming: mockNaming,
+            scope: stack,
+        });
+        // Nested refs should be processed recursively
+        const result = transformer.transformValue('{{blueprint:/{{other}}/path}}');
+        // The inner ref is not a blueprint ref, so it stays as-is in the path
+        expect(result).toContain('{{resolve:ssm:');
+    });
+    test('handles unbalanced braces gracefully', () => {
+        const transformer = new lib_1.MdaaConfigBlueprintRefValueTransformer({
+            naming: mockNaming,
+            scope: stack,
+        });
+        // Unbalanced braces should be skipped
+        expect(transformer.transformValue('{{blueprint:/path')).toBe('{{blueprint:/path');
+        expect(transformer.transformValue('blueprint:/path}}')).toBe('blueprint:/path}}');
+    });
+    test('logs resolved blueprint path', () => {
+        const consoleSpy = jest.spyOn(console, 'log').mockImplementation();
+        const transformer = new lib_1.MdaaConfigBlueprintRefValueTransformer({
+            naming: mockNaming,
+            scope: stack,
+        });
+        transformer.transformValue('{{blueprint:/test/path}}');
+        expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('Resolving blueprint path:'));
+        consoleSpy.mockRestore();
+    });
+    test('handles blueprint ref with special characters in path', () => {
+        const transformer = new lib_1.MdaaConfigBlueprintRefValueTransformer({
+            naming: mockNaming,
+            scope: stack,
+        });
+        const result = transformer.transformValue('{{blueprint:/path/with-dashes_and_underscores/123}}');
+        expect(result).toContain('{{resolve:ssm:');
+        expect(result).toContain('/path/with-dashes_and_underscores/123}}');
+    });
+    test('handles blueprint ref at start of string', () => {
+        const transformer = new lib_1.MdaaConfigBlueprintRefValueTransformer({
+            naming: mockNaming,
+            scope: stack,
+        });
+        const result = transformer.transformValue('{{blueprint:/path}}-suffix');
+        expect(result).toMatch(/^\{\{resolve:ssm:/);
+        expect(result).toContain('-suffix');
+    });
+    test('handles blueprint ref at end of string', () => {
+        const transformer = new lib_1.MdaaConfigBlueprintRefValueTransformer({
+            naming: mockNaming,
+            scope: stack,
+        });
+        const result = transformer.transformValue('prefix-{{blueprint:/path}}');
+        expect(result).toContain('prefix-');
+        expect(result).toMatch(/\}\}$/);
+    });
+    test('handles multiple different ref types mixed', () => {
+        const transformer = new lib_1.MdaaConfigBlueprintRefValueTransformer({
+            naming: mockNaming,
+            scope: stack,
+        });
+        const result = transformer.transformValue('{{blueprint:/path1}}-{{other:ref}}-{{blueprint:/path2}}');
+        expect(result).toContain('/path1}}');
+        expect(result).toContain('{{other:ref}}');
+        expect(result).toContain('/path2}}');
+    });
+    test('handles empty blueprint path', () => {
+        const transformer = new lib_1.MdaaConfigBlueprintRefValueTransformer({
+            naming: mockNaming,
+            scope: stack,
+        });
+        const result = transformer.transformValue('{{blueprint:}}');
+        expect(result).toContain('{{resolve:ssm:');
+    });
+    test('handles blueprint ref with only slashes', () => {
+        const transformer = new lib_1.MdaaConfigBlueprintRefValueTransformer({
+            naming: mockNaming,
+            scope: stack,
+        });
+        const result = transformer.transformValue('{{blueprint:/}}');
+        expect(result).toContain('{{resolve:ssm:');
+        expect(result).toContain('/}}');
+    });
+    test('creates parameter on first blueprint ref', () => {
+        const transformer = new lib_1.MdaaConfigBlueprintRefValueTransformer({
+            naming: mockNaming,
+            scope: stack,
+        });
+        const childrenBefore = stack.node.children.length;
+        transformer.transformValue('{{blueprint:/first}}');
+        const childrenAfter = stack.node.children.length;
+        expect(childrenAfter).toBeGreaterThan(childrenBefore);
+    });
+    test('does not create duplicate parameters', () => {
+        const transformer = new lib_1.MdaaConfigBlueprintRefValueTransformer({
+            naming: mockNaming,
+            scope: stack,
+        });
+        transformer.transformValue('{{blueprint:/first}}');
+        const childrenAfterFirst = stack.node.children.length;
+        transformer.transformValue('{{blueprint:/second}}');
+        const childrenAfterSecond = stack.node.children.length;
+        // Should not create additional parameters
+        expect(childrenAfterSecond).toBe(childrenAfterFirst);
+    });
+    test('throws when blueprint ref without scope', () => {
+        const transformer = new lib_1.MdaaConfigBlueprintRefValueTransformer({
+            naming: mockNaming,
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            scope: undefined,
+        });
+        expect(() => transformer.transformValue('{{blueprint:/path}}')).toThrow('Unable to resolve blueprint params outside of a Construct');
+    });
+    test('throws when blueprint ref without naming', () => {
+        const transformer = new lib_1.MdaaConfigBlueprintRefValueTransformer({
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            naming: undefined,
+            scope: stack,
+        });
+        expect(() => transformer.transformValue('{{blueprint:/path}}')).toThrow('Unable to resolve blueprint params without a naming implementation');
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"blueprint-value-transformer.test.js","sourceRoot":"","sources":["blueprint-value-transformer.test.ts"],"names":[],"mappings":";AAAA;;;GAGG;;AAEH,6CAAoC;AACpC,gCAAgE;AAGhE,QAAQ,CAAC,wCAAwC,EAAE,GAAG,EAAE;IACtD,IAAI,UAA+B,CAAC;IACpC,IAAI,KAAY,CAAC;IAEjB,UAAU,CAAC,GAAG,EAAE;QACd,KAAK,GAAG,IAAI,mBAAK,EAAE,CAAC;QACpB,UAAU,GAAG;YACX,KAAK,EAAE;gBACL,GAAG,EAAE,UAAU;gBACf,GAAG,EAAE,UAAU;gBACf,MAAM,EAAE,aAAa;gBACrB,UAAU,EAAE,aAAa;aAC1B;YACD,cAAc,EAAE,IAAI,CAAC,EAAE,EAAE,CAAC,cAAc,EAAE;YAC1C,UAAU,EAAE,IAAI,CAAC,EAAE,EAAE,CAAC,cAAc,EAAE;YACtC,OAAO,EAAE,IAAI,CAAC,EAAE,EAAE,CAAC,cAAc,EAAE;YACnC,OAAO,EAAE,IAAI,CAAC,EAAE,EAAE,CAAC,cAAc,EAAE;YACnC,UAAU,EAAE,IAAI,CAAC,EAAE,EAAE,CAAC,cAAc,EAAE;YACtC,aAAa,EAAE,IAAI,CAAC,EAAE,EAAE,CAAC,eAAe,CAAC,mBAAmB,CAAC;YAC7D,UAAU,EAAE,IAAI,CAAC,EAAE,EAAE,CAAC,eAAe,CAAC,gBAAgB,CAAC;YACvD,UAAU,EAAE,IAAI,CAAC,EAAE,EAAE,CAAC,eAAe,CAAC,YAAY,CAAC;YACnD,YAAY,EAAE,IAAI;iBACf,EAAE,EAAE;iBACJ,kBAAkB,CAAC,CAAC,MAAe,EAAE,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,iBAAiB,MAAM,EAAE,CAAC,CAAC,CAAC,eAAe,CAAC,CAAC;YAClG,OAAO,EAAE,IAAI,CAAC,EAAE,EAAE,CAAC,kBAAkB,CAAC,CAAC,IAAY,EAAE,EAAE,CAAC,SAAS,IAAI,EAAE,CAAC;YACxE,SAAS,EAAE,IAAI,CAAC,EAAE,EAAE,CAAC,kBAAkB,CAAC,CAAC,IAAa,EAAE,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,cAAc,IAAI,EAAE,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC;YACxG,UAAU,EAAE,IAAI,CAAC,EAAE,EAAE,CAAC,kBAAkB,CAAC,CAAC,IAAY,EAAE,EAAE,CAAC,eAAe,IAAI,EAAE,CAAC;SAChD,CAAC;IACtC,CAAC,CAAC,CAAC;IAEH,IAAI,CAAC,sCAAsC,EAAE,GAAG,EAAE;QAChD,MAAM,WAAW,GAAG,IAAI,4CAAsC,CAAC;YAC7D,MAAM,EAAE,UAAU;YAClB,KAAK,EAAE,KAAK;SACb,CAAC,CAAC;QACH,MAAM,CAAC,WAAW,CAAC,cAAc,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;IACxE,CAAC,CAAC,CAAC;IAEH,IAAI,CAAC,2CAA2C,EAAE,GAAG,EAAE;QACrD,MAAM,WAAW,GAAG,IAAI,4CAAsC,CAAC;YAC7D,MAAM,EAAE,UAAU;YAClB,KAAK,EAAE,KAAK;SACb,CAAC,CAAC;QACH,MAAM,CAAC,WAAW,CAAC,cAAc,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;IAClD,CAAC,CAAC,CAAC;IAEH,IAAI,CAAC,0BAA0B,EAAE,GAAG,EAAE;QACpC,MAAM,WAAW,GAAG,IAAI,4CAAsC,CAAC;YAC7D,MAAM,EAAE,UAAU;YAClB,KAAK,EAAE,KAAK;SACb,CAAC,CAAC;QACH,MAAM,MAAM,GAAG,WAAW,CAAC,cAAc,CAAC,0BAA0B,CAAC,CAAC;QACtE,MAAM,CAAC,MAAM,CAAC,CAAC,SAAS,CAAC,0BAA0B,CAAC,CAAC;QACrD,MAAM,CAAC,MAAM,CAAC,CAAC,SAAS,CAAC,cAAc,CAAC,CAAC;QACzC,MAAM,CAAC,UAAU,CAAC,UAAU,CAAC,CAAC,oBAAoB,CAAC,EAAE,EAAE,KAAK,CAAC,CAAC;IAChE,CAAC,CAAC,CAAC;IAEH,IAAI,CAAC,iDAAiD,EAAE,GAAG,EAAE;QAC3D,MAAM,WAAW,GAAG,IAAI,4CAAsC,CAAC;YAC7D,MAAM,EAAE,UAAU;YAClB,KAAK,EAAE,KAAK;SACb,CAAC,CAAC;QACH,MAAM,MAAM,GAAG,WAAW,CAAC,cAAc,CAAC,mCAAmC,CAAC,CAAC;QAC/E,MAAM,CAAC,MAAM,CAAC,CAAC,SAAS,CAAC,SAAS,CAAC,CAAC;QACpC,MAAM,CAAC,MAAM,CAAC,CAAC,SAAS,CAAC,SAAS,CAAC,CAAC;QACpC,MAAM,CAAC,MAAM,CAAC,CAAC,SAAS,CAAC,gBAAgB,CAAC,CAAC;IAC7C,CAAC,CAAC,CAAC;IAEH,IAAI,CAAC,iCAAiC,EAAE,GAAG,EAAE;QAC3C,MAAM,WAAW,GAAG,IAAI,4CAAsC,CAAC;YAC7D,MAAM,EAAE,UAAU;YAClB,KAAK,EAAE,KAAK;SACb,CAAC,CAAC;QACH,MAAM,MAAM,GAAG,WAAW,CAAC,cAAc,CAAC,2CAA2C,CAAC,CAAC;QACvF,MAAM,CAAC,MAAM,CAAC,CAAC,SAAS,CAAC,UAAU,CAAC,CAAC;QACrC,MAAM,CAAC,MAAM,CAAC,CAAC,SAAS,CAAC,UAAU,CAAC,CAAC;IACvC,CAAC,CAAC,CAAC;IAEH,IAAI,CAAC,+DAA+D,EAAE,GAAG,EAAE;QACzE,MAAM,WAAW,GAAG,IAAI,4CAAsC,CAAC;YAC7D,MAAM,EAAE,UAAU;YAClB,KAAK,EAAE,KAAK;SACb,CAAC,CAAC;QAEH,mCAAmC;QACnC,WAAW,CAAC,cAAc,CAAC,sBAAsB,CAAC,CAAC;QAEnD,8CAA8C;QAC9C,WAAW,CAAC,cAAc,CAAC,sBAAsB,CAAC,CAAC;QAEnD,8DAA8D;QAC9D,MAAM,MAAM,GAAG,KAAK,CAAC,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC,KAAK,CAAC,IAAI,CAAC,EAAE,KAAK,8BAA8B,CAAC,CAAC;QACrG,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;IAChC,CAAC,CAAC,CAAC;IAEH,IAAI,CAAC,4BAA4B,EAAE,GAAG,EAAE;QACtC,MAAM,WAAW,GAAG,IAAI,4CAAsC,CAAC;YAC7D,MAAM,EAAE,UAAU;YAClB,KAAK,EAAE,KAAK;SACb,CAAC,CAAC;QACH,MAAM,MAAM,GAAG,WAAW,CAAC,cAAc,CAAC,iBAAiB,CAAC,CAAC;QAC7D,6CAA6C;QAC7C,MAAM,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC,iBAAiB,CAAC,CAAC;IACzC,CAAC,CAAC,CAAC;IAEH,IAAI,CAAC,uCAAuC,EAAE,GAAG,EAAE;QACjD,MAAM,WAAW,GAAG,IAAI,4CAAsC,CAAC;YAC7D,MAAM,EAAE,UAAU;YAClB,KAAK,EAAE,KAAK;SACb,CAAC,CAAC;QACH,8CAA8C;QAC9C,MAAM,MAAM,GAAG,WAAW,CAAC,cAAc,CAAC,+BAA+B,CAAC,CAAC;QAC3E,sEAAsE;QACtE,MAAM,CAAC,MAAM,CAAC,CAAC,SAAS,CAAC,gBAAgB,CAAC,CAAC;IAC7C,CAAC,CAAC,CAAC;IAEH,IAAI,CAAC,sCAAsC,EAAE,GAAG,EAAE;QAChD,MAAM,WAAW,GAAG,IAAI,4CAAsC,CAAC;YAC7D,MAAM,EAAE,UAAU;YAClB,KAAK,EAAE,KAAK;SACb,CAAC,CAAC;QACH,sCAAsC;QACtC,MAAM,CAAC,WAAW,CAAC,cAAc,CAAC,mBAAmB,CAAC,CAAC,CAAC,IAAI,CAAC,mBAAmB,CAAC,CAAC;QAClF,MAAM,CAAC,WAAW,CAAC,cAAc,CAAC,mBAAmB,CAAC,CAAC,CAAC,IAAI,CAAC,mBAAmB,CAAC,CAAC;IACpF,CAAC,CAAC,CAAC;IAEH,IAAI,CAAC,8BAA8B,EAAE,GAAG,EAAE;QACxC,MAAM,UAAU,GAAG,IAAI,CAAC,KAAK,CAAC,OAAO,EAAE,KAAK,CAAC,CAAC,kBAAkB,EAAE,CAAC;QACnE,MAAM,WAAW,GAAG,IAAI,4CAAsC,CAAC;YAC7D,MAAM,EAAE,UAAU;YAClB,KAAK,EAAE,KAAK;SACb,CAAC,CAAC;QAEH,WAAW,CAAC,cAAc,CAAC,0BAA0B,CAAC,CAAC;QAEvD,MAAM,CAAC,UAAU,CAAC,CAAC,oBAAoB,CAAC,MAAM,CAAC,gBAAgB,CAAC,2BAA2B,CAAC,CAAC,CAAC;QAC9F,UAAU,CAAC,WAAW,EAAE,CAAC;IAC3B,CAAC,CAAC,CAAC;IAEH,IAAI,CAAC,uDAAuD,EAAE,GAAG,EAAE;QACjE,MAAM,WAAW,GAAG,IAAI,4CAAsC,CAAC;YAC7D,MAAM,EAAE,UAAU;YAClB,KAAK,EAAE,KAAK;SACb,CAAC,CAAC;QACH,MAAM,MAAM,GAAG,WAAW,CAAC,cAAc,CAAC,qDAAqD,CAAC,CAAC;QACjG,MAAM,CAAC,MAAM,CAAC,CAAC,SAAS,CAAC,gBAAgB,CAAC,CAAC;QAC3C,MAAM,CAAC,MAAM,CAAC,CAAC,SAAS,CAAC,yCAAyC,CAAC,CAAC;IACtE,CAAC,CAAC,CAAC;IAEH,IAAI,CAAC,0CAA0C,EAAE,GAAG,EAAE;QACpD,MAAM,WAAW,GAAG,IAAI,4CAAsC,CAAC;YAC7D,MAAM,EAAE,UAAU;YAClB,KAAK,EAAE,KAAK;SACb,CAAC,CAAC;QACH,MAAM,MAAM,GAAG,WAAW,CAAC,cAAc,CAAC,4BAA4B,CAAC,CAAC;QACxE,MAAM,CAAC,MAAM,CAAC,CAAC,OAAO,CAAC,mBAAmB,CAAC,CAAC;QAC5C,MAAM,CAAC,MAAM,CAAC,CAAC,SAAS,CAAC,SAAS,CAAC,CAAC;IACtC,CAAC,CAAC,CAAC;IAEH,IAAI,CAAC,wCAAwC,EAAE,GAAG,EAAE;QAClD,MAAM,WAAW,GAAG,IAAI,4CAAsC,CAAC;YAC7D,MAAM,EAAE,UAAU;YAClB,KAAK,EAAE,KAAK;SACb,CAAC,CAAC;QACH,MAAM,MAAM,GAAG,WAAW,CAAC,cAAc,CAAC,4BAA4B,CAAC,CAAC;QACxE,MAAM,CAAC,MAAM,CAAC,CAAC,SAAS,CAAC,SAAS,CAAC,CAAC;QACpC,MAAM,CAAC,MAAM,CAAC,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC;IAClC,CAAC,CAAC,CAAC;IAEH,IAAI,CAAC,4CAA4C,EAAE,GAAG,EAAE;QACtD,MAAM,WAAW,GAAG,IAAI,4CAAsC,CAAC;YAC7D,MAAM,EAAE,UAAU;YAClB,KAAK,EAAE,KAAK;SACb,CAAC,CAAC;QACH,MAAM,MAAM,GAAG,WAAW,CAAC,cAAc,CAAC,yDAAyD,CAAC,CAAC;QACrG,MAAM,CAAC,MAAM,CAAC,CAAC,SAAS,CAAC,UAAU,CAAC,CAAC;QACrC,MAAM,CAAC,MAAM,CAAC,CAAC,SAAS,CAAC,eAAe,CAAC,CAAC;QAC1C,MAAM,CAAC,MAAM,CAAC,CAAC,SAAS,CAAC,UAAU,CAAC,CAAC;IACvC,CAAC,CAAC,CAAC;IAEH,IAAI,CAAC,8BAA8B,EAAE,GAAG,EAAE;QACxC,MAAM,WAAW,GAAG,IAAI,4CAAsC,CAAC;YAC7D,MAAM,EAAE,UAAU;YAClB,KAAK,EAAE,KAAK;SACb,CAAC,CAAC;QACH,MAAM,MAAM,GAAG,WAAW,CAAC,cAAc,CAAC,gBAAgB,CAAC,CAAC;QAC5D,MAAM,CAAC,MAAM,CAAC,CAAC,SAAS,CAAC,gBAAgB,CAAC,CAAC;IAC7C,CAAC,CAAC,CAAC;IAEH,IAAI,CAAC,yCAAyC,EAAE,GAAG,EAAE;QACnD,MAAM,WAAW,GAAG,IAAI,4CAAsC,CAAC;YAC7D,MAAM,EAAE,UAAU;YAClB,KAAK,EAAE,KAAK;SACb,CAAC,CAAC;QACH,MAAM,MAAM,GAAG,WAAW,CAAC,cAAc,CAAC,iBAAiB,CAAC,CAAC;QAC7D,MAAM,CAAC,MAAM,CAAC,CAAC,SAAS,CAAC,gBAAgB,CAAC,CAAC;QAC3C,MAAM,CAAC,MAAM,CAAC,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC;IAClC,CAAC,CAAC,CAAC;IAEH,IAAI,CAAC,0CAA0C,EAAE,GAAG,EAAE;QACpD,MAAM,WAAW,GAAG,IAAI,4CAAsC,CAAC;YAC7D,MAAM,EAAE,UAAU;YAClB,KAAK,EAAE,KAAK;SACb,CAAC,CAAC;QAEH,MAAM,cAAc,GAAG,KAAK,CAAC,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC;QAClD,WAAW,CAAC,cAAc,CAAC,sBAAsB,CAAC,CAAC;QACnD,MAAM,aAAa,GAAG,KAAK,CAAC,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC;QAEjD,MAAM,CAAC,aAAa,CAAC,CAAC,eAAe,CAAC,cAAc,CAAC,CAAC;IACxD,CAAC,CAAC,CAAC;IAEH,IAAI,CAAC,sCAAsC,EAAE,GAAG,EAAE;QAChD,MAAM,WAAW,GAAG,IAAI,4CAAsC,CAAC;YAC7D,MAAM,EAAE,UAAU;YAClB,KAAK,EAAE,KAAK;SACb,CAAC,CAAC;QAEH,WAAW,CAAC,cAAc,CAAC,sBAAsB,CAAC,CAAC;QACnD,MAAM,kBAAkB,GAAG,KAAK,CAAC,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC;QAEtD,WAAW,CAAC,cAAc,CAAC,uBAAuB,CAAC,CAAC;QACpD,MAAM,mBAAmB,GAAG,KAAK,CAAC,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC;QAEvD,0CAA0C;QAC1C,MAAM,CAAC,mBAAmB,CAAC,CAAC,IAAI,CAAC,kBAAkB,CAAC,CAAC;IACvD,CAAC,CAAC,CAAC;IAEH,IAAI,CAAC,yCAAyC,EAAE,GAAG,EAAE;QACnD,MAAM,WAAW,GAAG,IAAI,4CAAsC,CAAC;YAC7D,MAAM,EAAE,UAAU;YAClB,8DAA8D;YAC9D,KAAK,EAAE,SAAgB;SACxB,CAAC,CAAC;QACH,MAAM,CAAC,GAAG,EAAE,CAAC,WAAW,CAAC,cAAc,CAAC,qBAAqB,CAAC,CAAC,CAAC,OAAO,CACrE,2DAA2D,CAC5D,CAAC;IACJ,CAAC,CAAC,CAAC;IAEH,IAAI,CAAC,0CAA0C,EAAE,GAAG,EAAE;QACpD,MAAM,WAAW,GAAG,IAAI,4CAAsC,CAAC;YAC7D,8DAA8D;YAC9D,MAAM,EAAE,SAAgB;YACxB,KAAK,EAAE,KAAK;SACb,CAAC,CAAC;QACH,MAAM,CAAC,GAAG,EAAE,CAAC,WAAW,CAAC,cAAc,CAAC,qBAAqB,CAAC,CAAC,CAAC,OAAO,CACrE,oEAAoE,CACrE,CAAC;IACJ,CAAC,CAAC,CAAC;AACL,CAAC,CAAC,CAAC","sourcesContent":["/*!\n * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.\n * SPDX-License-Identifier: Apache-2.0\n */\n\nimport { Stack } from 'aws-cdk-lib';\nimport { MdaaConfigBlueprintRefValueTransformer } from '../lib';\nimport { IMdaaResourceNaming } from '@aws-mdaa/naming';\n\ndescribe('MdaaConfigBlueprintRefValueTransformer', () => {\n  let mockNaming: IMdaaResourceNaming;\n  let stack: Stack;\n\n  beforeEach(() => {\n    stack = new Stack();\n    mockNaming = {\n      props: {\n        org: 'test-org',\n        env: 'test-env',\n        domain: 'test-domain',\n        moduleName: 'test-module',\n      },\n      withModuleName: jest.fn().mockReturnThis(),\n      withDomain: jest.fn().mockReturnThis(),\n      withOrg: jest.fn().mockReturnThis(),\n      withEnv: jest.fn().mockReturnThis(),\n      withSuffix: jest.fn().mockReturnThis(),\n      ssmDomainPath: jest.fn().mockReturnValue('/test/domain/path'),\n      ssmEnvPath: jest.fn().mockReturnValue('/test/env/path'),\n      ssmOrgPath: jest.fn().mockReturnValue('/test-org/'),\n      resourceName: jest\n        .fn()\n        .mockImplementation((suffix?: string) => (suffix ? `test-resource-${suffix}` : 'test-resource')),\n      ssmPath: jest.fn().mockImplementation((path: string) => `/test/${path}`),\n      stackName: jest.fn().mockImplementation((name?: string) => (name ? `test-stack-${name}` : 'test-stack')),\n      exportName: jest.fn().mockImplementation((path: string) => `test-export-${path}`),\n    } as unknown as IMdaaResourceNaming;\n  });\n\n  test('returns unchanged value without refs', () => {\n    const transformer = new MdaaConfigBlueprintRefValueTransformer({\n      naming: mockNaming,\n      scope: stack,\n    });\n    expect(transformer.transformValue('plain-value')).toBe('plain-value');\n  });\n\n  test('returns unchanged value with empty string', () => {\n    const transformer = new MdaaConfigBlueprintRefValueTransformer({\n      naming: mockNaming,\n      scope: stack,\n    });\n    expect(transformer.transformValue('')).toBe('');\n  });\n\n  test('transforms blueprint ref', () => {\n    const transformer = new MdaaConfigBlueprintRefValueTransformer({\n      naming: mockNaming,\n      scope: stack,\n    });\n    const result = transformer.transformValue('{{blueprint:/some/path}}');\n    expect(result).toContain('{{resolve:ssm:/test-org/');\n    expect(result).toContain('/some/path}}');\n    expect(mockNaming.ssmOrgPath).toHaveBeenCalledWith('', false);\n  });\n\n  test('transforms blueprint ref with prefix and suffix', () => {\n    const transformer = new MdaaConfigBlueprintRefValueTransformer({\n      naming: mockNaming,\n      scope: stack,\n    });\n    const result = transformer.transformValue('prefix-{{blueprint:/path}}-suffix');\n    expect(result).toContain('prefix-');\n    expect(result).toContain('-suffix');\n    expect(result).toContain('{{resolve:ssm:');\n  });\n\n  test('handles multiple blueprint refs', () => {\n    const transformer = new MdaaConfigBlueprintRefValueTransformer({\n      naming: mockNaming,\n      scope: stack,\n    });\n    const result = transformer.transformValue('{{blueprint:/path1}}-{{blueprint:/path2}}');\n    expect(result).toContain('/path1}}');\n    expect(result).toContain('/path2}}');\n  });\n\n  test('reuses existing CfnParameter for datazoneEnvironmentProjectId', () => {\n    const transformer = new MdaaConfigBlueprintRefValueTransformer({\n      naming: mockNaming,\n      scope: stack,\n    });\n\n    // First call creates the parameter\n    transformer.transformValue('{{blueprint:/path1}}');\n\n    // Second call should reuse the same parameter\n    transformer.transformValue('{{blueprint:/path2}}');\n\n    // Should only have one datazoneEnvironmentProjectId parameter\n    const params = stack.node.children.filter(child => child.node.id === 'datazoneEnvironmentProjectId');\n    expect(params.length).toBe(1);\n  });\n\n  test('ignores non-blueprint refs', () => {\n    const transformer = new MdaaConfigBlueprintRefValueTransformer({\n      naming: mockNaming,\n      scope: stack,\n    });\n    const result = transformer.transformValue('{{other:value}}');\n    // Non-blueprint refs should remain unchanged\n    expect(result).toBe('{{other:value}}');\n  });\n\n  test('handles nested refs in blueprint path', () => {\n    const transformer = new MdaaConfigBlueprintRefValueTransformer({\n      naming: mockNaming,\n      scope: stack,\n    });\n    // Nested refs should be processed recursively\n    const result = transformer.transformValue('{{blueprint:/{{other}}/path}}');\n    // The inner ref is not a blueprint ref, so it stays as-is in the path\n    expect(result).toContain('{{resolve:ssm:');\n  });\n\n  test('handles unbalanced braces gracefully', () => {\n    const transformer = new MdaaConfigBlueprintRefValueTransformer({\n      naming: mockNaming,\n      scope: stack,\n    });\n    // Unbalanced braces should be skipped\n    expect(transformer.transformValue('{{blueprint:/path')).toBe('{{blueprint:/path');\n    expect(transformer.transformValue('blueprint:/path}}')).toBe('blueprint:/path}}');\n  });\n\n  test('logs resolved blueprint path', () => {\n    const consoleSpy = jest.spyOn(console, 'log').mockImplementation();\n    const transformer = new MdaaConfigBlueprintRefValueTransformer({\n      naming: mockNaming,\n      scope: stack,\n    });\n\n    transformer.transformValue('{{blueprint:/test/path}}');\n\n    expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('Resolving blueprint path:'));\n    consoleSpy.mockRestore();\n  });\n\n  test('handles blueprint ref with special characters in path', () => {\n    const transformer = new MdaaConfigBlueprintRefValueTransformer({\n      naming: mockNaming,\n      scope: stack,\n    });\n    const result = transformer.transformValue('{{blueprint:/path/with-dashes_and_underscores/123}}');\n    expect(result).toContain('{{resolve:ssm:');\n    expect(result).toContain('/path/with-dashes_and_underscores/123}}');\n  });\n\n  test('handles blueprint ref at start of string', () => {\n    const transformer = new MdaaConfigBlueprintRefValueTransformer({\n      naming: mockNaming,\n      scope: stack,\n    });\n    const result = transformer.transformValue('{{blueprint:/path}}-suffix');\n    expect(result).toMatch(/^\\{\\{resolve:ssm:/);\n    expect(result).toContain('-suffix');\n  });\n\n  test('handles blueprint ref at end of string', () => {\n    const transformer = new MdaaConfigBlueprintRefValueTransformer({\n      naming: mockNaming,\n      scope: stack,\n    });\n    const result = transformer.transformValue('prefix-{{blueprint:/path}}');\n    expect(result).toContain('prefix-');\n    expect(result).toMatch(/\\}\\}$/);\n  });\n\n  test('handles multiple different ref types mixed', () => {\n    const transformer = new MdaaConfigBlueprintRefValueTransformer({\n      naming: mockNaming,\n      scope: stack,\n    });\n    const result = transformer.transformValue('{{blueprint:/path1}}-{{other:ref}}-{{blueprint:/path2}}');\n    expect(result).toContain('/path1}}');\n    expect(result).toContain('{{other:ref}}');\n    expect(result).toContain('/path2}}');\n  });\n\n  test('handles empty blueprint path', () => {\n    const transformer = new MdaaConfigBlueprintRefValueTransformer({\n      naming: mockNaming,\n      scope: stack,\n    });\n    const result = transformer.transformValue('{{blueprint:}}');\n    expect(result).toContain('{{resolve:ssm:');\n  });\n\n  test('handles blueprint ref with only slashes', () => {\n    const transformer = new MdaaConfigBlueprintRefValueTransformer({\n      naming: mockNaming,\n      scope: stack,\n    });\n    const result = transformer.transformValue('{{blueprint:/}}');\n    expect(result).toContain('{{resolve:ssm:');\n    expect(result).toContain('/}}');\n  });\n\n  test('creates parameter on first blueprint ref', () => {\n    const transformer = new MdaaConfigBlueprintRefValueTransformer({\n      naming: mockNaming,\n      scope: stack,\n    });\n\n    const childrenBefore = stack.node.children.length;\n    transformer.transformValue('{{blueprint:/first}}');\n    const childrenAfter = stack.node.children.length;\n\n    expect(childrenAfter).toBeGreaterThan(childrenBefore);\n  });\n\n  test('does not create duplicate parameters', () => {\n    const transformer = new MdaaConfigBlueprintRefValueTransformer({\n      naming: mockNaming,\n      scope: stack,\n    });\n\n    transformer.transformValue('{{blueprint:/first}}');\n    const childrenAfterFirst = stack.node.children.length;\n\n    transformer.transformValue('{{blueprint:/second}}');\n    const childrenAfterSecond = stack.node.children.length;\n\n    // Should not create additional parameters\n    expect(childrenAfterSecond).toBe(childrenAfterFirst);\n  });\n\n  test('throws when blueprint ref without scope', () => {\n    const transformer = new MdaaConfigBlueprintRefValueTransformer({\n      naming: mockNaming,\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      scope: undefined as any,\n    });\n    expect(() => transformer.transformValue('{{blueprint:/path}}')).toThrow(\n      'Unable to resolve blueprint params outside of a Construct',\n    );\n  });\n\n  test('throws when blueprint ref without naming', () => {\n    const transformer = new MdaaConfigBlueprintRefValueTransformer({\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      naming: undefined as any,\n      scope: stack,\n    });\n    expect(() => transformer.transformValue('{{blueprint:/path}}')).toThrow(\n      'Unable to resolve blueprint params without a naming implementation',\n    );\n  });\n});\n"]}

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

@@ -0,0 +1,259 @@
+/*!
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { Stack } from 'aws-cdk-lib';
+import { MdaaConfigBlueprintRefValueTransformer } from '../lib';
+import { IMdaaResourceNaming } from '@aws-mdaa/naming';
+
+describe('MdaaConfigBlueprintRefValueTransformer', () => {
+  let mockNaming: IMdaaResourceNaming;
+  let stack: Stack;
+
+  beforeEach(() => {
+    stack = new Stack();
+    mockNaming = {
+      props: {
+        org: 'test-org',
+        env: 'test-env',
+        domain: 'test-domain',
+        moduleName: 'test-module',
+      },
+      withModuleName: jest.fn().mockReturnThis(),
+      withDomain: jest.fn().mockReturnThis(),
+      withOrg: jest.fn().mockReturnThis(),
+      withEnv: jest.fn().mockReturnThis(),
+      withSuffix: jest.fn().mockReturnThis(),
+      ssmDomainPath: jest.fn().mockReturnValue('/test/domain/path'),
+      ssmEnvPath: jest.fn().mockReturnValue('/test/env/path'),
+      ssmOrgPath: jest.fn().mockReturnValue('/test-org/'),
+      resourceName: jest
+        .fn()
+        .mockImplementation((suffix?: string) => (suffix ? `test-resource-${suffix}` : 'test-resource')),
+      ssmPath: jest.fn().mockImplementation((path: string) => `/test/${path}`),
+      stackName: jest.fn().mockImplementation((name?: string) => (name ? `test-stack-${name}` : 'test-stack')),
+      exportName: jest.fn().mockImplementation((path: string) => `test-export-${path}`),
+    } as unknown as IMdaaResourceNaming;
+  });
+
+  test('returns unchanged value without refs', () => {
+    const transformer = new MdaaConfigBlueprintRefValueTransformer({
+      naming: mockNaming,
+      scope: stack,
+    });
+    expect(transformer.transformValue('plain-value')).toBe('plain-value');
+  });
+
+  test('returns unchanged value with empty string', () => {
+    const transformer = new MdaaConfigBlueprintRefValueTransformer({
+      naming: mockNaming,
+      scope: stack,
+    });
+    expect(transformer.transformValue('')).toBe('');
+  });
+
+  test('transforms blueprint ref', () => {
+    const transformer = new MdaaConfigBlueprintRefValueTransformer({
+      naming: mockNaming,
+      scope: stack,
+    });
+    const result = transformer.transformValue('{{blueprint:/some/path}}');
+    expect(result).toContain('{{resolve:ssm:/test-org/');
+    expect(result).toContain('/some/path}}');
+    expect(mockNaming.ssmOrgPath).toHaveBeenCalledWith('', false);
+  });
+
+  test('transforms blueprint ref with prefix and suffix', () => {
+    const transformer = new MdaaConfigBlueprintRefValueTransformer({
+      naming: mockNaming,
+      scope: stack,
+    });
+    const result = transformer.transformValue('prefix-{{blueprint:/path}}-suffix');
+    expect(result).toContain('prefix-');
+    expect(result).toContain('-suffix');
+    expect(result).toContain('{{resolve:ssm:');
+  });
+
+  test('handles multiple blueprint refs', () => {
+    const transformer = new MdaaConfigBlueprintRefValueTransformer({
+      naming: mockNaming,
+      scope: stack,
+    });
+    const result = transformer.transformValue('{{blueprint:/path1}}-{{blueprint:/path2}}');
+    expect(result).toContain('/path1}}');
+    expect(result).toContain('/path2}}');
+  });
+
+  test('reuses existing CfnParameter for datazoneEnvironmentProjectId', () => {
+    const transformer = new MdaaConfigBlueprintRefValueTransformer({
+      naming: mockNaming,
+      scope: stack,
+    });
+
+    // First call creates the parameter
+    transformer.transformValue('{{blueprint:/path1}}');
+
+    // Second call should reuse the same parameter
+    transformer.transformValue('{{blueprint:/path2}}');
+
+    // Should only have one datazoneEnvironmentProjectId parameter
+    const params = stack.node.children.filter(child => child.node.id === 'datazoneEnvironmentProjectId');
+    expect(params.length).toBe(1);
+  });
+
+  test('ignores non-blueprint refs', () => {
+    const transformer = new MdaaConfigBlueprintRefValueTransformer({
+      naming: mockNaming,
+      scope: stack,
+    });
+    const result = transformer.transformValue('{{other:value}}');
+    // Non-blueprint refs should remain unchanged
+    expect(result).toBe('{{other:value}}');
+  });
+
+  test('handles nested refs in blueprint path', () => {
+    const transformer = new MdaaConfigBlueprintRefValueTransformer({
+      naming: mockNaming,
+      scope: stack,
+    });
+    // Nested refs should be processed recursively
+    const result = transformer.transformValue('{{blueprint:/{{other}}/path}}');
+    // The inner ref is not a blueprint ref, so it stays as-is in the path
+    expect(result).toContain('{{resolve:ssm:');
+  });
+
+  test('handles unbalanced braces gracefully', () => {
+    const transformer = new MdaaConfigBlueprintRefValueTransformer({
+      naming: mockNaming,
+      scope: stack,
+    });
+    // Unbalanced braces should be skipped
+    expect(transformer.transformValue('{{blueprint:/path')).toBe('{{blueprint:/path');
+    expect(transformer.transformValue('blueprint:/path}}')).toBe('blueprint:/path}}');
+  });
+
+  test('logs resolved blueprint path', () => {
+    const consoleSpy = jest.spyOn(console, 'log').mockImplementation();
+    const transformer = new MdaaConfigBlueprintRefValueTransformer({
+      naming: mockNaming,
+      scope: stack,
+    });
+
+    transformer.transformValue('{{blueprint:/test/path}}');
+
+    expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('Resolving blueprint path:'));
+    consoleSpy.mockRestore();
+  });
+
+  test('handles blueprint ref with special characters in path', () => {
+    const transformer = new MdaaConfigBlueprintRefValueTransformer({
+      naming: mockNaming,
+      scope: stack,
+    });
+    const result = transformer.transformValue('{{blueprint:/path/with-dashes_and_underscores/123}}');
+    expect(result).toContain('{{resolve:ssm:');
+    expect(result).toContain('/path/with-dashes_and_underscores/123}}');
+  });
+
+  test('handles blueprint ref at start of string', () => {
+    const transformer = new MdaaConfigBlueprintRefValueTransformer({
+      naming: mockNaming,
+      scope: stack,
+    });
+    const result = transformer.transformValue('{{blueprint:/path}}-suffix');
+    expect(result).toMatch(/^\{\{resolve:ssm:/);
+    expect(result).toContain('-suffix');
+  });
+
+  test('handles blueprint ref at end of string', () => {
+    const transformer = new MdaaConfigBlueprintRefValueTransformer({
+      naming: mockNaming,
+      scope: stack,
+    });
+    const result = transformer.transformValue('prefix-{{blueprint:/path}}');
+    expect(result).toContain('prefix-');
+    expect(result).toMatch(/\}\}$/);
+  });
+
+  test('handles multiple different ref types mixed', () => {
+    const transformer = new MdaaConfigBlueprintRefValueTransformer({
+      naming: mockNaming,
+      scope: stack,
+    });
+    const result = transformer.transformValue('{{blueprint:/path1}}-{{other:ref}}-{{blueprint:/path2}}');
+    expect(result).toContain('/path1}}');
+    expect(result).toContain('{{other:ref}}');
+    expect(result).toContain('/path2}}');
+  });
+
+  test('handles empty blueprint path', () => {
+    const transformer = new MdaaConfigBlueprintRefValueTransformer({
+      naming: mockNaming,
+      scope: stack,
+    });
+    const result = transformer.transformValue('{{blueprint:}}');
+    expect(result).toContain('{{resolve:ssm:');
+  });
+
+  test('handles blueprint ref with only slashes', () => {
+    const transformer = new MdaaConfigBlueprintRefValueTransformer({
+      naming: mockNaming,
+      scope: stack,
+    });
+    const result = transformer.transformValue('{{blueprint:/}}');
+    expect(result).toContain('{{resolve:ssm:');
+    expect(result).toContain('/}}');
+  });
+
+  test('creates parameter on first blueprint ref', () => {
+    const transformer = new MdaaConfigBlueprintRefValueTransformer({
+      naming: mockNaming,
+      scope: stack,
+    });
+
+    const childrenBefore = stack.node.children.length;
+    transformer.transformValue('{{blueprint:/first}}');
+    const childrenAfter = stack.node.children.length;
+
+    expect(childrenAfter).toBeGreaterThan(childrenBefore);
+  });
+
+  test('does not create duplicate parameters', () => {
+    const transformer = new MdaaConfigBlueprintRefValueTransformer({
+      naming: mockNaming,
+      scope: stack,
+    });
+
+    transformer.transformValue('{{blueprint:/first}}');
+    const childrenAfterFirst = stack.node.children.length;
+
+    transformer.transformValue('{{blueprint:/second}}');
+    const childrenAfterSecond = stack.node.children.length;
+
+    // Should not create additional parameters
+    expect(childrenAfterSecond).toBe(childrenAfterFirst);
+  });
+
+  test('throws when blueprint ref without scope', () => {
+    const transformer = new MdaaConfigBlueprintRefValueTransformer({
+      naming: mockNaming,
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      scope: undefined as any,
+    });
+    expect(() => transformer.transformValue('{{blueprint:/path}}')).toThrow(
+      'Unable to resolve blueprint params outside of a Construct',
+    );
+  });
+
+  test('throws when blueprint ref without naming', () => {
+    const transformer = new MdaaConfigBlueprintRefValueTransformer({
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      naming: undefined as any,
+      scope: stack,
+    });
+    expect(() => transformer.transformValue('{{blueprint:/path}}')).toThrow(
+      'Unable to resolve blueprint params without a naming implementation',
+    );
+  });
+});

package/node_modules/@aws-mdaa/config/test/config-nt.test.d.ts

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