@aws-cdk/toolkit-lib 0.3.2 → 0.3.4

package/lib/api/cloudformation/evaluate-cloudformation-template.js

@@ -0,0 +1,456 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EvaluateCloudFormationTemplate = exports.CfnEvaluationException = exports.LazyLookupExport = exports.LookupExportError = exports.LazyListStackResources = void 0;
+const toolkit_error_1 = require("../../toolkit/toolkit-error");
+const resource_metadata_1 = require("../resource-metadata");
+class LazyListStackResources {
+    sdk;
+    stackName;
+    stackResources;
+    constructor(sdk, stackName) {
+        this.sdk = sdk;
+        this.stackName = stackName;
+    }
+    async listStackResources() {
+        if (this.stackResources === undefined) {
+            this.stackResources = this.sdk.cloudFormation().listStackResources({
+                StackName: this.stackName,
+            });
+        }
+        return this.stackResources;
+    }
+}
+exports.LazyListStackResources = LazyListStackResources;
+class LookupExportError extends Error {
+}
+exports.LookupExportError = LookupExportError;
+class LazyLookupExport {
+    sdk;
+    cachedExports = {};
+    constructor(sdk) {
+        this.sdk = sdk;
+    }
+    async lookupExport(name) {
+        if (this.cachedExports[name]) {
+            return this.cachedExports[name];
+        }
+        for await (const cfnExport of this.listExports()) {
+            if (!cfnExport.Name) {
+                continue; // ignore any result that omits a name
+            }
+            this.cachedExports[cfnExport.Name] = cfnExport;
+            if (cfnExport.Name === name) {
+                return cfnExport;
+            }
+        }
+        return undefined; // export not found
+    }
+    // TODO: Paginate
+    async *listExports() {
+        let nextToken = undefined;
+        while (true) {
+            const response = await this.sdk.cloudFormation().listExports({ NextToken: nextToken });
+            for (const cfnExport of response.Exports ?? []) {
+                yield cfnExport;
+            }
+            if (!response.NextToken) {
+                return;
+            }
+            nextToken = response.NextToken;
+        }
+    }
+}
+exports.LazyLookupExport = LazyLookupExport;
+class CfnEvaluationException extends Error {
+}
+exports.CfnEvaluationException = CfnEvaluationException;
+class EvaluateCloudFormationTemplate {
+    stackArtifact;
+    stackName;
+    template;
+    context;
+    account;
+    region;
+    partition;
+    sdk;
+    nestedStacks;
+    stackResources;
+    lookupExport;
+    cachedUrlSuffix;
+    constructor(props) {
+        this.stackArtifact = props.stackArtifact;
+        this.stackName = props.stackName ?? props.stackArtifact.stackName;
+        this.template = props.template ?? props.stackArtifact.template;
+        this.context = {
+            'AWS::AccountId': props.account,
+            'AWS::Region': props.region,
+            'AWS::Partition': props.partition,
+            ...props.parameters,
+        };
+        this.account = props.account;
+        this.region = props.region;
+        this.partition = props.partition;
+        this.sdk = props.sdk;
+        // We need names of nested stack so we can evaluate cross stack references
+        this.nestedStacks = props.nestedStacks ?? {};
+        // The current resources of the Stack.
+        // We need them to figure out the physical name of a resource in case it wasn't specified by the user.
+        // We fetch it lazily, to save a service call, in case all hotswapped resources have their physical names set.
+        this.stackResources = new LazyListStackResources(this.sdk, this.stackName);
+        // CloudFormation Exports lookup to be able to resolve Fn::ImportValue intrinsics in template
+        this.lookupExport = new LazyLookupExport(this.sdk);
+    }
+    // clones current EvaluateCloudFormationTemplate object, but updates the stack name
+    async createNestedEvaluateCloudFormationTemplate(stackName, nestedTemplate, nestedStackParameters) {
+        const evaluatedParams = await this.evaluateCfnExpression(nestedStackParameters);
+        return new EvaluateCloudFormationTemplate({
+            stackArtifact: this.stackArtifact,
+            stackName,
+            template: nestedTemplate,
+            parameters: evaluatedParams,
+            account: this.account,
+            region: this.region,
+            partition: this.partition,
+            sdk: this.sdk,
+            nestedStacks: this.nestedStacks,
+        });
+    }
+    async establishResourcePhysicalName(logicalId, physicalNameInCfnTemplate) {
+        if (physicalNameInCfnTemplate != null) {
+            try {
+                return await this.evaluateCfnExpression(physicalNameInCfnTemplate);
+            }
+            catch (e) {
+                // If we can't evaluate the resource's name CloudFormation expression,
+                // just look it up in the currently deployed Stack
+                if (!(e instanceof CfnEvaluationException)) {
+                    throw e;
+                }
+            }
+        }
+        return this.findPhysicalNameFor(logicalId);
+    }
+    async findPhysicalNameFor(logicalId) {
+        const stackResources = await this.stackResources.listStackResources();
+        return stackResources.find((sr) => sr.LogicalResourceId === logicalId)?.PhysicalResourceId;
+    }
+    async findLogicalIdForPhysicalName(physicalName) {
+        const stackResources = await this.stackResources.listStackResources();
+        return stackResources.find((sr) => sr.PhysicalResourceId === physicalName)?.LogicalResourceId;
+    }
+    findReferencesTo(logicalId) {
+        const ret = new Array();
+        for (const [resourceLogicalId, resourceDef] of Object.entries(this.template?.Resources ?? {})) {
+            if (logicalId !== resourceLogicalId && this.references(logicalId, resourceDef)) {
+                ret.push({
+                    ...resourceDef,
+                    LogicalId: resourceLogicalId,
+                });
+            }
+        }
+        return ret;
+    }
+    async evaluateCfnExpression(cfnExpression) {
+        const self = this;
+        /**
+         * Evaluates CloudFormation intrinsic functions
+         *
+         * Note that supported intrinsic functions are documented in README.md -- please update
+         * list of supported functions when adding new evaluations
+         *
+         * See: https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/intrinsic-function-reference.html
+         */
+        class CfnIntrinsics {
+            evaluateIntrinsic(intrinsic) {
+                const intrinsicFunc = this[intrinsic.name];
+                if (!intrinsicFunc) {
+                    throw new CfnEvaluationException(`CloudFormation function ${intrinsic.name} is not supported`);
+                }
+                const argsAsArray = Array.isArray(intrinsic.args) ? intrinsic.args : [intrinsic.args];
+                return intrinsicFunc.apply(this, argsAsArray);
+            }
+            async 'Fn::Join'(separator, args) {
+                const evaluatedArgs = await self.evaluateCfnExpression(args);
+                return evaluatedArgs.join(separator);
+            }
+            async 'Fn::Split'(separator, args) {
+                const evaluatedArgs = await self.evaluateCfnExpression(args);
+                return evaluatedArgs.split(separator);
+            }
+            async 'Fn::Select'(index, args) {
+                const evaluatedArgs = await self.evaluateCfnExpression(args);
+                return evaluatedArgs[index];
+            }
+            async Ref(logicalId) {
+                const refTarget = await self.findRefTarget(logicalId);
+                if (refTarget) {
+                    return refTarget;
+                }
+                else {
+                    throw new CfnEvaluationException(`Parameter or resource '${logicalId}' could not be found for evaluation`);
+                }
+            }
+            async 'Fn::GetAtt'(logicalId, attributeName) {
+                // ToDo handle the 'logicalId.attributeName' form of Fn::GetAtt
+                const attrValue = await self.findGetAttTarget(logicalId, attributeName);
+                if (attrValue) {
+                    return attrValue;
+                }
+                else {
+                    throw new CfnEvaluationException(`Attribute '${attributeName}' of resource '${logicalId}' could not be found for evaluation`);
+                }
+            }
+            async 'Fn::Sub'(template, explicitPlaceholders) {
+                const placeholders = explicitPlaceholders ? await self.evaluateCfnExpression(explicitPlaceholders) : {};
+                return asyncGlobalReplace(template, /\${([^}]*)}/g, (key) => {
+                    if (key in placeholders) {
+                        return placeholders[key];
+                    }
+                    else {
+                        const splitKey = key.split('.');
+                        return splitKey.length === 1 ? this.Ref(key) : this['Fn::GetAtt'](splitKey[0], splitKey.slice(1).join('.'));
+                    }
+                });
+            }
+            async 'Fn::ImportValue'(name) {
+                const exported = await self.lookupExport.lookupExport(name);
+                if (!exported) {
+                    throw new CfnEvaluationException(`Export '${name}' could not be found for evaluation`);
+                }
+                if (!exported.Value) {
+                    throw new CfnEvaluationException(`Export '${name}' exists without a value`);
+                }
+                return exported.Value;
+            }
+        }
+        if (cfnExpression == null) {
+            return cfnExpression;
+        }
+        if (Array.isArray(cfnExpression)) {
+            // Small arrays in practice
+            // eslint-disable-next-line @cdklabs/promiseall-no-unbounded-parallelism
+            return Promise.all(cfnExpression.map((expr) => this.evaluateCfnExpression(expr)));
+        }
+        if (typeof cfnExpression === 'object') {
+            const intrinsic = this.parseIntrinsic(cfnExpression);
+            if (intrinsic) {
+                return new CfnIntrinsics().evaluateIntrinsic(intrinsic);
+            }
+            else {
+                const ret = {};
+                for (const [key, val] of Object.entries(cfnExpression)) {
+                    ret[key] = await this.evaluateCfnExpression(val);
+                }
+                return ret;
+            }
+        }
+        return cfnExpression;
+    }
+    getResourceProperty(logicalId, propertyName) {
+        return this.template.Resources?.[logicalId]?.Properties?.[propertyName];
+    }
+    metadataFor(logicalId) {
+        return (0, resource_metadata_1.resourceMetadata)(this.stackArtifact, logicalId);
+    }
+    references(logicalId, templateElement) {
+        if (typeof templateElement === 'string') {
+            return logicalId === templateElement;
+        }
+        if (templateElement == null) {
+            return false;
+        }
+        if (Array.isArray(templateElement)) {
+            return templateElement.some((el) => this.references(logicalId, el));
+        }
+        if (typeof templateElement === 'object') {
+            return Object.values(templateElement).some((el) => this.references(logicalId, el));
+        }
+        return false;
+    }
+    parseIntrinsic(x) {
+        const keys = Object.keys(x);
+        if (keys.length === 1 && (keys[0].startsWith('Fn::') || keys[0] === 'Ref')) {
+            return {
+                name: keys[0],
+                args: x[keys[0]],
+            };
+        }
+        return undefined;
+    }
+    async findRefTarget(logicalId) {
+        // first, check to see if the Ref is a Parameter who's value we have
+        if (logicalId === 'AWS::URLSuffix') {
+            if (!this.cachedUrlSuffix) {
+                this.cachedUrlSuffix = await this.sdk.getUrlSuffix(this.region);
+            }
+            return this.cachedUrlSuffix;
+        }
+        // Try finding the ref in the passed in parameters
+        const parameterTarget = this.context[logicalId];
+        if (parameterTarget) {
+            return parameterTarget;
+        }
+        // If not in the passed in parameters, see if there is a default value in the template parameter that was not passed in
+        const defaultParameterValue = this.template.Parameters?.[logicalId]?.Default;
+        if (defaultParameterValue) {
+            return defaultParameterValue;
+        }
+        // if it's not a Parameter, we need to search in the current Stack resources
+        return this.findGetAttTarget(logicalId);
+    }
+    async findGetAttTarget(logicalId, attribute) {
+        // Handle case where the attribute is referencing a stack output (used in nested stacks to share parameters)
+        // See https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/quickref-cloudformation.html#w2ab1c17c23c19b5
+        if (logicalId === 'Outputs' && attribute) {
+            return this.evaluateCfnExpression(this.template.Outputs[attribute]?.Value);
+        }
+        const stackResources = await this.stackResources.listStackResources();
+        const foundResource = stackResources.find((sr) => sr.LogicalResourceId === logicalId);
+        if (!foundResource) {
+            return undefined;
+        }
+        if (foundResource.ResourceType == 'AWS::CloudFormation::Stack' && attribute?.startsWith('Outputs.')) {
+            const dependantStack = this.findNestedStack(logicalId, this.nestedStacks);
+            if (!dependantStack || !dependantStack.physicalName) {
+                // this is a newly created nested stack and cannot be hotswapped
+                return undefined;
+            }
+            const evaluateCfnTemplate = await this.createNestedEvaluateCloudFormationTemplate(dependantStack.physicalName, dependantStack.generatedTemplate, dependantStack.generatedTemplate.Parameters);
+            // Split Outputs.<refName> into 'Outputs' and '<refName>' and recursively call evaluate
+            return evaluateCfnTemplate.evaluateCfnExpression({
+                'Fn::GetAtt': attribute.split(/\.(.*)/s),
+            });
+        }
+        // now, we need to format the appropriate identifier depending on the resource type,
+        // and the requested attribute name
+        return this.formatResourceAttribute(foundResource, attribute);
+    }
+    findNestedStack(logicalId, nestedStacks) {
+        for (const nestedStackLogicalId of Object.keys(nestedStacks)) {
+            if (nestedStackLogicalId === logicalId) {
+                return nestedStacks[nestedStackLogicalId];
+            }
+            const checkInNestedChildStacks = this.findNestedStack(logicalId, nestedStacks[nestedStackLogicalId].nestedStackTemplates);
+            if (checkInNestedChildStacks)
+                return checkInNestedChildStacks;
+        }
+        return undefined;
+    }
+    formatResourceAttribute(resource, attribute) {
+        const physicalId = resource.PhysicalResourceId;
+        // no attribute means Ref expression, for which we use the physical ID directly
+        if (!attribute) {
+            return physicalId;
+        }
+        const resourceTypeFormats = RESOURCE_TYPE_ATTRIBUTES_FORMATS[resource.ResourceType];
+        if (!resourceTypeFormats) {
+            throw new CfnEvaluationException(`We don't support attributes of the '${resource.ResourceType}' resource. This is a CDK limitation. ` +
+                'Please report it at https://github.com/aws/aws-cdk/issues/new/choose');
+        }
+        const attributeFmtFunc = resourceTypeFormats[attribute];
+        if (!attributeFmtFunc) {
+            throw new CfnEvaluationException(`We don't support the '${attribute}' attribute of the '${resource.ResourceType}' resource. This is a CDK limitation. ` +
+                'Please report it at https://github.com/aws/aws-cdk/issues/new/choose');
+        }
+        const service = this.getServiceOfResource(resource);
+        const resourceTypeArnPart = this.getResourceTypeArnPartOfResource(resource);
+        return attributeFmtFunc({
+            partition: this.partition,
+            service,
+            region: this.region,
+            account: this.account,
+            resourceType: resourceTypeArnPart,
+            resourceName: physicalId,
+        });
+    }
+    getServiceOfResource(resource) {
+        return resource.ResourceType.split('::')[1].toLowerCase();
+    }
+    getResourceTypeArnPartOfResource(resource) {
+        const resourceType = resource.ResourceType;
+        const specialCaseResourceType = RESOURCE_TYPE_SPECIAL_NAMES[resourceType]?.resourceType;
+        return specialCaseResourceType
+            ? specialCaseResourceType
+            : // this is the default case
+                resourceType.split('::')[2].toLowerCase();
+    }
+}
+exports.EvaluateCloudFormationTemplate = EvaluateCloudFormationTemplate;
+/**
+ * Usually, we deduce the names of the service and the resource type used to format the ARN from the CloudFormation resource type.
+ * For a CFN type like AWS::Service::ResourceType, the second segment becomes the service name, and the third the resource type
+ * (after converting both of them to lowercase).
+ * However, some resource types break this simple convention, and we need to special-case them.
+ * This map is for storing those cases.
+ */
+const RESOURCE_TYPE_SPECIAL_NAMES = {
+    'AWS::Events::EventBus': {
+        resourceType: 'event-bus',
+    },
+};
+const RESOURCE_TYPE_ATTRIBUTES_FORMATS = {
+    'AWS::IAM::Role': { Arn: iamArnFmt },
+    'AWS::IAM::User': { Arn: iamArnFmt },
+    'AWS::IAM::Group': { Arn: iamArnFmt },
+    'AWS::S3::Bucket': { Arn: s3ArnFmt },
+    'AWS::Lambda::Function': { Arn: stdColonResourceArnFmt },
+    'AWS::Events::EventBus': {
+        Arn: stdSlashResourceArnFmt,
+        // the name attribute of the EventBus is the same as the Ref
+        Name: (parts) => parts.resourceName,
+    },
+    'AWS::DynamoDB::Table': { Arn: stdSlashResourceArnFmt },
+    'AWS::AppSync::GraphQLApi': { ApiId: appsyncGraphQlApiApiIdFmt },
+    'AWS::AppSync::FunctionConfiguration': {
+        FunctionId: appsyncGraphQlFunctionIDFmt,
+    },
+    'AWS::AppSync::DataSource': { Name: appsyncGraphQlDataSourceNameFmt },
+    'AWS::KMS::Key': { Arn: stdSlashResourceArnFmt },
+};
+function iamArnFmt(parts) {
+    // we skip region for IAM resources
+    return `arn:${parts.partition}:${parts.service}::${parts.account}:${parts.resourceType}/${parts.resourceName}`;
+}
+function s3ArnFmt(parts) {
+    // we skip account, region and resourceType for S3 resources
+    return `arn:${parts.partition}:${parts.service}:::${parts.resourceName}`;
+}
+function stdColonResourceArnFmt(parts) {
+    // this is a standard format for ARNs like: arn:aws:service:region:account:resourceType:resourceName
+    return `arn:${parts.partition}:${parts.service}:${parts.region}:${parts.account}:${parts.resourceType}:${parts.resourceName}`;
+}
+function stdSlashResourceArnFmt(parts) {
+    // this is a standard format for ARNs like: arn:aws:service:region:account:resourceType/resourceName
+    return `arn:${parts.partition}:${parts.service}:${parts.region}:${parts.account}:${parts.resourceType}/${parts.resourceName}`;
+}
+function appsyncGraphQlApiApiIdFmt(parts) {
+    // arn:aws:appsync:us-east-1:111111111111:apis/<apiId>
+    return parts.resourceName.split('/')[1];
+}
+function appsyncGraphQlFunctionIDFmt(parts) {
+    // arn:aws:appsync:us-east-1:111111111111:apis/<apiId>/functions/<functionId>
+    return parts.resourceName.split('/')[3];
+}
+function appsyncGraphQlDataSourceNameFmt(parts) {
+    // arn:aws:appsync:us-east-1:111111111111:apis/<apiId>/datasources/<name>
+    return parts.resourceName.split('/')[3];
+}
+async function asyncGlobalReplace(str, regex, cb) {
+    if (!regex.global) {
+        throw new toolkit_error_1.ToolkitError('Regex must be created with /g flag');
+    }
+    const ret = new Array();
+    let start = 0;
+    while (true) {
+        const match = regex.exec(str);
+        if (!match) {
+            break;
+        }
+        ret.push(str.substring(start, match.index));
+        ret.push(await cb(match[1]));
+        start = regex.lastIndex;
+    }
+    ret.push(str.slice(start));
+    return ret.join('');
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"evaluate-cloudformation-template.js","sourceRoot":"","sources":["evaluate-cloudformation-template.ts"],"names":[],"mappings":"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","sourcesContent":["import type { CloudFormationStackArtifact } from '@aws-cdk/cx-api';\nimport type { Export, ListExportsCommandOutput, StackResourceSummary } from '@aws-sdk/client-cloudformation';\nimport type { NestedStackTemplates } from './nested-stack-helpers';\nimport type { Template } from './stack-helpers';\nimport { ToolkitError } from '../../toolkit/toolkit-error';\nimport type { SDK } from '../aws-auth/private';\nimport type { ResourceMetadata } from '../resource-metadata';\nimport { resourceMetadata } from '../resource-metadata';\n\nexport interface ListStackResources {\n  listStackResources(): Promise<StackResourceSummary[]>;\n}\n\nexport class LazyListStackResources implements ListStackResources {\n  private stackResources: Promise<StackResourceSummary[]> | undefined;\n\n  constructor(\n    private readonly sdk: SDK,\n    private readonly stackName: string,\n  ) {\n  }\n\n  public async listStackResources(): Promise<StackResourceSummary[]> {\n    if (this.stackResources === undefined) {\n      this.stackResources = this.sdk.cloudFormation().listStackResources({\n        StackName: this.stackName,\n      });\n    }\n    return this.stackResources;\n  }\n}\n\nexport interface LookupExport {\n  lookupExport(name: string): Promise<Export | undefined>;\n}\n\nexport class LookupExportError extends Error {\n}\n\nexport class LazyLookupExport implements LookupExport {\n  private cachedExports: { [name: string]: Export } = {};\n\n  constructor(private readonly sdk: SDK) {\n  }\n\n  async lookupExport(name: string): Promise<Export | undefined> {\n    if (this.cachedExports[name]) {\n      return this.cachedExports[name];\n    }\n\n    for await (const cfnExport of this.listExports()) {\n      if (!cfnExport.Name) {\n        continue; // ignore any result that omits a name\n      }\n      this.cachedExports[cfnExport.Name] = cfnExport;\n\n      if (cfnExport.Name === name) {\n        return cfnExport;\n      }\n    }\n\n    return undefined; // export not found\n  }\n\n  // TODO: Paginate\n  private async *listExports() {\n    let nextToken: string | undefined = undefined;\n    while (true) {\n      const response: ListExportsCommandOutput = await this.sdk.cloudFormation().listExports({ NextToken: nextToken });\n      for (const cfnExport of response.Exports ?? []) {\n        yield cfnExport;\n      }\n\n      if (!response.NextToken) {\n        return;\n      }\n      nextToken = response.NextToken;\n    }\n  }\n}\n\nexport class CfnEvaluationException extends Error {\n}\n\nexport interface ResourceDefinition {\n  readonly LogicalId: string;\n  readonly Type: string;\n  readonly Properties: { [p: string]: any };\n}\n\nexport interface EvaluateCloudFormationTemplateProps {\n  readonly stackArtifact: CloudFormationStackArtifact;\n  readonly stackName?: string;\n  readonly template?: Template;\n  readonly parameters: { [parameterName: string]: string };\n  readonly account: string;\n  readonly region: string;\n  readonly partition: string;\n  readonly sdk: SDK;\n  readonly nestedStacks?: {\n    [nestedStackLogicalId: string]: NestedStackTemplates;\n  };\n}\n\nexport class EvaluateCloudFormationTemplate {\n  public readonly stackArtifact: CloudFormationStackArtifact;\n  private readonly stackName: string;\n  private readonly template: Template;\n  private readonly context: { [k: string]: any };\n  private readonly account: string;\n  private readonly region: string;\n  private readonly partition: string;\n  private readonly sdk: SDK;\n  private readonly nestedStacks: {\n    [nestedStackLogicalId: string]: NestedStackTemplates;\n  };\n  private readonly stackResources: ListStackResources;\n  private readonly lookupExport: LookupExport;\n\n  private cachedUrlSuffix: string | undefined;\n\n  constructor(props: EvaluateCloudFormationTemplateProps) {\n    this.stackArtifact = props.stackArtifact;\n    this.stackName = props.stackName ?? props.stackArtifact.stackName;\n    this.template = props.template ?? props.stackArtifact.template;\n    this.context = {\n      'AWS::AccountId': props.account,\n      'AWS::Region': props.region,\n      'AWS::Partition': props.partition,\n      ...props.parameters,\n    };\n    this.account = props.account;\n    this.region = props.region;\n    this.partition = props.partition;\n    this.sdk = props.sdk;\n\n    // We need names of nested stack so we can evaluate cross stack references\n    this.nestedStacks = props.nestedStacks ?? {};\n\n    // The current resources of the Stack.\n    // We need them to figure out the physical name of a resource in case it wasn't specified by the user.\n    // We fetch it lazily, to save a service call, in case all hotswapped resources have their physical names set.\n    this.stackResources = new LazyListStackResources(this.sdk, this.stackName);\n\n    // CloudFormation Exports lookup to be able to resolve Fn::ImportValue intrinsics in template\n    this.lookupExport = new LazyLookupExport(this.sdk);\n  }\n\n  // clones current EvaluateCloudFormationTemplate object, but updates the stack name\n  public async createNestedEvaluateCloudFormationTemplate(\n    stackName: string,\n    nestedTemplate: Template,\n    nestedStackParameters: { [parameterName: string]: any },\n  ) {\n    const evaluatedParams = await this.evaluateCfnExpression(nestedStackParameters);\n    return new EvaluateCloudFormationTemplate({\n      stackArtifact: this.stackArtifact,\n      stackName,\n      template: nestedTemplate,\n      parameters: evaluatedParams,\n      account: this.account,\n      region: this.region,\n      partition: this.partition,\n      sdk: this.sdk,\n      nestedStacks: this.nestedStacks,\n    });\n  }\n\n  public async establishResourcePhysicalName(\n    logicalId: string,\n    physicalNameInCfnTemplate: any,\n  ): Promise<string | undefined> {\n    if (physicalNameInCfnTemplate != null) {\n      try {\n        return await this.evaluateCfnExpression(physicalNameInCfnTemplate);\n      } catch (e) {\n        // If we can't evaluate the resource's name CloudFormation expression,\n        // just look it up in the currently deployed Stack\n        if (!(e instanceof CfnEvaluationException)) {\n          throw e;\n        }\n      }\n    }\n    return this.findPhysicalNameFor(logicalId);\n  }\n\n  public async findPhysicalNameFor(logicalId: string): Promise<string | undefined> {\n    const stackResources = await this.stackResources.listStackResources();\n    return stackResources.find((sr) => sr.LogicalResourceId === logicalId)?.PhysicalResourceId;\n  }\n\n  public async findLogicalIdForPhysicalName(physicalName: string): Promise<string | undefined> {\n    const stackResources = await this.stackResources.listStackResources();\n    return stackResources.find((sr) => sr.PhysicalResourceId === physicalName)?.LogicalResourceId;\n  }\n\n  public findReferencesTo(logicalId: string): Array<ResourceDefinition> {\n    const ret = new Array<ResourceDefinition>();\n    for (const [resourceLogicalId, resourceDef] of Object.entries(this.template?.Resources ?? {})) {\n      if (logicalId !== resourceLogicalId && this.references(logicalId, resourceDef)) {\n        ret.push({\n          ...(resourceDef as any),\n          LogicalId: resourceLogicalId,\n        });\n      }\n    }\n    return ret;\n  }\n\n  public async evaluateCfnExpression(cfnExpression: any): Promise<any> {\n    const self = this;\n    /**\n     * Evaluates CloudFormation intrinsic functions\n     *\n     * Note that supported intrinsic functions are documented in README.md -- please update\n     * list of supported functions when adding new evaluations\n     *\n     * See: https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/intrinsic-function-reference.html\n     */\n    class CfnIntrinsics {\n      public evaluateIntrinsic(intrinsic: Intrinsic): any {\n        const intrinsicFunc = (this as any)[intrinsic.name];\n        if (!intrinsicFunc) {\n          throw new CfnEvaluationException(`CloudFormation function ${intrinsic.name} is not supported`);\n        }\n\n        const argsAsArray = Array.isArray(intrinsic.args) ? intrinsic.args : [intrinsic.args];\n\n        return intrinsicFunc.apply(this, argsAsArray);\n      }\n\n      async 'Fn::Join'(separator: string, args: any[]): Promise<string> {\n        const evaluatedArgs = await self.evaluateCfnExpression(args);\n        return evaluatedArgs.join(separator);\n      }\n\n      async 'Fn::Split'(separator: string, args: any): Promise<string> {\n        const evaluatedArgs = await self.evaluateCfnExpression(args);\n        return evaluatedArgs.split(separator);\n      }\n\n      async 'Fn::Select'(index: number, args: any[]): Promise<string> {\n        const evaluatedArgs = await self.evaluateCfnExpression(args);\n        return evaluatedArgs[index];\n      }\n\n      async Ref(logicalId: string): Promise<string> {\n        const refTarget = await self.findRefTarget(logicalId);\n        if (refTarget) {\n          return refTarget;\n        } else {\n          throw new CfnEvaluationException(`Parameter or resource '${logicalId}' could not be found for evaluation`);\n        }\n      }\n\n      async 'Fn::GetAtt'(logicalId: string, attributeName: string): Promise<string> {\n        // ToDo handle the 'logicalId.attributeName' form of Fn::GetAtt\n        const attrValue = await self.findGetAttTarget(logicalId, attributeName);\n        if (attrValue) {\n          return attrValue;\n        } else {\n          throw new CfnEvaluationException(\n            `Attribute '${attributeName}' of resource '${logicalId}' could not be found for evaluation`,\n          );\n        }\n      }\n\n      async 'Fn::Sub'(template: string, explicitPlaceholders?: { [variable: string]: string }): Promise<string> {\n        const placeholders = explicitPlaceholders ? await self.evaluateCfnExpression(explicitPlaceholders) : {};\n\n        return asyncGlobalReplace(template, /\\${([^}]*)}/g, (key) => {\n          if (key in placeholders) {\n            return placeholders[key];\n          } else {\n            const splitKey = key.split('.');\n            return splitKey.length === 1 ? this.Ref(key) : this['Fn::GetAtt'](splitKey[0], splitKey.slice(1).join('.'));\n          }\n        });\n      }\n\n      async 'Fn::ImportValue'(name: string): Promise<string> {\n        const exported = await self.lookupExport.lookupExport(name);\n        if (!exported) {\n          throw new CfnEvaluationException(`Export '${name}' could not be found for evaluation`);\n        }\n        if (!exported.Value) {\n          throw new CfnEvaluationException(`Export '${name}' exists without a value`);\n        }\n        return exported.Value;\n      }\n    }\n\n    if (cfnExpression == null) {\n      return cfnExpression;\n    }\n\n    if (Array.isArray(cfnExpression)) {\n      // Small arrays in practice\n      // eslint-disable-next-line @cdklabs/promiseall-no-unbounded-parallelism\n      return Promise.all(cfnExpression.map((expr) => this.evaluateCfnExpression(expr)));\n    }\n\n    if (typeof cfnExpression === 'object') {\n      const intrinsic = this.parseIntrinsic(cfnExpression);\n      if (intrinsic) {\n        return new CfnIntrinsics().evaluateIntrinsic(intrinsic);\n      } else {\n        const ret: { [key: string]: any } = {};\n        for (const [key, val] of Object.entries(cfnExpression)) {\n          ret[key] = await this.evaluateCfnExpression(val);\n        }\n        return ret;\n      }\n    }\n\n    return cfnExpression;\n  }\n\n  public getResourceProperty(logicalId: string, propertyName: string): any {\n    return this.template.Resources?.[logicalId]?.Properties?.[propertyName];\n  }\n\n  public metadataFor(logicalId: string): ResourceMetadata | undefined {\n    return resourceMetadata(this.stackArtifact, logicalId);\n  }\n\n  private references(logicalId: string, templateElement: any): boolean {\n    if (typeof templateElement === 'string') {\n      return logicalId === templateElement;\n    }\n\n    if (templateElement == null) {\n      return false;\n    }\n\n    if (Array.isArray(templateElement)) {\n      return templateElement.some((el) => this.references(logicalId, el));\n    }\n\n    if (typeof templateElement === 'object') {\n      return Object.values(templateElement).some((el) => this.references(logicalId, el));\n    }\n\n    return false;\n  }\n\n  private parseIntrinsic(x: any): Intrinsic | undefined {\n    const keys = Object.keys(x);\n    if (keys.length === 1 && (keys[0].startsWith('Fn::') || keys[0] === 'Ref')) {\n      return {\n        name: keys[0],\n        args: x[keys[0]],\n      };\n    }\n    return undefined;\n  }\n\n  private async findRefTarget(logicalId: string): Promise<string | undefined> {\n    // first, check to see if the Ref is a Parameter who's value we have\n    if (logicalId === 'AWS::URLSuffix') {\n      if (!this.cachedUrlSuffix) {\n        this.cachedUrlSuffix = await this.sdk.getUrlSuffix(this.region);\n      }\n\n      return this.cachedUrlSuffix;\n    }\n\n    // Try finding the ref in the passed in parameters\n    const parameterTarget = this.context[logicalId];\n    if (parameterTarget) {\n      return parameterTarget;\n    }\n\n    // If not in the passed in parameters, see if there is a default value in the template parameter that was not passed in\n    const defaultParameterValue = this.template.Parameters?.[logicalId]?.Default;\n    if (defaultParameterValue) {\n      return defaultParameterValue;\n    }\n\n    // if it's not a Parameter, we need to search in the current Stack resources\n    return this.findGetAttTarget(logicalId);\n  }\n\n  private async findGetAttTarget(logicalId: string, attribute?: string): Promise<string | undefined> {\n    // Handle case where the attribute is referencing a stack output (used in nested stacks to share parameters)\n    // See https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/quickref-cloudformation.html#w2ab1c17c23c19b5\n    if (logicalId === 'Outputs' && attribute) {\n      return this.evaluateCfnExpression(this.template.Outputs[attribute]?.Value);\n    }\n\n    const stackResources = await this.stackResources.listStackResources();\n    const foundResource = stackResources.find((sr) => sr.LogicalResourceId === logicalId);\n    if (!foundResource) {\n      return undefined;\n    }\n\n    if (foundResource.ResourceType == 'AWS::CloudFormation::Stack' && attribute?.startsWith('Outputs.')) {\n      const dependantStack = this.findNestedStack(logicalId, this.nestedStacks);\n      if (!dependantStack || !dependantStack.physicalName) {\n        // this is a newly created nested stack and cannot be hotswapped\n        return undefined;\n      }\n      const evaluateCfnTemplate = await this.createNestedEvaluateCloudFormationTemplate(\n        dependantStack.physicalName,\n        dependantStack.generatedTemplate,\n        dependantStack.generatedTemplate.Parameters!,\n      );\n\n      // Split Outputs.<refName> into 'Outputs' and '<refName>' and recursively call evaluate\n      return evaluateCfnTemplate.evaluateCfnExpression({\n        'Fn::GetAtt': attribute.split(/\\.(.*)/s),\n      });\n    }\n    // now, we need to format the appropriate identifier depending on the resource type,\n    // and the requested attribute name\n    return this.formatResourceAttribute(foundResource, attribute);\n  }\n\n  private findNestedStack(\n    logicalId: string,\n    nestedStacks: {\n      [nestedStackLogicalId: string]: NestedStackTemplates;\n    },\n  ): NestedStackTemplates | undefined {\n    for (const nestedStackLogicalId of Object.keys(nestedStacks)) {\n      if (nestedStackLogicalId === logicalId) {\n        return nestedStacks[nestedStackLogicalId];\n      }\n      const checkInNestedChildStacks = this.findNestedStack(\n        logicalId,\n        nestedStacks[nestedStackLogicalId].nestedStackTemplates,\n      );\n      if (checkInNestedChildStacks) return checkInNestedChildStacks;\n    }\n    return undefined;\n  }\n\n  private formatResourceAttribute(resource: StackResourceSummary, attribute: string | undefined): string | undefined {\n    const physicalId = resource.PhysicalResourceId;\n\n    // no attribute means Ref expression, for which we use the physical ID directly\n    if (!attribute) {\n      return physicalId;\n    }\n\n    const resourceTypeFormats = RESOURCE_TYPE_ATTRIBUTES_FORMATS[resource.ResourceType!];\n    if (!resourceTypeFormats) {\n      throw new CfnEvaluationException(\n        `We don't support attributes of the '${resource.ResourceType}' resource. This is a CDK limitation. ` +\n          'Please report it at https://github.com/aws/aws-cdk/issues/new/choose',\n      );\n    }\n    const attributeFmtFunc = resourceTypeFormats[attribute];\n    if (!attributeFmtFunc) {\n      throw new CfnEvaluationException(\n        `We don't support the '${attribute}' attribute of the '${resource.ResourceType}' resource. This is a CDK limitation. ` +\n          'Please report it at https://github.com/aws/aws-cdk/issues/new/choose',\n      );\n    }\n    const service = this.getServiceOfResource(resource);\n    const resourceTypeArnPart = this.getResourceTypeArnPartOfResource(resource);\n    return attributeFmtFunc({\n      partition: this.partition,\n      service,\n      region: this.region,\n      account: this.account,\n      resourceType: resourceTypeArnPart,\n      resourceName: physicalId!,\n    });\n  }\n\n  private getServiceOfResource(resource: StackResourceSummary): string {\n    return resource.ResourceType!.split('::')[1].toLowerCase();\n  }\n\n  private getResourceTypeArnPartOfResource(resource: StackResourceSummary): string {\n    const resourceType = resource.ResourceType!;\n    const specialCaseResourceType = RESOURCE_TYPE_SPECIAL_NAMES[resourceType]?.resourceType;\n    return specialCaseResourceType\n      ? specialCaseResourceType\n      : // this is the default case\n      resourceType.split('::')[2].toLowerCase();\n  }\n}\n\ninterface ArnParts {\n  readonly partition: string;\n  readonly service: string;\n  readonly region: string;\n  readonly account: string;\n  readonly resourceType: string;\n  readonly resourceName: string;\n}\n\n/**\n * Usually, we deduce the names of the service and the resource type used to format the ARN from the CloudFormation resource type.\n * For a CFN type like AWS::Service::ResourceType, the second segment becomes the service name, and the third the resource type\n * (after converting both of them to lowercase).\n * However, some resource types break this simple convention, and we need to special-case them.\n * This map is for storing those cases.\n */\nconst RESOURCE_TYPE_SPECIAL_NAMES: {\n  [type: string]: { resourceType: string };\n} = {\n  'AWS::Events::EventBus': {\n    resourceType: 'event-bus',\n  },\n};\n\nconst RESOURCE_TYPE_ATTRIBUTES_FORMATS: {\n  [type: string]: { [attribute: string]: (parts: ArnParts) => string };\n} = {\n  'AWS::IAM::Role': { Arn: iamArnFmt },\n  'AWS::IAM::User': { Arn: iamArnFmt },\n  'AWS::IAM::Group': { Arn: iamArnFmt },\n  'AWS::S3::Bucket': { Arn: s3ArnFmt },\n  'AWS::Lambda::Function': { Arn: stdColonResourceArnFmt },\n  'AWS::Events::EventBus': {\n    Arn: stdSlashResourceArnFmt,\n    // the name attribute of the EventBus is the same as the Ref\n    Name: (parts) => parts.resourceName,\n  },\n  'AWS::DynamoDB::Table': { Arn: stdSlashResourceArnFmt },\n  'AWS::AppSync::GraphQLApi': { ApiId: appsyncGraphQlApiApiIdFmt },\n  'AWS::AppSync::FunctionConfiguration': {\n    FunctionId: appsyncGraphQlFunctionIDFmt,\n  },\n  'AWS::AppSync::DataSource': { Name: appsyncGraphQlDataSourceNameFmt },\n  'AWS::KMS::Key': { Arn: stdSlashResourceArnFmt },\n};\n\nfunction iamArnFmt(parts: ArnParts): string {\n  // we skip region for IAM resources\n  return `arn:${parts.partition}:${parts.service}::${parts.account}:${parts.resourceType}/${parts.resourceName}`;\n}\n\nfunction s3ArnFmt(parts: ArnParts): string {\n  // we skip account, region and resourceType for S3 resources\n  return `arn:${parts.partition}:${parts.service}:::${parts.resourceName}`;\n}\n\nfunction stdColonResourceArnFmt(parts: ArnParts): string {\n  // this is a standard format for ARNs like: arn:aws:service:region:account:resourceType:resourceName\n  return `arn:${parts.partition}:${parts.service}:${parts.region}:${parts.account}:${parts.resourceType}:${parts.resourceName}`;\n}\n\nfunction stdSlashResourceArnFmt(parts: ArnParts): string {\n  // this is a standard format for ARNs like: arn:aws:service:region:account:resourceType/resourceName\n  return `arn:${parts.partition}:${parts.service}:${parts.region}:${parts.account}:${parts.resourceType}/${parts.resourceName}`;\n}\n\nfunction appsyncGraphQlApiApiIdFmt(parts: ArnParts): string {\n  // arn:aws:appsync:us-east-1:111111111111:apis/<apiId>\n  return parts.resourceName.split('/')[1];\n}\n\nfunction appsyncGraphQlFunctionIDFmt(parts: ArnParts): string {\n  // arn:aws:appsync:us-east-1:111111111111:apis/<apiId>/functions/<functionId>\n  return parts.resourceName.split('/')[3];\n}\n\nfunction appsyncGraphQlDataSourceNameFmt(parts: ArnParts): string {\n  // arn:aws:appsync:us-east-1:111111111111:apis/<apiId>/datasources/<name>\n  return parts.resourceName.split('/')[3];\n}\n\ninterface Intrinsic {\n  readonly name: string;\n  readonly args: any;\n}\n\nasync function asyncGlobalReplace(str: string, regex: RegExp, cb: (x: string) => Promise<string>): Promise<string> {\n  if (!regex.global) {\n    throw new ToolkitError('Regex must be created with /g flag');\n  }\n\n  const ret = new Array<string>();\n  let start = 0;\n  while (true) {\n    const match = regex.exec(str);\n    if (!match) {\n      break;\n    }\n\n    ret.push(str.substring(start, match.index));\n    ret.push(await cb(match[1]));\n\n    start = regex.lastIndex;\n  }\n  ret.push(str.slice(start));\n\n  return ret.join('');\n}\n"]}

