@aws-cdk/toolkit-lib 0.3.2 → 0.3.3

package/lib/api/cloudformation/nested-stack-helpers.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadCurrentTemplateWithNestedStacks = loadCurrentTemplateWithNestedStacks;
+exports.loadCurrentTemplate = loadCurrentTemplate;
+const path = require("path");
+const fs = require("fs-extra");
+const evaluate_cloudformation_template_1 = require("./evaluate-cloudformation-template");
+const stack_helpers_1 = require("./stack-helpers");
+const util_1 = require("../../util");
+/**
+ * Reads the currently deployed template and all of its nested stack templates from CloudFormation.
+ */
+async function loadCurrentTemplateWithNestedStacks(rootStackArtifact, sdk, retrieveProcessedTemplate = false) {
+    const deployedRootTemplate = await loadCurrentTemplate(rootStackArtifact, sdk, retrieveProcessedTemplate);
+    const nestedStacks = await loadNestedStacks(rootStackArtifact, sdk, {
+        generatedTemplate: rootStackArtifact.template,
+        deployedTemplate: deployedRootTemplate,
+        deployedStackName: rootStackArtifact.stackName,
+    });
+    return {
+        deployedRootTemplate,
+        nestedStacks,
+    };
+}
+/**
+ * Returns the currently deployed template from CloudFormation that corresponds to `stackArtifact`.
+ */
+async function loadCurrentTemplate(stackArtifact, sdk, retrieveProcessedTemplate = false) {
+    return loadCurrentStackTemplate(stackArtifact.stackName, sdk, retrieveProcessedTemplate);
+}
+async function loadCurrentStackTemplate(stackName, sdk, retrieveProcessedTemplate = false) {
+    const cfn = sdk.cloudFormation();
+    const stack = await stack_helpers_1.CloudFormationStack.lookup(cfn, stackName, retrieveProcessedTemplate);
+    return stack.template();
+}
+async function loadNestedStacks(rootStackArtifact, sdk, parentTemplates) {
+    const listStackResources = parentTemplates.deployedStackName
+        ? new evaluate_cloudformation_template_1.LazyListStackResources(sdk, parentTemplates.deployedStackName)
+        : undefined;
+    const nestedStacks = {};
+    for (const [nestedStackLogicalId, generatedNestedStackResource] of Object.entries(parentTemplates.generatedTemplate.Resources ?? {})) {
+        if (!isCdkManagedNestedStack(generatedNestedStackResource)) {
+            continue;
+        }
+        const assetPath = generatedNestedStackResource.Metadata['aws:asset:path'];
+        const nestedStackTemplates = await getNestedStackTemplates(rootStackArtifact, assetPath, nestedStackLogicalId, listStackResources, sdk);
+        nestedStacks[nestedStackLogicalId] = {
+            deployedTemplate: nestedStackTemplates.deployedTemplate,
+            generatedTemplate: nestedStackTemplates.generatedTemplate,
+            physicalName: nestedStackTemplates.deployedStackName,
+            nestedStackTemplates: await loadNestedStacks(rootStackArtifact, sdk, nestedStackTemplates),
+        };
+    }
+    return nestedStacks;
+}
+async function getNestedStackTemplates(rootStackArtifact, nestedTemplateAssetPath, nestedStackLogicalId, listStackResources, sdk) {
+    const nestedTemplatePath = path.join(rootStackArtifact.assembly.directory, nestedTemplateAssetPath);
+    // CFN generates the nested stack name in the form `ParentStackName-NestedStackLogicalID-SomeHashWeCan'tCompute,
+    // the arn is of the form: arn:aws:cloudformation:region:123456789012:stack/NestedStackName/AnotherHashWeDon'tNeed
+    // so we get the ARN and manually extract the name.
+    const nestedStackArn = await getNestedStackArn(nestedStackLogicalId, listStackResources);
+    const deployedStackName = nestedStackArn?.slice(nestedStackArn.indexOf('/') + 1, nestedStackArn.lastIndexOf('/'));
+    return {
+        generatedTemplate: JSON.parse(fs.readFileSync(nestedTemplatePath, 'utf-8')),
+        deployedTemplate: deployedStackName ? await loadCurrentStackTemplate(deployedStackName, sdk) : {},
+        deployedStackName,
+    };
+}
+async function getNestedStackArn(nestedStackLogicalId, listStackResources) {
+    try {
+        const stackResources = await listStackResources?.listStackResources();
+        return stackResources?.find((sr) => sr.LogicalResourceId === nestedStackLogicalId)?.PhysicalResourceId;
+    }
+    catch (e) {
+        if ((0, util_1.formatErrorMessage)(e).startsWith('Stack with id ') && (0, util_1.formatErrorMessage)(e).endsWith(' does not exist')) {
+            return;
+        }
+        throw e;
+    }
+}
+function isCdkManagedNestedStack(stackResource) {
+    return (stackResource.Type === 'AWS::CloudFormation::Stack' &&
+        stackResource.Metadata &&
+        stackResource.Metadata['aws:asset:path']);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"nested-stack-helpers.js","sourceRoot":"","sources":["nested-stack-helpers.ts"],"names":[],"mappings":"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","sourcesContent":["import * as path from 'path';\nimport type { CloudFormationStackArtifact } from '@aws-cdk/cx-api';\nimport * as fs from 'fs-extra';\nimport { LazyListStackResources, type ListStackResources } from './evaluate-cloudformation-template';\nimport { CloudFormationStack, type Template } from './stack-helpers';\nimport { formatErrorMessage } from '../../util';\nimport type { SDK } from '../aws-auth/private';\n\nexport interface RootTemplateWithNestedStacks {\n  readonly deployedRootTemplate: Template;\n  readonly nestedStacks: {\n    [nestedStackLogicalId: string]: NestedStackTemplates;\n  };\n}\n\n/**\n * Reads the currently deployed template and all of its nested stack templates from CloudFormation.\n */\nexport async function loadCurrentTemplateWithNestedStacks(\n  rootStackArtifact: CloudFormationStackArtifact,\n  sdk: SDK,\n  retrieveProcessedTemplate: boolean = false,\n): Promise<RootTemplateWithNestedStacks> {\n  const deployedRootTemplate = await loadCurrentTemplate(rootStackArtifact, sdk, retrieveProcessedTemplate);\n  const nestedStacks = await loadNestedStacks(rootStackArtifact, sdk, {\n    generatedTemplate: rootStackArtifact.template,\n    deployedTemplate: deployedRootTemplate,\n    deployedStackName: rootStackArtifact.stackName,\n  });\n\n  return {\n    deployedRootTemplate,\n    nestedStacks,\n  };\n}\n\n/**\n * Returns the currently deployed template from CloudFormation that corresponds to `stackArtifact`.\n */\nexport async function loadCurrentTemplate(\n  stackArtifact: CloudFormationStackArtifact,\n  sdk: SDK,\n  retrieveProcessedTemplate: boolean = false,\n): Promise<Template> {\n  return loadCurrentStackTemplate(stackArtifact.stackName, sdk, retrieveProcessedTemplate);\n}\n\nasync function loadCurrentStackTemplate(\n  stackName: string,\n  sdk: SDK,\n  retrieveProcessedTemplate: boolean = false,\n): Promise<Template> {\n  const cfn = sdk.cloudFormation();\n  const stack = await CloudFormationStack.lookup(cfn, stackName, retrieveProcessedTemplate);\n  return stack.template();\n}\n\nasync function loadNestedStacks(\n  rootStackArtifact: CloudFormationStackArtifact,\n  sdk: SDK,\n  parentTemplates: StackTemplates,\n): Promise<{ [nestedStackLogicalId: string]: NestedStackTemplates }> {\n  const listStackResources = parentTemplates.deployedStackName\n    ? new LazyListStackResources(sdk, parentTemplates.deployedStackName)\n    : undefined;\n  const nestedStacks: { [nestedStackLogicalId: string]: NestedStackTemplates } = {};\n  for (const [nestedStackLogicalId, generatedNestedStackResource] of Object.entries(\n    parentTemplates.generatedTemplate.Resources ?? {},\n  )) {\n    if (!isCdkManagedNestedStack(generatedNestedStackResource)) {\n      continue;\n    }\n\n    const assetPath = generatedNestedStackResource.Metadata['aws:asset:path'];\n    const nestedStackTemplates = await getNestedStackTemplates(\n      rootStackArtifact,\n      assetPath,\n      nestedStackLogicalId,\n      listStackResources,\n      sdk,\n    );\n\n    nestedStacks[nestedStackLogicalId] = {\n      deployedTemplate: nestedStackTemplates.deployedTemplate,\n      generatedTemplate: nestedStackTemplates.generatedTemplate,\n      physicalName: nestedStackTemplates.deployedStackName,\n      nestedStackTemplates: await loadNestedStacks(rootStackArtifact, sdk, nestedStackTemplates),\n    };\n  }\n\n  return nestedStacks;\n}\n\nasync function getNestedStackTemplates(\n  rootStackArtifact: CloudFormationStackArtifact,\n  nestedTemplateAssetPath: string,\n  nestedStackLogicalId: string,\n  listStackResources: ListStackResources | undefined,\n  sdk: SDK,\n): Promise<StackTemplates> {\n  const nestedTemplatePath = path.join(rootStackArtifact.assembly.directory, nestedTemplateAssetPath);\n\n  // CFN generates the nested stack name in the form `ParentStackName-NestedStackLogicalID-SomeHashWeCan'tCompute,\n  // the arn is of the form: arn:aws:cloudformation:region:123456789012:stack/NestedStackName/AnotherHashWeDon'tNeed\n  // so we get the ARN and manually extract the name.\n  const nestedStackArn = await getNestedStackArn(nestedStackLogicalId, listStackResources);\n  const deployedStackName = nestedStackArn?.slice(nestedStackArn.indexOf('/') + 1, nestedStackArn.lastIndexOf('/'));\n\n  return {\n    generatedTemplate: JSON.parse(fs.readFileSync(nestedTemplatePath, 'utf-8')),\n    deployedTemplate: deployedStackName ? await loadCurrentStackTemplate(deployedStackName, sdk) : {},\n    deployedStackName,\n  };\n}\n\nasync function getNestedStackArn(\n  nestedStackLogicalId: string,\n  listStackResources?: ListStackResources,\n): Promise<string | undefined> {\n  try {\n    const stackResources = await listStackResources?.listStackResources();\n    return stackResources?.find((sr) => sr.LogicalResourceId === nestedStackLogicalId)?.PhysicalResourceId;\n  } catch (e: any) {\n    if (formatErrorMessage(e).startsWith('Stack with id ') && formatErrorMessage(e).endsWith(' does not exist')) {\n      return;\n    }\n    throw e;\n  }\n}\n\nfunction isCdkManagedNestedStack(stackResource: any): stackResource is NestedStackResource {\n  return (\n    stackResource.Type === 'AWS::CloudFormation::Stack' &&\n    stackResource.Metadata &&\n    stackResource.Metadata['aws:asset:path']\n  );\n}\n\nexport interface NestedStackTemplates {\n  readonly physicalName: string | undefined;\n  readonly deployedTemplate: Template;\n  readonly generatedTemplate: Template;\n  readonly nestedStackTemplates: {\n    [nestedStackLogicalId: string]: NestedStackTemplates;\n  };\n}\n\ninterface StackTemplates {\n  readonly generatedTemplate: any;\n  readonly deployedTemplate: any;\n  readonly deployedStackName: string | undefined;\n}\n\ninterface NestedStackResource {\n  readonly Metadata: { 'aws:asset:path': string };\n  readonly Properties: any;\n}\n"]}

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

