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

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

@@ -0,0 +1,159 @@
+/*!
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { CfnParameter, CfnParameterProps, Stack } from 'aws-cdk-lib';
+import { MdaaConfigRefValueTransformerProps, MdaaConfigRefValueTransformer } from './ref-value-transformer';
+
+export interface MdaaConfigParamRefValueTransformerProps extends MdaaConfigRefValueTransformerProps {
+  readonly paramProps: { [name: string]: CfnParameterProps };
+}
+export class MdaaConfigParamRefValueTransformer extends MdaaConfigRefValueTransformer {
+  private readonly paramProps: { [name: string]: CfnParameterProps };
+  constructor(props: MdaaConfigParamRefValueTransformerProps) {
+    super(props);
+    this.paramProps = props.paramProps;
+  }
+  protected override parseRef(value: string, refMatch: string[]): string | number {
+    /**
+     * Handle base case where we resolve and return a single naked parameter value,
+     * Important as we need to avoid building a string if we have a standalone numerical value
+     */
+    const standaloneParam = this.resolveStandaloneParam(value, refMatch);
+    if (standaloneParam) {
+      return standaloneParam;
+    }
+    // In all other cases, return a recursively substituted string
+    let toReturn: string = value;
+    refMatch.forEach(ref => {
+      let resolvedValue: string | undefined;
+      const refInner = this.transformValue(ref).toString();
+      if (refInner.startsWith('param:') && this.props.scope instanceof Stack) {
+        resolvedValue = this.createParam(refInner).toString();
+      }
+      toReturn = resolvedValue ? toReturn.replace(`{{${ref}}}`, resolvedValue) : toReturn;
+    });
+    return toReturn;
+  }
+  /**
+   * Resolve standalone parameters with no other content in the value.
+   * "Standalone" means it is not embedded in a string value.
+   * Important as this can be a case where a number should be returned instead of a string.
+   * @param value
+   * @param refMatch
+   * @returns
+   */
+  private resolveStandaloneParam(value: string, refMatch: string[]): string | number | undefined {
+    if (refMatch.length === 1) {
+      const strippedValue = value.replace(`{{${refMatch[0]}}}`, '').trim();
+      if (strippedValue.length === 0) {
+        const refInner = this.transformValue(refMatch[0]);
+        if (typeof refInner === 'string') {
+          if (refInner.startsWith('param:') && this.props.scope instanceof Stack) {
+            return this.createParam(refInner);
+          }
+        }
+      }
+    }
+    return undefined;
+  }
+  /**
+   * Create new or resolve existing parameter for a given parameter reference
+   * @param refInner
+   * @returns Value of CfnParameter
+   */
+  private createParam(refInner: string): string | number {
+    if (!this.props.scope) {
+      throw new Error('Unable to create parameters outside of a Construct');
+    }
+    const stack = Stack.of(this.props.scope);
+    const paramBase = refInner.replace(/^param:/, '');
+    const paramName = paramBase
+      .replace(/^string:/, '')
+      .replace(/^number:/, '')
+      .replace(/^list:/, '');
+    const paramProps = this.getParamProps(paramName);
+    const exists = stack.node.tryFindChild(paramName) as CfnParameter;
+    // Return values for existing parameter if it already exists
+    if (exists?.type) {
+      if (this.isStringType(exists.type)) return exists.valueAsString;
+      else if (this.isNumberType(exists.type)) return exists.valueAsNumber;
+      else if (this.isListType(exists.type)) return exists.valueAsList.join(',');
+    }
+    // If parameter exists, but we weren't able to infer a type, return it as a string
+    if (exists) {
+      return exists.valueAsString;
+    }
+    // If parameter properties are present, use them to infer the parameter type if possible
+    if (paramProps?.type) {
+      return this.createParamUsingProps(paramName, paramProps.type, paramProps);
+    }
+    // If no paramProps type was found, create a new parameter based on type labels if present
+    return this.createParamUsingTypeLabels(paramBase, paramName, paramProps);
+  }
+  private createParamUsingProps(paramName: string, paramType: string, paramProps: CfnParameterProps) {
+    if (!this.props.scope) {
+      throw new Error('Unable to create params outside of a Construct');
+    }
+    if (this.isNumberType(paramType)) {
+      return new CfnParameter(this.props.scope, paramName, paramProps).valueAsNumber;
+    } else if (this.isStringType(paramType)) {
+      return new CfnParameter(this.props.scope, paramName, paramProps).valueAsString;
+    } else if (this.isListType(paramType)) {
+      return new CfnParameter(this.props.scope, paramName, paramProps).valueAsList.join(',');
+    } else {
+      throw new Error(
+        `Invalid parameter type passed to paramProps: "${paramType}". Type must be one of ['String', 'Number', 'CommaDelimitedList']`,
+      );
+    }
+  }
+  protected createParamUsingTypeLabels(
+    paramBase: string,
+    paramName: string,
+    paramProps: CfnParameterProps | undefined,
+  ) {
+    if (!this.props.scope) {
+      throw new Error('Unable to create params outside of a Construct');
+    }
+    if (paramBase.startsWith('string:')) {
+      const typedProps = { ...paramProps, type: 'String' };
+      return new CfnParameter(this.props.scope, paramName, typedProps).valueAsString;
+    } else if (paramBase.startsWith('number')) {
+      const typedProps = { ...paramProps, type: 'Number' };
+      return new CfnParameter(this.props.scope, paramName, typedProps).valueAsNumber;
+    } else if (paramBase.startsWith('list')) {
+      const typedProps = { ...paramProps, type: 'CommaDelimitedList' };
+      return new CfnParameter(this.props.scope, paramName, typedProps).valueAsList.join(',');
+    }
+    // If no type is specified in paramProps, then assume that the parameter is a string
+    return new CfnParameter(this.props.scope, paramName, paramProps).valueAsString;
+  }
+  /**
+   * Whether the given parameter type is a list type
+   * Follows conventions of CfnParameter internal functions
+   */
+  private isListType(type: string) {
+    return type.includes('List<') || type.includes('CommaDelimitedList');
+  }
+  /**
+   * Whether the given parameter type is a number type
+   * Follows conventions of CfnParameter internal functions
+   */
+  private isNumberType(type: string) {
+    return type === 'Number';
+  }
+  /**
+   * Whether the given parameter type is a string type
+   * Follows conventions of CfnParameter internal functions
+   */
+  private isStringType(type: string) {
+    return !this.isListType(type) && !this.isNumberType(type);
+  }
+  private getParamProps(paramName: string): CfnParameterProps | undefined {
+    if (this.paramProps[paramName]) {
+      return this.paramProps[paramName];
+    }
+    return undefined;
+  }
+}

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