package/lib/api/cloudformation/index.d.ts

@@ -0,0 +1,4 @@
+export * from './evaluate-cloudformation-template';
+export * from './template-body-parameter';
+export * from './nested-stack-helpers';
+export * from './stack-helpers';

package/lib/api/cloudformation/index.js

@@ -0,0 +1,21 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./evaluate-cloudformation-template"), exports);
+__exportStar(require("./template-body-parameter"), exports);
+__exportStar(require("./nested-stack-helpers"), exports);
+__exportStar(require("./stack-helpers"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJpbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7O0FBQUEscUVBQW1EO0FBQ25ELDREQUEwQztBQUMxQyx5REFBdUM7QUFDdkMsa0RBQWdDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9ldmFsdWF0ZS1jbG91ZGZvcm1hdGlvbi10ZW1wbGF0ZSc7XG5leHBvcnQgKiBmcm9tICcuL3RlbXBsYXRlLWJvZHktcGFyYW1ldGVyJztcbmV4cG9ydCAqIGZyb20gJy4vbmVzdGVkLXN0YWNrLWhlbHBlcnMnO1xuZXhwb3J0ICogZnJvbSAnLi9zdGFjay1oZWxwZXJzJztcbiJdfQ==

package/lib/api/cloudformation/nested-stack-helpers.d.ts

@@ -0,0 +1,25 @@
+import type { CloudFormationStackArtifact } from '@aws-cdk/cx-api';
+import { type Template } from './stack-helpers';
+import type { SDK } from '../aws-auth/private';
+export interface RootTemplateWithNestedStacks {
+    readonly deployedRootTemplate: Template;
+    readonly nestedStacks: {
+        [nestedStackLogicalId: string]: NestedStackTemplates;
+    };
+}
+/**
+ * Reads the currently deployed template and all of its nested stack templates from CloudFormation.
+ */
+export declare function loadCurrentTemplateWithNestedStacks(rootStackArtifact: CloudFormationStackArtifact, sdk: SDK, retrieveProcessedTemplate?: boolean): Promise<RootTemplateWithNestedStacks>;
+/**
+ * Returns the currently deployed template from CloudFormation that corresponds to `stackArtifact`.
+ */
+export declare function loadCurrentTemplate(stackArtifact: CloudFormationStackArtifact, sdk: SDK, retrieveProcessedTemplate?: boolean): Promise<Template>;
+export interface NestedStackTemplates {
+    readonly physicalName: string | undefined;
+    readonly deployedTemplate: Template;
+    readonly generatedTemplate: Template;
+    readonly nestedStackTemplates: {
+        [nestedStackLogicalId: string]: NestedStackTemplates;
+    };
+}