@@ -0,0 +1,96 @@
+import type { Stack, Tag } from '@aws-sdk/client-cloudformation';
+import type { ICloudFormationClient } from '../aws-auth/private';
+import { StackStatus } from '../stack-events';
+export interface Template {
+    Parameters?: Record<string, TemplateParameter>;
+    [section: string]: any;
+}
+export interface TemplateParameter {
+    Type: string;
+    Default?: any;
+    Description?: string;
+    [key: string]: any;
+}
+/**
+ * Represents an (existing) Stack in CloudFormation
+ *
+ * Bundle and cache some information that we need during deployment (so we don't have to make
+ * repeated calls to CloudFormation).
+ */
+export declare class CloudFormationStack {
+    private readonly cfn;
+    readonly stackName: string;
+    private readonly stack?;
+    private readonly retrieveProcessedTemplate;
+    static lookup(cfn: ICloudFormationClient, stackName: string, retrieveProcessedTemplate?: boolean): Promise<CloudFormationStack>;
+    /**
+     * Return a copy of the given stack that does not exist
+     *
+     * It's a little silly that it needs arguments to do that, but there we go.
+     */
+    static doesNotExist(cfn: ICloudFormationClient, stackName: string): CloudFormationStack;
+    /**
+     * From static information (for testing)
+     */
+    static fromStaticInformation(cfn: ICloudFormationClient, stackName: string, stack: Stack): CloudFormationStack;
+    private _template;
+    protected constructor(cfn: ICloudFormationClient, stackName: string, stack?: Stack | undefined, retrieveProcessedTemplate?: boolean);
+    /**
+     * Retrieve the stack's deployed template
+     *
+     * Cached, so will only be retrieved once. Will return an empty
+     * structure if the stack does not exist.
+     */
+    template(): Promise<Template>;
+    /**
+     * Whether the stack exists
+     */
+    get exists(): boolean;
+    /**
+     * The stack's ID (which is the same as its ARN)
+     *
+     * Throws if the stack doesn't exist.
+     */
+    get stackId(): string;
+    /**
+     * The stack's current outputs
+     *
+     * Empty object if the stack doesn't exist
+     */
+    get outputs(): Record<string, string>;
+    /**
+     * The stack's status
+     *
+     * Special status NOT_FOUND if the stack does not exist.
+     */
+    get stackStatus(): StackStatus;
+    /**
+     * The stack's current tags
+     *
+     * Empty list if the stack does not exist
+     */
+    get tags(): Tag[];
+    /**
+     * SNS Topic ARNs that will receive stack events.
+     *
+     * Empty list if the stack does not exist
+     */
+    get notificationArns(): string[];
+    /**
+     * Return the names of all current parameters to the stack
+     *
+     * Empty list if the stack does not exist.
+     */
+    get parameterNames(): string[];
+    /**
+     * Return the names and values of all current parameters to the stack
+     *
+     * Empty object if the stack does not exist.
+     */
+    get parameters(): Record<string, string>;
+    /**
+     * Return the termination protection of the stack
+     */
+    get terminationProtection(): boolean | undefined;
+    private assertExists;
+}