@@ -0,0 +1,10 @@
+/*!
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { IMdaaConfigValueTransformer } from './transformer';
+export declare class ConfigConfigPathValueTransformer implements IMdaaConfigValueTransformer {
+    private readonly baseDir;
+    constructor(baseDir: string);
+    transformValue(value: string): string;
+}

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

@@ -0,0 +1,30 @@
+"use strict";
+/*!
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConfigConfigPathValueTransformer = void 0;
+const path = require("path");
+class ConfigConfigPathValueTransformer {
+    constructor(baseDir) {
+        this.baseDir = baseDir;
+    }
+    transformValue(value) {
+        if (value.startsWith('../')) {
+            // Resolve to baseDir's parent path
+            // nosemgrep
+            return path.resolve(this.baseDir, value);
+        }
+        else if (value.startsWith('./')) {
+            // Resolve relative to baseDir
+            // nosemgrep
+            return path.resolve(value.replace(/^\./, this.baseDir));
+        }
+        else {
+            return value;
+        }
+    }
+}
+exports.ConfigConfigPathValueTransformer = ConfigConfigPathValueTransformer;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGF0aC12YWx1ZS10cmFuc2Zvcm1lci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbInBhdGgtdmFsdWUtdHJhbnNmb3JtZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBOzs7R0FHRzs7O0FBRUgsNkJBQTZCO0FBRzdCLE1BQWEsZ0NBQWdDO0lBRTNDLFlBQVksT0FBZTtRQUN6QixJQUFJLENBQUMsT0FBTyxHQUFHLE9BQU8sQ0FBQztJQUN6QixDQUFDO0lBQ00sY0FBYyxDQUFDLEtBQWE7UUFDakMsSUFBSSxLQUFLLENBQUMsVUFBVSxDQUFDLEtBQUssQ0FBQyxFQUFFLENBQUM7WUFDNUIsbUNBQW1DO1lBQ25DLFlBQVk7WUFDWixPQUFPLElBQUksQ0FBQyxPQUFPLENBQUMsSUFBSSxDQUFDLE9BQU8sRUFBRSxLQUFLLENBQUMsQ0FBQztRQUMzQyxDQUFDO2FBQU0sSUFBSSxLQUFLLENBQUMsVUFBVSxDQUFDLElBQUksQ0FBQyxFQUFFLENBQUM7WUFDbEMsOEJBQThCO1lBQzlCLFlBQVk7WUFDWixPQUFPLElBQUksQ0FBQyxPQUFPLENBQUMsS0FBSyxDQUFDLE9BQU8sQ0FBQyxLQUFLLEVBQUUsSUFBSSxDQUFDLE9BQU8sQ0FBQyxDQUFDLENBQUM7UUFDMUQsQ0FBQzthQUFNLENBQUM7WUFDTixPQUFPLEtBQUssQ0FBQztRQUNmLENBQUM7SUFDSCxDQUFDO0NBQ0Y7QUFsQkQsNEVBa0JDIiwic291cmNlc0NvbnRlbnQiOlsiLyohXG4gKiBDb3B5cmlnaHQgQW1hem9uLmNvbSwgSW5jLiBvciBpdHMgYWZmaWxpYXRlcy4gQWxsIFJpZ2h0cyBSZXNlcnZlZC5cbiAqIFNQRFgtTGljZW5zZS1JZGVudGlmaWVyOiBBcGFjaGUtMi4wXG4gKi9cblxuaW1wb3J0ICogYXMgcGF0aCBmcm9tICdwYXRoJztcbmltcG9ydCB7IElNZGFhQ29uZmlnVmFsdWVUcmFuc2Zvcm1lciB9IGZyb20gJy4vdHJhbnNmb3JtZXInO1xuXG5leHBvcnQgY2xhc3MgQ29uZmlnQ29uZmlnUGF0aFZhbHVlVHJhbnNmb3JtZXIgaW1wbGVtZW50cyBJTWRhYUNvbmZpZ1ZhbHVlVHJhbnNmb3JtZXIge1xuICBwcml2YXRlIHJlYWRvbmx5IGJhc2VEaXI6IHN0cmluZztcbiAgY29uc3RydWN0b3IoYmFzZURpcjogc3RyaW5nKSB7XG4gICAgdGhpcy5iYXNlRGlyID0gYmFzZURpcjtcbiAgfVxuICBwdWJsaWMgdHJhbnNmb3JtVmFsdWUodmFsdWU6IHN0cmluZyk6IHN0cmluZyB7XG4gICAgaWYgKHZhbHVlLnN0YXJ0c1dpdGgoJy4uLycpKSB7XG4gICAgICAvLyBSZXNvbHZlIHRvIGJhc2VEaXIncyBwYXJlbnQgcGF0aFxuICAgICAgLy8gbm9zZW1ncmVwXG4gICAgICByZXR1cm4gcGF0aC5yZXNvbHZlKHRoaXMuYmFzZURpciwgdmFsdWUpO1xuICAgIH0gZWxzZSBpZiAodmFsdWUuc3RhcnRzV2l0aCgnLi8nKSkge1xuICAgICAgLy8gUmVzb2x2ZSByZWxhdGl2ZSB0byBiYXNlRGlyXG4gICAgICAvLyBub3NlbWdyZXBcbiAgICAgIHJldHVybiBwYXRoLnJlc29sdmUodmFsdWUucmVwbGFjZSgvXlxcLi8sIHRoaXMuYmFzZURpcikpO1xuICAgIH0gZWxzZSB7XG4gICAgICByZXR1cm4gdmFsdWU7XG4gICAgfVxuICB9XG59XG4iXX0=

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

@@ -0,0 +1,27 @@
+/*!
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import * as path from 'path';
+import { IMdaaConfigValueTransformer } from './transformer';
+
+export class ConfigConfigPathValueTransformer implements IMdaaConfigValueTransformer {
+  private readonly baseDir: string;
+  constructor(baseDir: string) {
+    this.baseDir = baseDir;
+  }
+  public transformValue(value: string): string {
+    if (value.startsWith('../')) {
+      // Resolve to baseDir's parent path
+      // nosemgrep
+      return path.resolve(this.baseDir, value);
+    } else if (value.startsWith('./')) {
+      // Resolve relative to baseDir
+      // nosemgrep
+      return path.resolve(value.replace(/^\./, this.baseDir));
+    } else {
+      return value;
+    }
+  }
+}

package/node_modules/@aws-mdaa/config/lib/ref-value-transformer.d.ts

@@ -0,0 +1,44 @@
+/*!
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Construct } from 'constructs';
+import { IMdaaResourceNaming } from '@aws-mdaa/naming';
+import { ConfigurationElement } from './config';
+import { IMdaaConfigValueTransformer, TransformResult } from './transformer';
+export interface AwsEnvironment {
+    readonly partition?: string;
+    readonly region?: string;
+    readonly account?: string;
+}
+export interface MdaaConfigRefValueTransformerProps {
+    readonly naming?: IMdaaResourceNaming;
+    readonly org: string;
+    readonly domain: string;
+    readonly env: string;
+    readonly module_name: string;
+    readonly scope?: Construct;
+    readonly context?: ConfigurationElement;
+    readonly awsEnvironment?: AwsEnvironment;
+}
+export declare class MdaaConfigRefValueTransformer implements IMdaaConfigValueTransformer {
+    protected props: MdaaConfigRefValueTransformerProps;
+    constructor(props: MdaaConfigRefValueTransformerProps);
+    transformValue(value: string): TransformResult;
+    protected parseRef(value: string, refMatch: string[]): string | number | object;
+    private isNakedReference;
+    private handleNakedReference;
+    private substituteReferences;
+    private convertToString;
+    private resolveReference;
+    private resolveRef;
+    private generateLogicalId;
+    private getSimpleRefMap;
+    private resolveContextReference;
+    private resolveEnvVar;
+    private extractSsmValue;
+    private resolveSsmPartialPathReference;
+    private resolveDirectSsm;
+    private getSsmValue;
+    private parseContext;
+}

package/node_modules/@aws-mdaa/config/lib/ref-value-transformer.js

@@ -0,0 +1,243 @@
+"use strict";
+/*!
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MdaaConfigRefValueTransformer = void 0;
+const construct_1 = require("@aws-mdaa/construct");
+const aws_cdk_lib_1 = require("aws-cdk-lib");
+const constructs_1 = require("constructs");
+const XRegExp = require("xregexp");
+class MdaaConfigRefValueTransformer {
+    constructor(props) {
+        this.props = props;
+    }
+    transformValue(value) {
+        const refMatch = XRegExp.matchRecursive(value, '{{', '}}', 'g', {
+            unbalanced: 'skip',
+        });
+        if (refMatch.length > 0) {
+            return this.parseRef(value, refMatch);
+        }
+        else {
+            return value;
+        }
+    }
+    parseRef(value, refMatch) {
+        const isNakedReference = this.isNakedReference(value, refMatch);
+        // Handle naked references that might return objects/arrays
+        if (isNakedReference) {
+            const nakedResult = this.handleNakedReference(refMatch[0]);
+            if (nakedResult !== undefined) {
+                return nakedResult;
+            }
+        }
+        // Substitute all references in the string
+        return this.substituteReferences(value, refMatch, isNakedReference);
+    }
+    isNakedReference(value, refMatch) {
+        return refMatch.length === 1 && value === `{{${refMatch[0]}}}`;
+    }
+    handleNakedReference(ref) {
+        const refInner = this.transformValue(ref).toString();
+        if (refInner.startsWith('context:')) {
+            const resolvedValue = this.parseContext(refInner);
+            // If it's an object or array, return it directly
+            if (typeof resolvedValue === 'object' && resolvedValue !== null) {
+                return resolvedValue;
+            }
+        }
+        // For env_var refs, attempt to parse JSON arrays/objects so that
+        // env vars containing '["a","b"]' resolve to actual arrays rather than strings.
+        if (refInner.startsWith('env_var:')) {
+            const envValue = this.resolveEnvVar(refInner);
+            if (envValue && (envValue.startsWith('[') || envValue.startsWith('{'))) {
+                try {
+                    const parsed = JSON.parse(envValue);
+                    if (typeof parsed === 'object' && parsed !== null) {
+                        return parsed;
+                    }
+                }
+                catch {
+                    // Not valid JSON — fall through to string substitution
+                }
+            }
+        }
+        return undefined;
+    }
+    substituteReferences(value, refMatch, isNakedReference) {
+        return refMatch.reduce((result, ref) => {
+            const refInner = this.transformValue(ref).toString();
+            const resolvedValue = this.resolveReference(refInner, isNakedReference);
+            if (resolvedValue === undefined) {
+                return result;
+            }
+            const stringValue = this.convertToString(resolvedValue);
+            return result.replace(`{{${ref}}}`, stringValue);
+        }, value);
+    }
+    convertToString(value) {
+        if (typeof value === 'string') {
+            return value;
+        }
+        if (typeof value === 'number' || typeof value === 'boolean') {
+            return String(value);
+        }
+        // For objects, use JSON.stringify as a safe fallback
+        return JSON.stringify(value);
+    }
+    resolveReference(refInner, isNakedReference) {
+        const simpleRefMap = this.getSimpleRefMap();
+        if (simpleRefMap[refInner]) {
+            return simpleRefMap[refInner];
+        }
+        if (refInner.startsWith('context:')) {
+            return this.resolveContextReference(refInner, isNakedReference);
+        }
+        if (refInner.startsWith('env_var:')) {
+            return this.resolveEnvVar(refInner);
+        }
+        if (refInner.startsWith('ssm-org:')) {
+            return this.resolveSsmPartialPathReference(refInner);
+        }
+        if (refInner.startsWith('ssm-domain:')) {
+            return this.resolveSsmPartialPathReference(refInner);
+        }
+        if (refInner.startsWith('ssm-env:')) {
+            return this.resolveSsmPartialPathReference(refInner);
+        }
+        if (refInner.startsWith('resolve:ssm:')) {
+            return this.resolveDirectSsm(refInner);
+        }
+        if (refInner.startsWith('ref:')) {
+            return this.resolveRef(refInner);
+        }
+        return undefined;
+    }
+    resolveRef(refInner) {
+        const dummyStack = new aws_cdk_lib_1.Stack(undefined);
+        const withoutPrefix = refInner.replace(/^ref:/, '');
+        const parts = withoutPrefix.split(':');
+        // Remove leading slash if present from the path
+        const pathWithSlash = parts[0];
+        const path = pathWithSlash.startsWith('/') ? pathWithSlash.slice(1) : pathWithSlash;
+        const attr = parts[1]; // Will be undefined if no attribute specified
+        const logicalId = this.generateLogicalId(dummyStack, path);
+        if (attr) {
+            return aws_cdk_lib_1.Fn.getAtt(logicalId, attr).toString();
+        }
+        else {
+            return aws_cdk_lib_1.Fn.ref(logicalId).toString();
+        }
+    }
+    generateLogicalId(parentScope, path) {
+        const pathComponents = path.split('/');
+        const construct = new constructs_1.Construct(parentScope, pathComponents[0]);
+        if (pathComponents.length == 1) {
+            return aws_cdk_lib_1.Names.nodeUniqueId(construct.node);
+        }
+        else {
+            return this.generateLogicalId(construct, pathComponents.slice(1).join('/'));
+        }
+    }
+    getSimpleRefMap() {
+        const scopeStack = this.props.scope ? aws_cdk_lib_1.Stack.of(this.props.scope) : undefined;
+        return {
+            org: this.props.org,
+            env: this.props.env,
+            domain: this.props.domain,
+            module_name: this.props.module_name,
+            partition: this.props.awsEnvironment?.partition ?? scopeStack?.partition,
+            region: this.props.awsEnvironment?.region ?? scopeStack?.region,
+            account: this.props.awsEnvironment?.account ?? scopeStack?.account,
+        };
+    }
+    resolveContextReference(refInner, isNakedReference) {
+        const resolvedValue = this.parseContext(refInner);
+        // If the resolved value is an object or array, and we're not in a naked reference
+        if (typeof resolvedValue === 'object' && resolvedValue !== null && !isNakedReference) {
+            throw new Error('Cannot embed array or object context value in string');
+        }
+        return resolvedValue;
+    }
+    resolveEnvVar(refInner) {
+        const envVar = refInner.replace(/^env_var:/, '');
+        return process.env[envVar];
+    }
+    extractSsmValue(refInner, prefix) {
+        const extracted = refInner.replace(new RegExp(String.raw `^${prefix}:\s*`), '');
+        // Remove leading slash to prevent double slashes in the path
+        return extracted.startsWith('/') ? extracted.slice(1) : extracted;
+    }
+    resolveSsmPartialPathReference(refInner) {
+        if (!this.props.naming) {
+            throw new Error(`Unable to resolve ${refInner} ssm param outside of a naming context`);
+        }
+        if (refInner.startsWith('ssm-org:')) {
+            const ssmPath = this.props.naming.ssmOrgPath(this.extractSsmValue(refInner, 'ssm-org'));
+            return `{{resolve:ssm:${ssmPath}}}`;
+        }
+        if (refInner.startsWith('ssm-domain:')) {
+            const ssmPath = this.props.naming.ssmDomainPath(this.extractSsmValue(refInner, 'ssm-domain'));
+            return `{{resolve:ssm:${ssmPath}}}`;
+        }
+        if (refInner.startsWith('ssm-env:')) {
+            const ssmPath = this.props.naming.ssmEnvPath(this.extractSsmValue(refInner, 'ssm-env'));
+            return `{{resolve:ssm:${ssmPath}}}`;
+        }
+        return refInner;
+    }
+    resolveDirectSsm(refInner) {
+        if (!this.props.scope) {
+            throw new Error('Unable to resolve ssm param outside of a Construct');
+        }
+        const ssmPath = refInner.replace(/^resolve:ssm:/, '');
+        console.log(`Resolving SSM: ${ssmPath}`);
+        return this.getSsmValue(ssmPath);
+    }
+    getSsmValue(ssmPath) {
+        if (!this.props.scope) {
+            throw new Error('Unable to resolve ssm param outside of a Construct');
+        }
+        //Handle full arn-based SSM paths (for referencing RAM shared SSM params from other accounts)
+        if (ssmPath.startsWith('arn:')) {
+            const stack = aws_cdk_lib_1.Stack.of(this.props.scope);
+            const exists = stack.node.tryFindChild(ssmPath);
+            if (exists) {
+                return exists.stringValue;
+            }
+            return construct_1.MdaaStringParameter.fromStringParameterArn(aws_cdk_lib_1.Stack.of(this.props.scope), ssmPath, ssmPath).stringValue;
+        }
+        return this.props.scope.node.tryGetContext('@mdaaLookupSSMValues')
+            ? construct_1.MdaaStringParameter.valueFromLookup(aws_cdk_lib_1.Stack.of(this.props.scope), ssmPath)
+            : construct_1.MdaaStringParameter.valueForStringParameter(aws_cdk_lib_1.Stack.of(this.props.scope), ssmPath);
+    }
+    parseContext(refInner) {
+        const refInnerContext = refInner.replace(/^context:/, '');
+        const scopeContextValue = this.props.scope?.node.tryGetContext(refInnerContext);
+        const scopeInnerContextValue = this.props.context ? this.props.context[refInnerContext] : undefined;
+        const contextValue = scopeContextValue ?? scopeInnerContextValue;
+        if (!contextValue) {
+            throw new Error(`Failed to resolve context: ${refInnerContext}`);
+        }
+        if (typeof contextValue === 'string') {
+            // Check if the value is encoded with quotes (from CLI encoding)
+            if (contextValue.startsWith('"') && contextValue.endsWith('"')) {
+                // Remove outer quotes
+                const unquoted = contextValue.slice(1, -1);
+                if (unquoted.startsWith('obj:')) {
+                    // Parse object: "obj:{...}" -> {...}
+                    return JSON.parse(unquoted.replace(/^obj:/, ''));
+                }
+                else if (unquoted.startsWith('list:')) {
+                    // Parse array: "list:[...]" -> [...]
+                    return JSON.parse(unquoted.replace(/^list:/, ''));
+                }
+            }
+        }
+        return contextValue;
+    }
+}
+exports.MdaaConfigRefValueTransformer = MdaaConfigRefValueTransformer;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ref-value-transformer.js","sourceRoot":"","sources":["ref-value-transformer.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 { MdaaStringParameter } from '@aws-mdaa/construct';\nimport { Fn, Names, Stack } from 'aws-cdk-lib';\nimport { Construct } from 'constructs';\n// nosemgrep\nimport { IMdaaResourceNaming } from '@aws-mdaa/naming';\nimport * as XRegExp from 'xregexp';\nimport { ConfigurationElement } from './config';\nimport { IMdaaConfigValueTransformer, TransformResult } from './transformer';\nimport { IStringParameter } from 'aws-cdk-lib/aws-ssm';\n\nexport interface AwsEnvironment {\n  readonly partition?: string;\n  readonly region?: string;\n  readonly account?: string;\n}\n\nexport interface MdaaConfigRefValueTransformerProps {\n  readonly naming?: IMdaaResourceNaming;\n  readonly org: string;\n  readonly domain: string;\n  readonly env: string;\n  readonly module_name: string;\n  readonly scope?: Construct;\n  readonly context?: ConfigurationElement;\n  readonly awsEnvironment?: AwsEnvironment;\n}\n\nexport class MdaaConfigRefValueTransformer implements IMdaaConfigValueTransformer {\n  protected props: MdaaConfigRefValueTransformerProps;\n\n  constructor(props: MdaaConfigRefValueTransformerProps) {\n    this.props = props;\n  }\n\n  public transformValue(value: string): TransformResult {\n    const refMatch = XRegExp.matchRecursive(value, '{{', '}}', 'g', {\n      unbalanced: 'skip',\n    });\n    if (refMatch.length > 0) {\n      return this.parseRef(value, refMatch) as TransformResult;\n    } else {\n      return value;\n    }\n  }\n\n  protected parseRef(value: string, refMatch: string[]): string | number | object {\n    const isNakedReference = this.isNakedReference(value, refMatch);\n\n    // Handle naked references that might return objects/arrays\n    if (isNakedReference) {\n      const nakedResult = this.handleNakedReference(refMatch[0]);\n      if (nakedResult !== undefined) {\n        return nakedResult;\n      }\n    }\n    // Substitute all references in the string\n    return this.substituteReferences(value, refMatch, isNakedReference);\n  }\n\n  private isNakedReference(value: string, refMatch: string[]): boolean {\n    return refMatch.length === 1 && value === `{{${refMatch[0]}}}`;\n  }\n\n  private handleNakedReference(ref: string) {\n    const refInner = this.transformValue(ref).toString();\n\n    if (refInner.startsWith('context:')) {\n      const resolvedValue = this.parseContext(refInner);\n      // If it's an object or array, return it directly\n      if (typeof resolvedValue === 'object' && resolvedValue !== null) {\n        return resolvedValue;\n      }\n    }\n\n    // For env_var refs, attempt to parse JSON arrays/objects so that\n    // env vars containing '[\"a\",\"b\"]' resolve to actual arrays rather than strings.\n    if (refInner.startsWith('env_var:')) {\n      const envValue = this.resolveEnvVar(refInner);\n      if (envValue && (envValue.startsWith('[') || envValue.startsWith('{'))) {\n        try {\n          const parsed = JSON.parse(envValue);\n          if (typeof parsed === 'object' && parsed !== null) {\n            return parsed;\n          }\n        } catch {\n          // Not valid JSON — fall through to string substitution\n        }\n      }\n    }\n\n    return undefined;\n  }\n\n  private substituteReferences(value: string, refMatch: string[], isNakedReference: boolean): string {\n    return refMatch.reduce((result, ref) => {\n      const refInner = this.transformValue(ref).toString();\n      const resolvedValue = this.resolveReference(refInner, isNakedReference);\n\n      if (resolvedValue === undefined) {\n        return result;\n      }\n\n      const stringValue = this.convertToString(resolvedValue);\n      return result.replace(`{{${ref}}}`, stringValue);\n    }, value);\n  }\n\n  private convertToString(value: unknown): string {\n    if (typeof value === 'string') {\n      return value;\n    }\n    if (typeof value === 'number' || typeof value === 'boolean') {\n      return String(value);\n    }\n    // For objects, use JSON.stringify as a safe fallback\n    return JSON.stringify(value);\n  }\n\n  private resolveReference(refInner: string, isNakedReference: boolean) {\n    const simpleRefMap = this.getSimpleRefMap();\n\n    if (simpleRefMap[refInner]) {\n      return simpleRefMap[refInner];\n    }\n\n    if (refInner.startsWith('context:')) {\n      return this.resolveContextReference(refInner, isNakedReference);\n    }\n\n    if (refInner.startsWith('env_var:')) {\n      return this.resolveEnvVar(refInner);\n    }\n\n    if (refInner.startsWith('ssm-org:')) {\n      return this.resolveSsmPartialPathReference(refInner);\n    }\n\n    if (refInner.startsWith('ssm-domain:')) {\n      return this.resolveSsmPartialPathReference(refInner);\n    }\n\n    if (refInner.startsWith('ssm-env:')) {\n      return this.resolveSsmPartialPathReference(refInner);\n    }\n\n    if (refInner.startsWith('resolve:ssm:')) {\n      return this.resolveDirectSsm(refInner);\n    }\n\n    if (refInner.startsWith('ref:')) {\n      return this.resolveRef(refInner);\n    }\n\n    return undefined;\n  }\n\n  private resolveRef(refInner: string): string {\n    const dummyStack = new Stack(undefined);\n    const withoutPrefix = refInner.replace(/^ref:/, '');\n    const parts = withoutPrefix.split(':');\n\n    // Remove leading slash if present from the path\n    const pathWithSlash = parts[0];\n    const path = pathWithSlash.startsWith('/') ? pathWithSlash.slice(1) : pathWithSlash;\n    const attr = parts[1]; // Will be undefined if no attribute specified\n\n    const logicalId = this.generateLogicalId(dummyStack, path);\n\n    if (attr) {\n      return Fn.getAtt(logicalId, attr).toString();\n    } else {\n      return Fn.ref(logicalId).toString();\n    }\n  }\n\n  private generateLogicalId(parentScope: Construct, path: string): string {\n    const pathComponents = path.split('/');\n    const construct = new Construct(parentScope, pathComponents[0]);\n    if (pathComponents.length == 1) {\n      return Names.nodeUniqueId(construct.node);\n    } else {\n      return this.generateLogicalId(construct, pathComponents.slice(1).join('/'));\n    }\n  }\n\n  private getSimpleRefMap(): { [key: string]: string | undefined } {\n    const scopeStack = this.props.scope ? Stack.of(this.props.scope) : undefined;\n    return {\n      org: this.props.org,\n      env: this.props.env,\n      domain: this.props.domain,\n      module_name: this.props.module_name,\n      partition: this.props.awsEnvironment?.partition ?? scopeStack?.partition,\n      region: this.props.awsEnvironment?.region ?? scopeStack?.region,\n      account: this.props.awsEnvironment?.account ?? scopeStack?.account,\n    };\n  }\n\n  private resolveContextReference(refInner: string, isNakedReference: boolean) {\n    const resolvedValue = this.parseContext(refInner);\n\n    // If the resolved value is an object or array, and we're not in a naked reference\n    if (typeof resolvedValue === 'object' && resolvedValue !== null && !isNakedReference) {\n      throw new Error('Cannot embed array or object context value in string');\n    }\n\n    return resolvedValue;\n  }\n\n  private resolveEnvVar(refInner: string): string | undefined {\n    const envVar = refInner.replace(/^env_var:/, '');\n    return process.env[envVar];\n  }\n\n  private extractSsmValue(refInner: string, prefix: string): string {\n    const extracted = refInner.replace(new RegExp(String.raw`^${prefix}:\\s*`), '');\n    // Remove leading slash to prevent double slashes in the path\n    return extracted.startsWith('/') ? extracted.slice(1) : extracted;\n  }\n\n  private resolveSsmPartialPathReference(refInner: string): string {\n    if (!this.props.naming) {\n      throw new Error(`Unable to resolve ${refInner} ssm param outside of a naming context`);\n    }\n\n    if (refInner.startsWith('ssm-org:')) {\n      const ssmPath = this.props.naming.ssmOrgPath(this.extractSsmValue(refInner, 'ssm-org'));\n      return `{{resolve:ssm:${ssmPath}}}`;\n    }\n\n    if (refInner.startsWith('ssm-domain:')) {\n      const ssmPath = this.props.naming.ssmDomainPath(this.extractSsmValue(refInner, 'ssm-domain'));\n      return `{{resolve:ssm:${ssmPath}}}`;\n    }\n\n    if (refInner.startsWith('ssm-env:')) {\n      const ssmPath = this.props.naming.ssmEnvPath(this.extractSsmValue(refInner, 'ssm-env'));\n      return `{{resolve:ssm:${ssmPath}}}`;\n    }\n\n    return refInner;\n  }\n\n  private resolveDirectSsm(refInner: string): string {\n    if (!this.props.scope) {\n      throw new Error('Unable to resolve ssm param outside of a Construct');\n    }\n\n    const ssmPath = refInner.replace(/^resolve:ssm:/, '');\n    console.log(`Resolving SSM: ${ssmPath}`);\n    return this.getSsmValue(ssmPath);\n  }\n\n  private getSsmValue(ssmPath: string): string {\n    if (!this.props.scope) {\n      throw new Error('Unable to resolve ssm param outside of a Construct');\n    }\n    //Handle full arn-based SSM paths (for referencing RAM shared SSM params from other accounts)\n    if (ssmPath.startsWith('arn:')) {\n      const stack = Stack.of(this.props.scope);\n      const exists = stack.node.tryFindChild(ssmPath) as IStringParameter;\n      if (exists) {\n        return exists.stringValue;\n      }\n      return MdaaStringParameter.fromStringParameterArn(Stack.of(this.props.scope), ssmPath, ssmPath).stringValue;\n    }\n    return this.props.scope.node.tryGetContext('@mdaaLookupSSMValues')\n      ? MdaaStringParameter.valueFromLookup(Stack.of(this.props.scope), ssmPath)\n      : MdaaStringParameter.valueForStringParameter(Stack.of(this.props.scope), ssmPath);\n  }\n\n  private parseContext(refInner: string) {\n    const refInnerContext = refInner.replace(/^context:/, '');\n    const scopeContextValue = this.props.scope?.node.tryGetContext(refInnerContext);\n    const scopeInnerContextValue = this.props.context ? this.props.context[refInnerContext] : undefined;\n    const contextValue = scopeContextValue ?? scopeInnerContextValue;\n    if (!contextValue) {\n      throw new Error(`Failed to resolve context: ${refInnerContext}`);\n    }\n    if (typeof contextValue === 'string') {\n      // Check if the value is encoded with quotes (from CLI encoding)\n      if (contextValue.startsWith('\"') && contextValue.endsWith('\"')) {\n        // Remove outer quotes\n        const unquoted = contextValue.slice(1, -1);\n\n        if (unquoted.startsWith('obj:')) {\n          // Parse object: \"obj:{...}\" -> {...}\n          return JSON.parse(unquoted.replace(/^obj:/, '')) as ConfigurationElement;\n        } else if (unquoted.startsWith('list:')) {\n          // Parse array: \"list:[...]\" -> [...]\n          return JSON.parse(unquoted.replace(/^list:/, '')) as unknown[];\n        }\n      }\n    }\n    return contextValue;\n  }\n}\n"]}