package/lib/api/cloudformation/stack-helpers.js

@@ -0,0 +1,163 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CloudFormationStack = void 0;
+const util_1 = require("../../util");
+const stack_events_1 = require("../stack-events");
+const toolkit_error_1 = require("../toolkit-error");
+/**
+ * Represents an (existing) Stack in CloudFormation
+ *
+ * Bundle and cache some information that we need during deployment (so we don't have to make
+ * repeated calls to CloudFormation).
+ */
+class CloudFormationStack {
+    cfn;
+    stackName;
+    stack;
+    retrieveProcessedTemplate;
+    static async lookup(cfn, stackName, retrieveProcessedTemplate = false) {
+        try {
+            const response = await cfn.describeStacks({ StackName: stackName });
+            return new CloudFormationStack(cfn, stackName, response.Stacks && response.Stacks[0], retrieveProcessedTemplate);
+        }
+        catch (e) {
+            if (e.name === 'ValidationError' && (0, util_1.formatErrorMessage)(e) === `Stack with id ${stackName} does not exist`) {
+                return new CloudFormationStack(cfn, stackName, undefined);
+            }
+            throw e;
+        }
+    }
+    /**
+     * Return a copy of the given stack that does not exist
+     *
+     * It's a little silly that it needs arguments to do that, but there we go.
+     */
+    static doesNotExist(cfn, stackName) {
+        return new CloudFormationStack(cfn, stackName);
+    }
+    /**
+     * From static information (for testing)
+     */
+    static fromStaticInformation(cfn, stackName, stack) {
+        return new CloudFormationStack(cfn, stackName, stack);
+    }
+    _template;
+    constructor(cfn, stackName, stack, retrieveProcessedTemplate = false) {
+        this.cfn = cfn;
+        this.stackName = stackName;
+        this.stack = stack;
+        this.retrieveProcessedTemplate = retrieveProcessedTemplate;
+    }
+    /**
+     * Retrieve the stack's deployed template
+     *
+     * Cached, so will only be retrieved once. Will return an empty
+     * structure if the stack does not exist.
+     */
+    async template() {
+        if (!this.exists) {
+            return {};
+        }
+        if (this._template === undefined) {
+            const response = await this.cfn.getTemplate({
+                StackName: this.stackName,
+                TemplateStage: this.retrieveProcessedTemplate ? 'Processed' : 'Original',
+            });
+            this._template = (response.TemplateBody && (0, util_1.deserializeStructure)(response.TemplateBody)) || {};
+        }
+        return this._template;
+    }
+    /**
+     * Whether the stack exists
+     */
+    get exists() {
+        return this.stack !== undefined;
+    }
+    /**
+     * The stack's ID (which is the same as its ARN)
+     *
+     * Throws if the stack doesn't exist.
+     */
+    get stackId() {
+        this.assertExists();
+        return this.stack.StackId;
+    }
+    /**
+     * The stack's current outputs
+     *
+     * Empty object if the stack doesn't exist
+     */
+    get outputs() {
+        if (!this.exists) {
+            return {};
+        }
+        const result = {};
+        (this.stack.Outputs || []).forEach((output) => {
+            result[output.OutputKey] = output.OutputValue;
+        });
+        return result;
+    }
+    /**
+     * The stack's status
+     *
+     * Special status NOT_FOUND if the stack does not exist.
+     */
+    get stackStatus() {
+        if (!this.exists) {
+            return new stack_events_1.StackStatus('NOT_FOUND', 'Stack not found during lookup');
+        }
+        return stack_events_1.StackStatus.fromStackDescription(this.stack);
+    }
+    /**
+     * The stack's current tags
+     *
+     * Empty list if the stack does not exist
+     */
+    get tags() {
+        return this.stack?.Tags || [];
+    }
+    /**
+     * SNS Topic ARNs that will receive stack events.
+     *
+     * Empty list if the stack does not exist
+     */
+    get notificationArns() {
+        return this.stack?.NotificationARNs ?? [];
+    }
+    /**
+     * Return the names of all current parameters to the stack
+     *
+     * Empty list if the stack does not exist.
+     */
+    get parameterNames() {
+        return Object.keys(this.parameters);
+    }
+    /**
+     * Return the names and values of all current parameters to the stack
+     *
+     * Empty object if the stack does not exist.
+     */
+    get parameters() {
+        if (!this.exists) {
+            return {};
+        }
+        const ret = {};
+        for (const param of this.stack.Parameters ?? []) {
+            ret[param.ParameterKey] = param.ResolvedValue ?? param.ParameterValue;
+        }
+        return ret;
+    }
+    /**
+     * Return the termination protection of the stack
+     */
+    get terminationProtection() {
+        return this.stack?.EnableTerminationProtection;
+    }
+    assertExists() {
+        if (!this.exists) {
+            throw new toolkit_error_1.ToolkitError(`No stack named '${this.stackName}'`);
+        }
+    }
+}
+exports.CloudFormationStack = CloudFormationStack;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"stack-helpers.js","sourceRoot":"","sources":["stack-helpers.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Stack, Tag } from '@aws-sdk/client-cloudformation';\nimport { formatErrorMessage, deserializeStructure } from '../../util';\nimport type { ICloudFormationClient } from '../aws-auth/private';\nimport { StackStatus } from '../stack-events';\nimport { ToolkitError } from '../toolkit-error';\n\nexport interface Template {\n  Parameters?: Record<string, TemplateParameter>;\n  [section: string]: any;\n}\n\nexport interface TemplateParameter {\n  Type: string;\n  Default?: any;\n  Description?: string;\n  [key: string]: any;\n}\n\n/**\n * Represents an (existing) Stack in CloudFormation\n *\n * Bundle and cache some information that we need during deployment (so we don't have to make\n * repeated calls to CloudFormation).\n */\nexport class CloudFormationStack {\n  public static async lookup(\n    cfn: ICloudFormationClient,\n    stackName: string,\n    retrieveProcessedTemplate: boolean = false,\n  ): Promise<CloudFormationStack> {\n    try {\n      const response = await cfn.describeStacks({ StackName: stackName });\n      return new CloudFormationStack(cfn, stackName, response.Stacks && response.Stacks[0], retrieveProcessedTemplate);\n    } catch (e: any) {\n      if (e.name === 'ValidationError' && formatErrorMessage(e) === `Stack with id ${stackName} does not exist`) {\n        return new CloudFormationStack(cfn, stackName, undefined);\n      }\n      throw e;\n    }\n  }\n\n  /**\n   * Return a copy of the given stack that does not exist\n   *\n   * It's a little silly that it needs arguments to do that, but there we go.\n   */\n  public static doesNotExist(cfn: ICloudFormationClient, stackName: string) {\n    return new CloudFormationStack(cfn, stackName);\n  }\n\n  /**\n   * From static information (for testing)\n   */\n  public static fromStaticInformation(cfn: ICloudFormationClient, stackName: string, stack: Stack) {\n    return new CloudFormationStack(cfn, stackName, stack);\n  }\n\n  private _template: any;\n\n  protected constructor(\n    private readonly cfn: ICloudFormationClient,\n    public readonly stackName: string,\n    private readonly stack?: Stack,\n    private readonly retrieveProcessedTemplate: boolean = false,\n  ) {\n  }\n\n  /**\n   * Retrieve the stack's deployed template\n   *\n   * Cached, so will only be retrieved once. Will return an empty\n   * structure if the stack does not exist.\n   */\n  public async template(): Promise<Template> {\n    if (!this.exists) {\n      return {};\n    }\n\n    if (this._template === undefined) {\n      const response = await this.cfn.getTemplate({\n        StackName: this.stackName,\n        TemplateStage: this.retrieveProcessedTemplate ? 'Processed' : 'Original',\n      });\n      this._template = (response.TemplateBody && deserializeStructure(response.TemplateBody)) || {};\n    }\n    return this._template;\n  }\n\n  /**\n   * Whether the stack exists\n   */\n  public get exists() {\n    return this.stack !== undefined;\n  }\n\n  /**\n   * The stack's ID (which is the same as its ARN)\n   *\n   * Throws if the stack doesn't exist.\n   */\n  public get stackId() {\n    this.assertExists();\n    return this.stack!.StackId!;\n  }\n\n  /**\n   * The stack's current outputs\n   *\n   * Empty object if the stack doesn't exist\n   */\n  public get outputs(): Record<string, string> {\n    if (!this.exists) {\n      return {};\n    }\n    const result: { [name: string]: string } = {};\n    (this.stack!.Outputs || []).forEach((output) => {\n      result[output.OutputKey!] = output.OutputValue!;\n    });\n    return result;\n  }\n\n  /**\n   * The stack's status\n   *\n   * Special status NOT_FOUND if the stack does not exist.\n   */\n  public get stackStatus(): StackStatus {\n    if (!this.exists) {\n      return new StackStatus('NOT_FOUND', 'Stack not found during lookup');\n    }\n    return StackStatus.fromStackDescription(this.stack!);\n  }\n\n  /**\n   * The stack's current tags\n   *\n   * Empty list if the stack does not exist\n   */\n  public get tags(): Tag[] {\n    return this.stack?.Tags || [];\n  }\n\n  /**\n   * SNS Topic ARNs that will receive stack events.\n   *\n   * Empty list if the stack does not exist\n   */\n  public get notificationArns(): string[] {\n    return this.stack?.NotificationARNs ?? [];\n  }\n\n  /**\n   * Return the names of all current parameters to the stack\n   *\n   * Empty list if the stack does not exist.\n   */\n  public get parameterNames(): string[] {\n    return Object.keys(this.parameters);\n  }\n\n  /**\n   * Return the names and values of all current parameters to the stack\n   *\n   * Empty object if the stack does not exist.\n   */\n  public get parameters(): Record<string, string> {\n    if (!this.exists) {\n      return {};\n    }\n    const ret: Record<string, string> = {};\n    for (const param of this.stack!.Parameters ?? []) {\n      ret[param.ParameterKey!] = param.ResolvedValue ?? param.ParameterValue!;\n    }\n    return ret;\n  }\n\n  /**\n   * Return the termination protection of the stack\n   */\n  public get terminationProtection(): boolean | undefined {\n    return this.stack?.EnableTerminationProtection;\n  }\n\n  private assertExists() {\n    if (!this.exists) {\n      throw new ToolkitError(`No stack named '${this.stackName}'`);\n    }\n  }\n}\n"]}

package/lib/api/cloudformation/template-body-parameter.d.ts

@@ -0,0 +1,22 @@
+import { type CloudFormationStackArtifact, type Environment } from '@aws-cdk/cx-api';
+import type { AssetManifestBuilder } from '../deployments';
+import type { EnvironmentResources } from '../environment';
+import { type IoHelper } from '../io/private';
+export type TemplateBodyParameter = {
+    TemplateBody?: string;
+    TemplateURL?: string;
+};
+/**
+ * Prepares the body parameter for +CreateChangeSet+.
+ *
+ * If the template is small enough to be inlined into the API call, just return
+ * it immediately.
+ *
+ * Otherwise, add it to the asset manifest to get uploaded to the staging
+ * bucket and return its coordinates. If there is no staging bucket, an error
+ * is thrown.
+ *
+ * @param stack     the synthesized stack that provides the CloudFormation template
+ * @param toolkitInfo information about the toolkit stack
+ */
+export declare function makeBodyParameter(ioHelper: IoHelper, stack: CloudFormationStackArtifact, resolvedEnvironment: Environment, assetManifest: AssetManifestBuilder, resources: EnvironmentResources, overrideTemplate?: any): Promise<TemplateBodyParameter>;

package/lib/api/cloudformation/template-body-parameter.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeBodyParameter = makeBodyParameter;
+const fs = require("node:fs/promises");
+const path = require("node:path");
+const util = require("node:util");
+const cx_api_1 = require("@aws-cdk/cx-api");
+const client_s3_1 = require("@aws-sdk/client-s3");
+const middleware_endpoint_1 = require("@smithy/middleware-endpoint");
+const chalk = require("chalk");
+const util_1 = require("../../util");
+const private_1 = require("../io/private");
+const toolkit_error_1 = require("../toolkit-error");
+const LARGE_TEMPLATE_SIZE_KB = 50;
+/**
+ * Prepares the body parameter for +CreateChangeSet+.
+ *
+ * If the template is small enough to be inlined into the API call, just return
+ * it immediately.
+ *
+ * Otherwise, add it to the asset manifest to get uploaded to the staging
+ * bucket and return its coordinates. If there is no staging bucket, an error
+ * is thrown.
+ *
+ * @param stack     the synthesized stack that provides the CloudFormation template
+ * @param toolkitInfo information about the toolkit stack
+ */
+async function makeBodyParameter(ioHelper, stack, resolvedEnvironment, assetManifest, resources, overrideTemplate) {
+    // If the template has already been uploaded to S3, just use it from there.
+    if (stack.stackTemplateAssetObjectUrl && !overrideTemplate) {
+        return {
+            TemplateURL: await restUrlFromManifest(stack.stackTemplateAssetObjectUrl, resolvedEnvironment),
+        };
+    }
+    // Otherwise, pass via API call (if small) or upload here (if large)
+    const templateJson = (0, util_1.toYAML)(overrideTemplate ?? stack.template);
+    if (templateJson.length <= LARGE_TEMPLATE_SIZE_KB * 1024) {
+        return { TemplateBody: templateJson };
+    }
+    const toolkitInfo = await resources.lookupToolkit();
+    if (!toolkitInfo.found) {
+        await ioHelper.notify(private_1.IO.DEFAULT_TOOLKIT_ERROR.msg(util.format(`The template for stack "${stack.displayName}" is ${Math.round(templateJson.length / 1024)}KiB. ` +
+            `Templates larger than ${LARGE_TEMPLATE_SIZE_KB}KiB must be uploaded to S3.\n` +
+            'Run the following command in order to setup an S3 bucket in this environment, and then re-deploy:\n\n', chalk.blue(`\t$ cdk bootstrap ${resolvedEnvironment.name}\n`))));
+        throw new toolkit_error_1.ToolkitError('Template too large to deploy ("cdk bootstrap" is required)');
+    }
+    const templateHash = (0, util_1.contentHash)(templateJson);
+    const key = `cdk/${stack.id}/${templateHash}.yml`;
+    let templateFile = stack.templateFile;
+    if (overrideTemplate) {
+        // Add a variant of this template
+        templateFile = `${stack.templateFile}-${templateHash}.yaml`;
+        const templateFilePath = path.join(stack.assembly.directory, templateFile);
+        await fs.writeFile(templateFilePath, templateJson, { encoding: 'utf-8' });
+    }
+    assetManifest.addFileAsset(templateHash, {
+        path: templateFile,
+    }, {
+        bucketName: toolkitInfo.bucketName,
+        objectKey: key,
+    });
+    const templateURL = `${toolkitInfo.bucketUrl}/${key}`;
+    await ioHelper.notify(private_1.IO.DEFAULT_TOOLKIT_DEBUG.msg(`Storing template in S3 at: ${templateURL}`));
+    return { TemplateURL: templateURL };
+}
+/**
+ * Format an S3 URL in the manifest for use with CloudFormation
+ *
+ * Replaces environment placeholders (which this field may contain),
+ * and reformats s3://.../... urls into S3 REST URLs (which CloudFormation
+ * expects)
+ */
+async function restUrlFromManifest(url, environment) {
+    const doNotUseMarker = '**DONOTUSE**';
+    const region = environment.region;
+    // This URL may contain placeholders, so still substitute those.
+    url = cx_api_1.EnvironmentPlaceholders.replace(url, {
+        accountId: environment.account,
+        region,
+        partition: doNotUseMarker,
+    });
+    // Yes, this is extremely crude, but we don't actually need this so I'm not inclined to spend
+    // a lot of effort trying to thread the right value to this location.
+    if (url.indexOf(doNotUseMarker) > -1) {
+        throw new toolkit_error_1.ToolkitError("Cannot use '${AWS::Partition}' in the 'stackTemplateAssetObjectUrl' field");
+    }
+    const s3Url = url.match(/s3:\/\/([^/]+)\/(.*)$/);
+    if (!s3Url) {
+        return url;
+    }
+    // We need to pass an 'https://s3.REGION.amazonaws.com[.cn]/bucket/object' URL to CloudFormation, but we
+    // got an 's3://bucket/object' URL instead. Construct the rest API URL here.
+    const bucketName = s3Url[1];
+    const objectKey = s3Url[2];
+    // SDK v3 no longer allows for getting endpoints from only region.
+    // A command and client config must now be provided.
+    const s3 = new client_s3_1.S3Client({ region });
+    const endpoint = await (0, middleware_endpoint_1.getEndpointFromInstructions)({}, client_s3_1.HeadObjectCommand, {
+        ...s3.config,
+    });
+    endpoint.url.hostname;
+    return `${endpoint.url.origin}/${bucketName}/${objectKey}`;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"template-body-parameter.js","sourceRoot":"","sources":["template-body-parameter.ts"],"names":[],"mappings":"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","sourcesContent":["import * as fs from 'node:fs/promises';\nimport * as path from 'node:path';\nimport * as util from 'node:util';\nimport { type CloudFormationStackArtifact, type Environment, EnvironmentPlaceholders } from '@aws-cdk/cx-api';\nimport { HeadObjectCommand, S3Client } from '@aws-sdk/client-s3';\nimport { getEndpointFromInstructions } from '@smithy/middleware-endpoint';\nimport * as chalk from 'chalk';\nimport { contentHash, toYAML } from '../../util';\nimport type { AssetManifestBuilder } from '../deployments';\nimport type { EnvironmentResources } from '../environment';\nimport { IO, type IoHelper } from '../io/private';\nimport { ToolkitError } from '../toolkit-error';\n\nexport type TemplateBodyParameter = {\n  TemplateBody?: string;\n  TemplateURL?: string;\n};\n\nconst LARGE_TEMPLATE_SIZE_KB = 50;\n\n/**\n * Prepares the body parameter for +CreateChangeSet+.\n *\n * If the template is small enough to be inlined into the API call, just return\n * it immediately.\n *\n * Otherwise, add it to the asset manifest to get uploaded to the staging\n * bucket and return its coordinates. If there is no staging bucket, an error\n * is thrown.\n *\n * @param stack     the synthesized stack that provides the CloudFormation template\n * @param toolkitInfo information about the toolkit stack\n */\nexport async function makeBodyParameter(\n  ioHelper: IoHelper,\n  stack: CloudFormationStackArtifact,\n  resolvedEnvironment: Environment,\n  assetManifest: AssetManifestBuilder,\n  resources: EnvironmentResources,\n  overrideTemplate?: any,\n): Promise<TemplateBodyParameter> {\n  // If the template has already been uploaded to S3, just use it from there.\n  if (stack.stackTemplateAssetObjectUrl && !overrideTemplate) {\n    return {\n      TemplateURL: await restUrlFromManifest(stack.stackTemplateAssetObjectUrl, resolvedEnvironment),\n    };\n  }\n\n  // Otherwise, pass via API call (if small) or upload here (if large)\n  const templateJson = toYAML(overrideTemplate ?? stack.template);\n\n  if (templateJson.length <= LARGE_TEMPLATE_SIZE_KB * 1024) {\n    return { TemplateBody: templateJson };\n  }\n\n  const toolkitInfo = await resources.lookupToolkit();\n  if (!toolkitInfo.found) {\n    await ioHelper.notify(\n      IO.DEFAULT_TOOLKIT_ERROR.msg(util.format(\n        `The template for stack \"${stack.displayName}\" is ${Math.round(templateJson.length / 1024)}KiB. ` +\n        `Templates larger than ${LARGE_TEMPLATE_SIZE_KB}KiB must be uploaded to S3.\\n` +\n        'Run the following command in order to setup an S3 bucket in this environment, and then re-deploy:\\n\\n',\n        chalk.blue(`\\t$ cdk bootstrap ${resolvedEnvironment.name}\\n`),\n      )),\n    );\n\n    throw new ToolkitError('Template too large to deploy (\"cdk bootstrap\" is required)');\n  }\n\n  const templateHash = contentHash(templateJson);\n  const key = `cdk/${stack.id}/${templateHash}.yml`;\n\n  let templateFile = stack.templateFile;\n  if (overrideTemplate) {\n    // Add a variant of this template\n    templateFile = `${stack.templateFile}-${templateHash}.yaml`;\n    const templateFilePath = path.join(stack.assembly.directory, templateFile);\n    await fs.writeFile(templateFilePath, templateJson, { encoding: 'utf-8' });\n  }\n\n  assetManifest.addFileAsset(\n    templateHash,\n    {\n      path: templateFile,\n    },\n    {\n      bucketName: toolkitInfo.bucketName,\n      objectKey: key,\n    },\n  );\n\n  const templateURL = `${toolkitInfo.bucketUrl}/${key}`;\n  await ioHelper.notify(IO.DEFAULT_TOOLKIT_DEBUG.msg(`Storing template in S3 at: ${templateURL}`));\n  return { TemplateURL: templateURL };\n}\n\n/**\n * Format an S3 URL in the manifest for use with CloudFormation\n *\n * Replaces environment placeholders (which this field may contain),\n * and reformats s3://.../... urls into S3 REST URLs (which CloudFormation\n * expects)\n */\nasync function restUrlFromManifest(url: string, environment: Environment): Promise<string> {\n  const doNotUseMarker = '**DONOTUSE**';\n  const region = environment.region;\n  // This URL may contain placeholders, so still substitute those.\n  url = EnvironmentPlaceholders.replace(url, {\n    accountId: environment.account,\n    region,\n    partition: doNotUseMarker,\n  });\n\n  // Yes, this is extremely crude, but we don't actually need this so I'm not inclined to spend\n  // a lot of effort trying to thread the right value to this location.\n  if (url.indexOf(doNotUseMarker) > -1) {\n    throw new ToolkitError(\"Cannot use '${AWS::Partition}' in the 'stackTemplateAssetObjectUrl' field\");\n  }\n\n  const s3Url = url.match(/s3:\\/\\/([^/]+)\\/(.*)$/);\n  if (!s3Url) {\n    return url;\n  }\n\n  // We need to pass an 'https://s3.REGION.amazonaws.com[.cn]/bucket/object' URL to CloudFormation, but we\n  // got an 's3://bucket/object' URL instead. Construct the rest API URL here.\n  const bucketName = s3Url[1];\n  const objectKey = s3Url[2];\n\n  // SDK v3 no longer allows for getting endpoints from only region.\n  // A command and client config must now be provided.\n  const s3 = new S3Client({ region });\n  const endpoint = await getEndpointFromInstructions({}, HeadObjectCommand, {\n    ...s3.config,\n  });\n  endpoint.url.hostname;\n\n  return `${endpoint.url.origin}/${bucketName}/${objectKey}`;\n}\n"]}

package/lib/api/context.d.ts

@@ -0,0 +1,40 @@
+import { Settings } from './settings';
+export { TRANSIENT_CONTEXT_KEY } from './settings';
+export declare const PROJECT_CONTEXT = "cdk.context.json";
+interface ContextBag {
+    /**
+     * The file name of the context. Will be used to potentially
+     * save new context back to the original file.
+     */
+    fileName?: string;
+    /**
+     * The context values.
+     */
+    bag: Settings;
+}
+/**
+ * Class that supports overlaying property bags
+ *
+ * Reads come from the first property bag that can has the given key,
+ * writes go to the first property bag that is not readonly. A write
+ * will remove the value from all property bags after the first
+ * writable one.
+ */
+export declare class Context {
+    private readonly bags;
+    private readonly fileNames;
+    constructor(...bags: ContextBag[]);
+    get keys(): string[];
+    has(key: string): boolean;
+    get all(): {
+        [key: string]: any;
+    };
+    get(key: string): any;
+    set(key: string, value: any): void;
+    unset(key: string): void;
+    clear(): void;
+    /**
+     * Save a specific context file
+     */
+    save(fileName: string): Promise<this>;
+}