@aws-cdk/toolkit-lib 0.2.0 → 0.3.1

package/build-info.json

@@ -1,4 +1,4 @@
 {
-  "comment": "Generated at 2025-04-09T14:21:13Z by build-info.sh",
-  "commit": "4f3efd4"
+  "comment": "Generated at 2025-04-16T14:16:14Z by build-info.sh",
+  "commit": "6b421db"
 }

package/lib/actions/bootstrap/index.js

@@ -1,4 +1,56 @@
 "use strict";
+var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
+    if (value !== null && value !== void 0) {
+        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+        var dispose, inner;
+        if (async) {
+            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+            dispose = value[Symbol.asyncDispose];
+        }
+        if (dispose === void 0) {
+            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+            dispose = value[Symbol.dispose];
+            if (async) inner = dispose;
+        }
+        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
+        env.stack.push({ value: value, dispose: dispose, async: async });
+    }
+    else if (async) {
+        env.stack.push({ async: true });
+    }
+    return value;
+};
+var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
+    return function (env) {
+        function fail(e) {
+            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+            env.hasError = true;
+        }
+        var r, s = 0;
+        function next() {
+            while (r = env.stack.pop()) {
+                try {
+                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+                    if (r.dispose) {
+                        var result = r.dispose.call(r.value);
+                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
+                    }
+                    else s |= 1;
+                }
+                catch (e) {
+                    fail(e);
+                }
+            }
+            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+            if (env.hasError) throw env.error;
+        }
+        return next();
+    };
+})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+});
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BootstrapSource = exports.BootstrapStackParameters = exports.BootstrapEnvironments = void 0;
 const private_1 = require("./private");
@@ -22,10 +74,22 @@ class BootstrapEnvironments {
      */
     static fromCloudAssemblySource(cx) {
         return new BootstrapEnvironments(async (ioHost) => {
-            const ioHelper = (0, shared_private_1.asIoHelper)(ioHost, 'bootstrap');
-            const assembly = await (0, private_3.assemblyFromSource)(ioHelper, cx);
-            const stackCollection = await assembly.selectStacksV2(private_2.ALL_STACKS);
-            return stackCollection.stackArtifacts.map(stack => stack.environment);
+            const env_1 = { stack: [], error: void 0, hasError: false };
+            try {
+                const ioHelper = (0, shared_private_1.asIoHelper)(ioHost, 'bootstrap');
+                const assembly = __addDisposableResource(env_1, await (0, private_3.assemblyFromSource)(ioHelper, cx), true);
+                const stackCollection = await assembly.selectStacksV2(private_2.ALL_STACKS);
+                return stackCollection.stackArtifacts.map(stack => stack.environment);
+            }
+            catch (e_1) {
+                env_1.error = e_1;
+                env_1.hasError = true;
+            }
+            finally {
+                const result_1 = __disposeResources(env_1);
+                if (result_1)
+                    await result_1;
+            }
         });
     }
     constructor(envProvider) {
@@ -98,4 +162,4 @@ class BootstrapSource {
     }
 }
 exports.BootstrapSource = BootstrapSource;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["index.ts"],"names":[],"mappings":";;;AACA,uCAAwD;AAExD,8DAA8D;AAG9D,6DAAsD;AACtD,mDAA2D;AAE3D;;GAEG;AACH,MAAa,qBAAqB;IAqBK;IApBrC;;;OAGG;IACH,MAAM,CAAC,QAAQ,CAAC,YAAsB;QACpC,OAAO,IAAI,qBAAqB,CAAC,IAAA,qCAA2B,EAAC,YAAY,CAAC,CAAC,CAAC;IAC9E,CAAC;IAED;;OAEG;IACH,MAAM,CAAC,uBAAuB,CAAC,EAAwB;QACrD,OAAO,IAAI,qBAAqB,CAAC,KAAK,EAAE,MAAe,EAAE,EAAE;YACzD,MAAM,QAAQ,GAAG,IAAA,2BAAU,EAAC,MAAM,EAAE,WAAW,CAAC,CAAC;YACjD,MAAM,QAAQ,GAAG,MAAM,IAAA,4BAAkB,EAAC,QAAQ,EAAE,EAAE,CAAC,CAAC;YACxD,MAAM,eAAe,GAAG,MAAM,QAAQ,CAAC,cAAc,CAAC,oBAAU,CAAC,CAAC;YAClE,OAAO,eAAe,CAAC,cAAc,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE,CAAC,KAAK,CAAC,WAAW,CAAC,CAAC;QACxE,CAAC,CAAC,CAAC;IACL,CAAC;IAED,YAAqC,WAAsF;QAAtF,gBAAW,GAAX,WAAW,CAA2E;IAE3H,CAAC;IAED;;;;OAIG;IACH,KAAK,CAAC,eAAe,CAAC,MAAe;QACnC,IAAI,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,WAAW,CAAC,EAAE,CAAC;YACpC,OAAO,IAAI,CAAC,WAAW,CAAC;QAC1B,CAAC;QACD,OAAO,IAAI,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC;IAClC,CAAC;CACF;AApCD,sDAoCC;AA+ID;;GAEG;AACH,MAAa,wBAAwB;IACnC;;OAEG;IACI,MAAM,CAAC,YAAY;QACxB,OAAO,IAAI,wBAAwB,CAAC,EAAE,EAAE,IAAI,CAAC,CAAC;IAChD,CAAC;IAED;;OAEG;IACI,MAAM,CAAC,OAAO,CAAC,MAA2B;QAC/C,OAAO,IAAI,wBAAwB,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;IACrD,CAAC;IAED;;OAEG;IACI,MAAM,CAAC,YAAY,CAAC,MAA2B;QACpD,OAAO,IAAI,wBAAwB,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;IACpD,CAAC;IAED;;OAEG;IACa,UAAU,CAAuB;IACjC,sBAAsB,CAAU;IAEhD,YAAoB,MAA4B,EAAE,qBAAqB,GAAG,IAAI;QAC5E,IAAI,CAAC,sBAAsB,GAAG,qBAAqB,CAAC;QACpD,IAAI,CAAC,UAAU,GAAG,MAAM,CAAC;IAC3B,CAAC;CACF;AAhCD,4DAgCC;AAED;;GAEG;AACH,MAAa,eAAe;IAC1B;;OAEG;IACH,MAAM,CAAC,OAAO;QACZ,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,CAAC;IAC/B,CAAC;IAED;;OAEG;IACH,MAAM,CAAC,cAAc,CAAC,YAAoB;QACxC,OAAO;YACL,MAAM,EAAE,QAAQ;YAChB,YAAY;SACb,CAAC;IACJ,CAAC;CACF;AAjBD,0CAiBC","sourcesContent":["import type * as cxapi from '@aws-cdk/cx-api';\nimport { environmentsFromDescriptors } from './private';\nimport type { ICloudAssemblySource } from '../../api/cloud-assembly';\nimport { ALL_STACKS } from '../../api/cloud-assembly/private';\nimport type { IIoHost } from '../../api/io';\nimport type { Tag } from '../../api/shared-private';\nimport { asIoHelper } from '../../api/shared-private';\nimport { assemblyFromSource } from '../../toolkit/private';\n\n/**\n * Create manage bootstrap environments\n */\nexport class BootstrapEnvironments {\n  /**\n   * Create from a list of environment descriptors\n   * List of strings like `['aws://012345678912/us-east-1', 'aws://234567890123/eu-west-1']`\n   */\n  static fromList(environments: string[]): BootstrapEnvironments {\n    return new BootstrapEnvironments(environmentsFromDescriptors(environments));\n  }\n\n  /**\n   * Create from a cloud assembly source\n   */\n  static fromCloudAssemblySource(cx: ICloudAssemblySource): BootstrapEnvironments {\n    return new BootstrapEnvironments(async (ioHost: IIoHost) => {\n      const ioHelper = asIoHelper(ioHost, 'bootstrap');\n      const assembly = await assemblyFromSource(ioHelper, cx);\n      const stackCollection = await assembly.selectStacksV2(ALL_STACKS);\n      return stackCollection.stackArtifacts.map(stack => stack.environment);\n    });\n  }\n\n  private constructor(private readonly envProvider: cxapi.Environment[] | ((ioHost: IIoHost) => Promise<cxapi.Environment[]>)) {\n\n  }\n\n  /**\n   * Compute the bootstrap enviornments\n   *\n   * @internal\n   */\n  async getEnvironments(ioHost: IIoHost): Promise<cxapi.Environment[]> {\n    if (Array.isArray(this.envProvider)) {\n      return this.envProvider;\n    }\n    return this.envProvider(ioHost);\n  }\n}\n\n/**\n * Options for Bootstrap\n */\nexport interface BootstrapOptions {\n\n  /**\n   * Bootstrap environment parameters for CloudFormation used when deploying the bootstrap stack\n   * @default BootstrapEnvironmentParameters.onlyExisting()\n   */\n  readonly parameters?: BootstrapStackParameters;\n\n  /**\n   * The template source of the bootstrap stack\n   *\n   * @default BootstrapSource.default()\n   */\n  readonly source?: { source: 'default' } | { source: 'custom'; templateFile: string };\n\n  /**\n   * Whether to execute the changeset or only create it and leave it in review\n   * @default true\n   */\n  readonly execute?: boolean;\n\n  /**\n   * Tags for cdktoolkit stack\n   *\n   * @default []\n   */\n  readonly tags?: Tag[];\n\n  /**\n   * Whether the stacks created by the bootstrap process should be protected from termination\n   * @see https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-cfn-protect-stacks.html\n   * @default true\n   */\n  readonly terminationProtection?: boolean;\n}\n\n/**\n * Parameter values for the bootstrapping template\n */\nexport interface BootstrapParameters {\n  /**\n   * The name to be given to the CDK Bootstrap bucket\n   * By default, a name is generated by CloudFormation\n   *\n   * @default - No value, optional argument\n   */\n  readonly bucketName?: string;\n\n  /**\n   * The ID of an existing KMS key to be used for encrypting items in the bucket\n   * By default, the default KMS key is used\n   *\n   * @default - No value, optional argument\n   */\n  readonly kmsKeyId?: string;\n\n  /**\n   * Whether or not to create a new customer master key (CMK)\n   *\n   * Only applies to modern bootstrapping\n   * Legacy bootstrapping will never create a CMK, only use the default S3 key\n   *\n   * @default false\n   */\n  readonly createCustomerMasterKey?: boolean;\n\n  /**\n   * The list of AWS account IDs that are trusted to deploy into the environment being bootstrapped\n   *\n   * @default []\n   */\n  readonly trustedAccounts?: string[];\n\n  /**\n   * The list of AWS account IDs that are trusted to look up values in the environment being bootstrapped\n   *\n   * @default []\n   */\n  readonly trustedAccountsForLookup?: string[];\n\n  /**\n   * The list of AWS account IDs that should not be trusted by the bootstrapped environment\n   * If these accounts are already trusted, they will be removed on bootstrapping\n   *\n   * @default []\n   */\n  readonly untrustedAccounts?: string[];\n\n  /**\n   * The ARNs of the IAM managed policies that should be attached to the role performing CloudFormation deployments\n   * In most cases, this will be the AdministratorAccess policy\n   * At least one policy is required if `trustedAccounts` were passed\n   *\n   * @default []\n   */\n  readonly cloudFormationExecutionPolicies?: string[];\n\n  /**\n   * Identifier to distinguish multiple bootstrapped environments\n   * The default qualifier is an arbitrary but unique string\n   *\n   * @default - 'hnb659fds'\n   */\n  readonly qualifier?: string;\n\n  /**\n   * Whether or not to enable S3 Staging Bucket Public Access Block Configuration\n   *\n   * @default true\n   */\n  readonly publicAccessBlockConfiguration?: boolean;\n\n  /**\n   * Flag for using the default permissions boundary for bootstrapping\n   *\n   * @default - No value, optional argument\n   */\n  readonly examplePermissionsBoundary?: boolean;\n\n  /**\n   * Name for the customer's custom permissions boundary for bootstrapping\n   *\n   * @default - No value, optional argument\n   */\n  readonly customPermissionsBoundary?: string;\n}\n\nexport interface EnvironmentBootstrapResult {\n  environment: cxapi.Environment;\n  status: 'success' | 'no-op';\n  duration: number;\n}\n\nexport interface BootstrapResult {\n  environments: EnvironmentBootstrapResult[];\n  duration: number;\n}\n\n/**\n * Parameters of the bootstrapping template with flexible configuration options\n */\nexport class BootstrapStackParameters {\n  /**\n   * Use only existing parameters on the stack.\n   */\n  public static onlyExisting() {\n    return new BootstrapStackParameters({}, true);\n  }\n\n  /**\n   * Use exactly these parameters and remove any other existing parameters from the stack.\n   */\n  public static exactly(params: BootstrapParameters) {\n    return new BootstrapStackParameters(params, false);\n  }\n\n  /**\n   * Define additional parameters for the stack, while keeping existing parameters for unspecified values.\n   */\n  public static withExisting(params: BootstrapParameters) {\n    return new BootstrapStackParameters(params, true);\n  }\n\n  /**\n   * The parameters as a Map for easy access and manipulation\n   */\n  public readonly parameters?: BootstrapParameters;\n  public readonly keepExistingParameters: boolean;\n\n  private constructor(params?: BootstrapParameters, usePreviousParameters = true) {\n    this.keepExistingParameters = usePreviousParameters;\n    this.parameters = params;\n  }\n}\n\n/**\n * Source configuration for bootstrap operations\n */\nexport class BootstrapSource {\n  /**\n   * Use the default bootstrap template\n   */\n  static default(): BootstrapOptions['source'] {\n    return { source: 'default' };\n  }\n\n  /**\n   * Use a custom bootstrap template\n   */\n  static customTemplate(templateFile: string): BootstrapOptions['source'] {\n    return {\n      source: 'custom',\n      templateFile,\n    };\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AACA,uCAAwD;AAExD,8DAA8D;AAG9D,6DAAsD;AACtD,mDAA2D;AAE3D;;GAEG;AACH,MAAa,qBAAqB;IAqBK;IApBrC;;;OAGG;IACH,MAAM,CAAC,QAAQ,CAAC,YAAsB;QACpC,OAAO,IAAI,qBAAqB,CAAC,IAAA,qCAA2B,EAAC,YAAY,CAAC,CAAC,CAAC;IAC9E,CAAC;IAED;;OAEG;IACH,MAAM,CAAC,uBAAuB,CAAC,EAAwB;QACrD,OAAO,IAAI,qBAAqB,CAAC,KAAK,EAAE,MAAe,EAAE,EAAE;;;gBACzD,MAAM,QAAQ,GAAG,IAAA,2BAAU,EAAC,MAAM,EAAE,WAAW,CAAC,CAAC;gBACjD,MAAY,QAAQ,kCAAG,MAAM,IAAA,4BAAkB,EAAC,QAAQ,EAAE,EAAE,CAAC,OAAA,CAAC;gBAC9D,MAAM,eAAe,GAAG,MAAM,QAAQ,CAAC,cAAc,CAAC,oBAAU,CAAC,CAAC;gBAClE,OAAO,eAAe,CAAC,cAAc,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE,CAAC,KAAK,CAAC,WAAW,CAAC,CAAC;;;;;;;;;;;SACvE,CAAC,CAAC;IACL,CAAC;IAED,YAAqC,WAAsF;QAAtF,gBAAW,GAAX,WAAW,CAA2E;IAE3H,CAAC;IAED;;;;OAIG;IACH,KAAK,CAAC,eAAe,CAAC,MAAe;QACnC,IAAI,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,WAAW,CAAC,EAAE,CAAC;YACpC,OAAO,IAAI,CAAC,WAAW,CAAC;QAC1B,CAAC;QACD,OAAO,IAAI,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC;IAClC,CAAC;CACF;AApCD,sDAoCC;AA+ID;;GAEG;AACH,MAAa,wBAAwB;IACnC;;OAEG;IACI,MAAM,CAAC,YAAY;QACxB,OAAO,IAAI,wBAAwB,CAAC,EAAE,EAAE,IAAI,CAAC,CAAC;IAChD,CAAC;IAED;;OAEG;IACI,MAAM,CAAC,OAAO,CAAC,MAA2B;QAC/C,OAAO,IAAI,wBAAwB,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;IACrD,CAAC;IAED;;OAEG;IACI,MAAM,CAAC,YAAY,CAAC,MAA2B;QACpD,OAAO,IAAI,wBAAwB,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;IACpD,CAAC;IAED;;OAEG;IACa,UAAU,CAAuB;IACjC,sBAAsB,CAAU;IAEhD,YAAoB,MAA4B,EAAE,qBAAqB,GAAG,IAAI;QAC5E,IAAI,CAAC,sBAAsB,GAAG,qBAAqB,CAAC;QACpD,IAAI,CAAC,UAAU,GAAG,MAAM,CAAC;IAC3B,CAAC;CACF;AAhCD,4DAgCC;AAED;;GAEG;AACH,MAAa,eAAe;IAC1B;;OAEG;IACH,MAAM,CAAC,OAAO;QACZ,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,CAAC;IAC/B,CAAC;IAED;;OAEG;IACH,MAAM,CAAC,cAAc,CAAC,YAAoB;QACxC,OAAO;YACL,MAAM,EAAE,QAAQ;YAChB,YAAY;SACb,CAAC;IACJ,CAAC;CACF;AAjBD,0CAiBC","sourcesContent":["import type * as cxapi from '@aws-cdk/cx-api';\nimport { environmentsFromDescriptors } from './private';\nimport type { ICloudAssemblySource } from '../../api/cloud-assembly';\nimport { ALL_STACKS } from '../../api/cloud-assembly/private';\nimport type { IIoHost } from '../../api/io';\nimport type { Tag } from '../../api/shared-private';\nimport { asIoHelper } from '../../api/shared-private';\nimport { assemblyFromSource } from '../../toolkit/private';\n\n/**\n * Create manage bootstrap environments\n */\nexport class BootstrapEnvironments {\n  /**\n   * Create from a list of environment descriptors\n   * List of strings like `['aws://012345678912/us-east-1', 'aws://234567890123/eu-west-1']`\n   */\n  static fromList(environments: string[]): BootstrapEnvironments {\n    return new BootstrapEnvironments(environmentsFromDescriptors(environments));\n  }\n\n  /**\n   * Create from a cloud assembly source\n   */\n  static fromCloudAssemblySource(cx: ICloudAssemblySource): BootstrapEnvironments {\n    return new BootstrapEnvironments(async (ioHost: IIoHost) => {\n      const ioHelper = asIoHelper(ioHost, 'bootstrap');\n      await using assembly = await assemblyFromSource(ioHelper, cx);\n      const stackCollection = await assembly.selectStacksV2(ALL_STACKS);\n      return stackCollection.stackArtifacts.map(stack => stack.environment);\n    });\n  }\n\n  private constructor(private readonly envProvider: cxapi.Environment[] | ((ioHost: IIoHost) => Promise<cxapi.Environment[]>)) {\n\n  }\n\n  /**\n   * Compute the bootstrap enviornments\n   *\n   * @internal\n   */\n  async getEnvironments(ioHost: IIoHost): Promise<cxapi.Environment[]> {\n    if (Array.isArray(this.envProvider)) {\n      return this.envProvider;\n    }\n    return this.envProvider(ioHost);\n  }\n}\n\n/**\n * Options for Bootstrap\n */\nexport interface BootstrapOptions {\n\n  /**\n   * Bootstrap environment parameters for CloudFormation used when deploying the bootstrap stack\n   * @default BootstrapEnvironmentParameters.onlyExisting()\n   */\n  readonly parameters?: BootstrapStackParameters;\n\n  /**\n   * The template source of the bootstrap stack\n   *\n   * @default BootstrapSource.default()\n   */\n  readonly source?: { source: 'default' } | { source: 'custom'; templateFile: string };\n\n  /**\n   * Whether to execute the changeset or only create it and leave it in review\n   * @default true\n   */\n  readonly execute?: boolean;\n\n  /**\n   * Tags for cdktoolkit stack\n   *\n   * @default []\n   */\n  readonly tags?: Tag[];\n\n  /**\n   * Whether the stacks created by the bootstrap process should be protected from termination\n   * @see https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-cfn-protect-stacks.html\n   * @default true\n   */\n  readonly terminationProtection?: boolean;\n}\n\n/**\n * Parameter values for the bootstrapping template\n */\nexport interface BootstrapParameters {\n  /**\n   * The name to be given to the CDK Bootstrap bucket\n   * By default, a name is generated by CloudFormation\n   *\n   * @default - No value, optional argument\n   */\n  readonly bucketName?: string;\n\n  /**\n   * The ID of an existing KMS key to be used for encrypting items in the bucket\n   * By default, the default KMS key is used\n   *\n   * @default - No value, optional argument\n   */\n  readonly kmsKeyId?: string;\n\n  /**\n   * Whether or not to create a new customer master key (CMK)\n   *\n   * Only applies to modern bootstrapping\n   * Legacy bootstrapping will never create a CMK, only use the default S3 key\n   *\n   * @default false\n   */\n  readonly createCustomerMasterKey?: boolean;\n\n  /**\n   * The list of AWS account IDs that are trusted to deploy into the environment being bootstrapped\n   *\n   * @default []\n   */\n  readonly trustedAccounts?: string[];\n\n  /**\n   * The list of AWS account IDs that are trusted to look up values in the environment being bootstrapped\n   *\n   * @default []\n   */\n  readonly trustedAccountsForLookup?: string[];\n\n  /**\n   * The list of AWS account IDs that should not be trusted by the bootstrapped environment\n   * If these accounts are already trusted, they will be removed on bootstrapping\n   *\n   * @default []\n   */\n  readonly untrustedAccounts?: string[];\n\n  /**\n   * The ARNs of the IAM managed policies that should be attached to the role performing CloudFormation deployments\n   * In most cases, this will be the AdministratorAccess policy\n   * At least one policy is required if `trustedAccounts` were passed\n   *\n   * @default []\n   */\n  readonly cloudFormationExecutionPolicies?: string[];\n\n  /**\n   * Identifier to distinguish multiple bootstrapped environments\n   * The default qualifier is an arbitrary but unique string\n   *\n   * @default - 'hnb659fds'\n   */\n  readonly qualifier?: string;\n\n  /**\n   * Whether or not to enable S3 Staging Bucket Public Access Block Configuration\n   *\n   * @default true\n   */\n  readonly publicAccessBlockConfiguration?: boolean;\n\n  /**\n   * Flag for using the default permissions boundary for bootstrapping\n   *\n   * @default - No value, optional argument\n   */\n  readonly examplePermissionsBoundary?: boolean;\n\n  /**\n   * Name for the customer's custom permissions boundary for bootstrapping\n   *\n   * @default - No value, optional argument\n   */\n  readonly customPermissionsBoundary?: string;\n}\n\nexport interface EnvironmentBootstrapResult {\n  environment: cxapi.Environment;\n  status: 'success' | 'no-op';\n  duration: number;\n}\n\nexport interface BootstrapResult {\n  environments: EnvironmentBootstrapResult[];\n  duration: number;\n}\n\n/**\n * Parameters of the bootstrapping template with flexible configuration options\n */\nexport class BootstrapStackParameters {\n  /**\n   * Use only existing parameters on the stack.\n   */\n  public static onlyExisting() {\n    return new BootstrapStackParameters({}, true);\n  }\n\n  /**\n   * Use exactly these parameters and remove any other existing parameters from the stack.\n   */\n  public static exactly(params: BootstrapParameters) {\n    return new BootstrapStackParameters(params, false);\n  }\n\n  /**\n   * Define additional parameters for the stack, while keeping existing parameters for unspecified values.\n   */\n  public static withExisting(params: BootstrapParameters) {\n    return new BootstrapStackParameters(params, true);\n  }\n\n  /**\n   * The parameters as a Map for easy access and manipulation\n   */\n  public readonly parameters?: BootstrapParameters;\n  public readonly keepExistingParameters: boolean;\n\n  private constructor(params?: BootstrapParameters, usePreviousParameters = true) {\n    this.keepExistingParameters = usePreviousParameters;\n    this.parameters = params;\n  }\n}\n\n/**\n * Source configuration for bootstrap operations\n */\nexport class BootstrapSource {\n  /**\n   * Use the default bootstrap template\n   */\n  static default(): BootstrapOptions['source'] {\n    return { source: 'default' };\n  }\n\n  /**\n   * Use a custom bootstrap template\n   */\n  static customTemplate(templateFile: string): BootstrapOptions['source'] {\n    return {\n      source: 'custom',\n      templateFile,\n    };\n  }\n}\n"]}

package/lib/actions/diff/index.d.ts

@@ -9,6 +9,14 @@ export interface CloudFormationDiffOptions {
     readonly compareAgainstProcessedTemplate?: boolean;
 }
 export interface ChangeSetDiffOptions extends CloudFormationDiffOptions {
+    /**
+     * Enable falling back to template-based diff in case creating the changeset is not possible or results in an error.
+     *
+     * Should be used for stacks containing nested stacks or when change set permissions aren't available.
+     *
+     * @default true
+     */
+    readonly fallbackToTemplate?: boolean;
     /**
      * Additional parameters for CloudFormation when creating a diff change set
      *

package/lib/actions/diff/index.js

@@ -45,4 +45,4 @@ class DiffMethod {
     }
 }
 exports.DiffMethod = DiffMethod;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/actions/diff/private/helpers.d.ts

@@ -8,3 +8,19 @@ export declare function makeTemplateInfos(ioHelper: IoHelper, stacks: StackColle
  * Return whether the diff has security-impacting changes that need confirmation.
  */
 export declare function determinePermissionType(oldTemplate: any, newTemplate: cxapi.CloudFormationStackArtifact, changeSet?: DescribeChangeSetOutput): PermissionChangeType;
+/**
+ * Appends all properties from obj2 to obj1.
+ * obj2 values take priority in the case of collisions.
+ *
+ * @param obj1 The object to modify
+ * @param obj2 The object to consume
+ *
+ * @returns obj1 with all properties from obj2
+ */
+export declare function appendObject<T>(obj1: {
+    [name: string]: T;
+}, obj2: {
+    [name: string]: T;
+}): {
+    [name: string]: T;
+};

package/lib/actions/diff/private/helpers.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.makeTemplateInfos = makeTemplateInfos;
 exports.determinePermissionType = determinePermissionType;
+exports.appendObject = appendObject;
 const cloudformation_diff_1 = require("@aws-cdk/cloudformation-diff");
 const fs = require("fs-extra");
 const uuid = require("uuid");
@@ -37,7 +38,7 @@ async function localFileDiff(stacks, options) {
             newTemplate: stacks.firstStack,
         }];
 }
-async function cfnDiff(ioHelper, stacks, deployments, options, sdkProvider, changeSet) {
+async function cfnDiff(ioHelper, stacks, deployments, options, sdkProvider, includeChangeSet) {
     const templateInfos = [];
     const methodOptions = (options.method?.options ?? {});
     // Compare N stacks against deployed templates
@@ -50,18 +51,18 @@ async function cfnDiff(ioHelper, stacks, deployments, options, sdkProvider, chan
         if (resourcesToImport) {
             (0, shared_private_1.removeNonImportResources)(stack);
         }
+        const changeSet = includeChangeSet ? await changeSetDiff(ioHelper, deployments, stack, sdkProvider, resourcesToImport, methodOptions.parameters, methodOptions.fallbackToTemplate) : undefined;
         templateInfos.push({
             oldTemplate: currentTemplate,
             newTemplate: stack,
-            stackName: stack.stackName,
             isImport: !!resourcesToImport,
             nestedStacks,
-            changeSet: changeSet ? await changeSetDiff(ioHelper, deployments, stack, sdkProvider, resourcesToImport, methodOptions.parameters) : undefined,
+            changeSet,
         });
     }
     return templateInfos;
 }
-async function changeSetDiff(ioHelper, deployments, stack, sdkProvider, resourcesToImport, parameters = {}) {
+async function changeSetDiff(ioHelper, deployments, stack, sdkProvider, resourcesToImport, parameters = {}, fallBackToTemplate = true) {
     let stackExists = false;
     try {
         stackExists = await deployments.stackExists({
@@ -71,6 +72,9 @@ async function changeSetDiff(ioHelper, deployments, stack, sdkProvider, resource
         });
     }
     catch (e) {
+        if (!fallBackToTemplate) {
+            throw new shared_public_1.ToolkitError(`describeStacks call failed with ${e} for ${stack.stackName}, set fallBackToTemplate to true or use DiffMethod.templateOnly to base the diff on template differences.`);
+        }
         await ioHelper.notify(shared_private_1.IO.DEFAULT_TOOLKIT_DEBUG.msg(`Checking if the stack ${stack.stackName} exists before creating the changeset has failed, will base the diff on template differences.\n`));
         await ioHelper.notify(shared_private_1.IO.DEFAULT_TOOLKIT_DEBUG.msg((0, util_1.formatErrorMessage)(e)));
         stackExists = false;
@@ -84,10 +88,14 @@ async function changeSetDiff(ioHelper, deployments, stack, sdkProvider, resource
             sdkProvider,
             parameters: parameters,
             resourcesToImport,
+            failOnError: !fallBackToTemplate,
         });
     }
     else {
-        await ioHelper.notify(shared_private_1.IO.DEFAULT_TOOLKIT_DEBUG.msg(`the stack '${stack.stackName}' has not been deployed to CloudFormation or describeStacks call failed, skipping changeset creation.`));
+        if (!fallBackToTemplate) {
+            throw new shared_public_1.ToolkitError(`the stack '${stack.stackName}' has not been deployed to CloudFormation, set fallBackToTemplate to true or use DiffMethod.templateOnly to base the diff on template differences.`);
+        }
+        await ioHelper.notify(shared_private_1.IO.DEFAULT_TOOLKIT_DEBUG.msg(`the stack '${stack.stackName}' has not been deployed to CloudFormation, skipping changeset creation.`));
         return;
     }
 }
@@ -107,4 +115,21 @@ function determinePermissionType(oldTemplate, newTemplate, changeSet) {
         return shared_public_1.PermissionChangeType.NONE;
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"helpers.js","sourceRoot":"","sources":["helpers.ts"],"names":[],"mappings":"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","sourcesContent":["import type { DescribeChangeSetOutput } from '@aws-cdk/cloudformation-diff';\nimport { fullDiff } from '@aws-cdk/cloudformation-diff';\nimport type * as cxapi from '@aws-cdk/cx-api';\nimport * as fs from 'fs-extra';\nimport * as uuid from 'uuid';\nimport type { ChangeSetDiffOptions, DiffOptions, LocalFileDiffOptions } from '..';\nimport { DiffMethod } from '..';\nimport type { Deployments, ResourcesToImport, IoHelper, SdkProvider, StackCollection, TemplateInfo } from '../../../api/shared-private';\nimport { ResourceMigrator, IO, removeNonImportResources, cfnApi } from '../../../api/shared-private';\nimport { PermissionChangeType, ToolkitError } from '../../../api/shared-public';\nimport { deserializeStructure, formatErrorMessage } from '../../../private/util';\n\nexport function makeTemplateInfos(\n  ioHelper: IoHelper,\n  stacks: StackCollection,\n  deployments: Deployments,\n  sdkProvider: SdkProvider,\n  options: DiffOptions,\n): Promise<TemplateInfo[]> {\n  switch (options.method?.method ?? DiffMethod.ChangeSet().method) {\n    case 'local-file':\n      return localFileDiff(stacks, options);\n    case 'template-only':\n      return cfnDiff(ioHelper, stacks, deployments, options, sdkProvider, false);\n    case 'change-set':\n      return cfnDiff(ioHelper, stacks, deployments, options, sdkProvider, true);\n    default:\n      throw new ToolkitError(formatErrorMessage(`Unknown diff method ${options.method}`));\n  }\n}\n\nasync function localFileDiff(stacks: StackCollection, options: DiffOptions): Promise<TemplateInfo[]> {\n  const methodOptions = (options.method?.options ?? {}) as LocalFileDiffOptions;\n\n  // Compare single stack against fixed template\n  if (stacks.stackCount !== 1) {\n    throw new ToolkitError(\n      'Can only select one stack when comparing to fixed template. Use --exclusively to avoid selecting multiple stacks.',\n    );\n  }\n\n  if (!(await fs.pathExists(methodOptions.path))) {\n    throw new ToolkitError(`There is no file at ${methodOptions.path}`);\n  }\n\n  const file = fs.readFileSync(methodOptions.path).toString();\n  const template = deserializeStructure(file);\n\n  return [{\n    oldTemplate: template,\n    newTemplate: stacks.firstStack,\n  }];\n}\n\nasync function cfnDiff(\n  ioHelper: IoHelper,\n  stacks: StackCollection,\n  deployments: Deployments,\n  options: DiffOptions,\n  sdkProvider: SdkProvider,\n  changeSet: boolean,\n): Promise<TemplateInfo[]> {\n  const templateInfos = [];\n  const methodOptions = (options.method?.options ?? {}) as ChangeSetDiffOptions;\n\n  // Compare N stacks against deployed templates\n  for (const stack of stacks.stackArtifacts) {\n    const templateWithNestedStacks = await deployments.readCurrentTemplateWithNestedStacks(\n      stack,\n      methodOptions.compareAgainstProcessedTemplate,\n    );\n    const currentTemplate = templateWithNestedStacks.deployedRootTemplate;\n    const nestedStacks = templateWithNestedStacks.nestedStacks;\n\n    const migrator = new ResourceMigrator({ deployments, ioHelper });\n    const resourcesToImport = await migrator.tryGetResources(await deployments.resolveEnvironment(stack));\n    if (resourcesToImport) {\n      removeNonImportResources(stack);\n    }\n\n    templateInfos.push({\n      oldTemplate: currentTemplate,\n      newTemplate: stack,\n      stackName: stack.stackName,\n      isImport: !!resourcesToImport,\n      nestedStacks,\n      changeSet: changeSet ? await changeSetDiff(ioHelper, deployments, stack, sdkProvider, resourcesToImport, methodOptions.parameters) : undefined,\n    });\n  }\n\n  return templateInfos;\n}\n\nasync function changeSetDiff(\n  ioHelper: IoHelper,\n  deployments: Deployments,\n  stack: cxapi.CloudFormationStackArtifact,\n  sdkProvider: SdkProvider,\n  resourcesToImport?: ResourcesToImport,\n  parameters: { [name: string]: string | undefined } = {},\n): Promise<any | undefined> {\n  let stackExists = false;\n  try {\n    stackExists = await deployments.stackExists({\n      stack,\n      deployName: stack.stackName,\n      tryLookupRole: true,\n    });\n  } catch (e: any) {\n    await ioHelper.notify(IO.DEFAULT_TOOLKIT_DEBUG.msg(`Checking if the stack ${stack.stackName} exists before creating the changeset has failed, will base the diff on template differences.\\n`));\n    await ioHelper.notify(IO.DEFAULT_TOOLKIT_DEBUG.msg(formatErrorMessage(e)));\n    stackExists = false;\n  }\n\n  if (stackExists) {\n    return cfnApi.createDiffChangeSet(ioHelper, {\n      stack,\n      uuid: uuid.v4(),\n      deployments,\n      willExecute: false,\n      sdkProvider,\n      parameters: parameters,\n      resourcesToImport,\n    });\n  } else {\n    await ioHelper.notify(IO.DEFAULT_TOOLKIT_DEBUG.msg(`the stack '${stack.stackName}' has not been deployed to CloudFormation or describeStacks call failed, skipping changeset creation.`));\n    return;\n  }\n}\n\n/**\n * Return whether the diff has security-impacting changes that need confirmation.\n */\nexport function determinePermissionType(\n  oldTemplate: any,\n  newTemplate: cxapi.CloudFormationStackArtifact,\n  changeSet?: DescribeChangeSetOutput,\n): PermissionChangeType {\n  // @todo return a printable version of the full diff.\n  const diff = fullDiff(oldTemplate, newTemplate.template, changeSet);\n\n  if (diff.permissionsBroadened) {\n    return PermissionChangeType.BROADENING;\n  } else if (diff.permissionsAnyChanges) {\n    return PermissionChangeType.NON_BROADENING;\n  } else {\n    return PermissionChangeType.NONE;\n  }\n}\n"]}
+/**
+ * Appends all properties from obj2 to obj1.
+ * obj2 values take priority in the case of collisions.
+ *
+ * @param obj1 The object to modify
+ * @param obj2 The object to consume
+ *
+ * @returns obj1 with all properties from obj2
+ */
+function appendObject(obj1, obj2) {
+    // Directly modify obj1 by adding all properties from obj2
+    for (const key in obj2) {
+        obj1[key] = obj2[key];
+    }
+    // Return the modified obj1
+    return obj1;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"helpers.js","sourceRoot":"","sources":["helpers.ts"],"names":[],"mappings":"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","sourcesContent":["import type { DescribeChangeSetOutput } from '@aws-cdk/cloudformation-diff';\nimport { fullDiff } from '@aws-cdk/cloudformation-diff';\nimport type * as cxapi from '@aws-cdk/cx-api';\nimport * as fs from 'fs-extra';\nimport * as uuid from 'uuid';\nimport type { ChangeSetDiffOptions, DiffOptions, LocalFileDiffOptions } from '..';\nimport { DiffMethod } from '..';\nimport type { Deployments, ResourcesToImport, IoHelper, SdkProvider, StackCollection, TemplateInfo } from '../../../api/shared-private';\nimport { ResourceMigrator, IO, removeNonImportResources, cfnApi } from '../../../api/shared-private';\nimport { PermissionChangeType, ToolkitError } from '../../../api/shared-public';\nimport { deserializeStructure, formatErrorMessage } from '../../../private/util';\n\nexport function makeTemplateInfos(\n  ioHelper: IoHelper,\n  stacks: StackCollection,\n  deployments: Deployments,\n  sdkProvider: SdkProvider,\n  options: DiffOptions,\n): Promise<TemplateInfo[]> {\n  switch (options.method?.method ?? DiffMethod.ChangeSet().method) {\n    case 'local-file':\n      return localFileDiff(stacks, options);\n    case 'template-only':\n      return cfnDiff(ioHelper, stacks, deployments, options, sdkProvider, false);\n    case 'change-set':\n      return cfnDiff(ioHelper, stacks, deployments, options, sdkProvider, true);\n    default:\n      throw new ToolkitError(formatErrorMessage(`Unknown diff method ${options.method}`));\n  }\n}\n\nasync function localFileDiff(stacks: StackCollection, options: DiffOptions): Promise<TemplateInfo[]> {\n  const methodOptions = (options.method?.options ?? {}) as LocalFileDiffOptions;\n\n  // Compare single stack against fixed template\n  if (stacks.stackCount !== 1) {\n    throw new ToolkitError(\n      'Can only select one stack when comparing to fixed template. Use --exclusively to avoid selecting multiple stacks.',\n    );\n  }\n\n  if (!(await fs.pathExists(methodOptions.path))) {\n    throw new ToolkitError(`There is no file at ${methodOptions.path}`);\n  }\n\n  const file = fs.readFileSync(methodOptions.path).toString();\n  const template = deserializeStructure(file);\n\n  return [{\n    oldTemplate: template,\n    newTemplate: stacks.firstStack,\n  }];\n}\n\nasync function cfnDiff(\n  ioHelper: IoHelper,\n  stacks: StackCollection,\n  deployments: Deployments,\n  options: DiffOptions,\n  sdkProvider: SdkProvider,\n  includeChangeSet: boolean,\n): Promise<TemplateInfo[]> {\n  const templateInfos = [];\n  const methodOptions = (options.method?.options ?? {}) as ChangeSetDiffOptions;\n\n  // Compare N stacks against deployed templates\n  for (const stack of stacks.stackArtifacts) {\n    const templateWithNestedStacks = await deployments.readCurrentTemplateWithNestedStacks(\n      stack,\n      methodOptions.compareAgainstProcessedTemplate,\n    );\n    const currentTemplate = templateWithNestedStacks.deployedRootTemplate;\n    const nestedStacks = templateWithNestedStacks.nestedStacks;\n\n    const migrator = new ResourceMigrator({ deployments, ioHelper });\n    const resourcesToImport = await migrator.tryGetResources(await deployments.resolveEnvironment(stack));\n    if (resourcesToImport) {\n      removeNonImportResources(stack);\n    }\n\n    const changeSet = includeChangeSet ? await changeSetDiff(\n      ioHelper,\n      deployments,\n      stack,\n      sdkProvider,\n      resourcesToImport,\n      methodOptions.parameters,\n      methodOptions.fallbackToTemplate,\n    ) : undefined;\n\n    templateInfos.push({\n      oldTemplate: currentTemplate,\n      newTemplate: stack,\n      isImport: !!resourcesToImport,\n      nestedStacks,\n      changeSet,\n    });\n  }\n\n  return templateInfos;\n}\n\nasync function changeSetDiff(\n  ioHelper: IoHelper,\n  deployments: Deployments,\n  stack: cxapi.CloudFormationStackArtifact,\n  sdkProvider: SdkProvider,\n  resourcesToImport?: ResourcesToImport,\n  parameters: { [name: string]: string | undefined } = {},\n  fallBackToTemplate: boolean = true,\n): Promise<any | undefined> {\n  let stackExists = false;\n  try {\n    stackExists = await deployments.stackExists({\n      stack,\n      deployName: stack.stackName,\n      tryLookupRole: true,\n    });\n  } catch (e: any) {\n    if (!fallBackToTemplate) {\n      throw new ToolkitError(`describeStacks call failed with ${e} for ${stack.stackName}, set fallBackToTemplate to true or use DiffMethod.templateOnly to base the diff on template differences.`);\n    }\n\n    await ioHelper.notify(IO.DEFAULT_TOOLKIT_DEBUG.msg(`Checking if the stack ${stack.stackName} exists before creating the changeset has failed, will base the diff on template differences.\\n`));\n    await ioHelper.notify(IO.DEFAULT_TOOLKIT_DEBUG.msg(formatErrorMessage(e)));\n    stackExists = false;\n  }\n\n  if (stackExists) {\n    return cfnApi.createDiffChangeSet(ioHelper, {\n      stack,\n      uuid: uuid.v4(),\n      deployments,\n      willExecute: false,\n      sdkProvider,\n      parameters: parameters,\n      resourcesToImport,\n      failOnError: !fallBackToTemplate,\n    });\n  } else {\n    if (!fallBackToTemplate) {\n      throw new ToolkitError(`the stack '${stack.stackName}' has not been deployed to CloudFormation, set fallBackToTemplate to true or use DiffMethod.templateOnly to base the diff on template differences.`);\n    }\n\n    await ioHelper.notify(IO.DEFAULT_TOOLKIT_DEBUG.msg(`the stack '${stack.stackName}' has not been deployed to CloudFormation, skipping changeset creation.`));\n    return;\n  }\n}\n\n/**\n * Return whether the diff has security-impacting changes that need confirmation.\n */\nexport function determinePermissionType(\n  oldTemplate: any,\n  newTemplate: cxapi.CloudFormationStackArtifact,\n  changeSet?: DescribeChangeSetOutput,\n): PermissionChangeType {\n  // @todo return a printable version of the full diff.\n  const diff = fullDiff(oldTemplate, newTemplate.template, changeSet);\n\n  if (diff.permissionsBroadened) {\n    return PermissionChangeType.BROADENING;\n  } else if (diff.permissionsAnyChanges) {\n    return PermissionChangeType.NON_BROADENING;\n  } else {\n    return PermissionChangeType.NONE;\n  }\n}\n\n/**\n * Appends all properties from obj2 to obj1.\n * obj2 values take priority in the case of collisions.\n *\n * @param obj1 The object to modify\n * @param obj2 The object to consume\n *\n * @returns obj1 with all properties from obj2\n */\nexport function appendObject<T>(\n  obj1: { [name: string]: T },\n  obj2: { [name: string]: T },\n): { [name: string]: T } {\n  // Directly modify obj1 by adding all properties from obj2\n  for (const key in obj2) {\n    obj1[key] = obj2[key];\n  }\n\n  // Return the modified obj1\n  return obj1;\n}\n"]}

package/lib/actions/index.d.ts

@@ -3,6 +3,7 @@ export * from './deploy';
 export * from './destroy';
 export * from './diff';
 export * from './list';
+export * from './refactor';
 export * from './rollback';
 export * from './synth';
 export * from './watch';

package/lib/actions/index.js

@@ -19,7 +19,8 @@ __exportStar(require("./deploy"), exports);
 __exportStar(require("./destroy"), exports);
 __exportStar(require("./diff"), exports);
 __exportStar(require("./list"), exports);
+__exportStar(require("./refactor"), exports);
 __exportStar(require("./rollback"), exports);
 __exportStar(require("./synth"), exports);
 __exportStar(require("./watch"), exports);
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJpbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7O0FBQUEsOENBQTRCO0FBQzVCLDJDQUF5QjtBQUN6Qiw0Q0FBMEI7QUFDMUIseUNBQXVCO0FBQ3ZCLHlDQUF1QjtBQUN2Qiw2Q0FBMkI7QUFDM0IsMENBQXdCO0FBQ3hCLDBDQUF3QiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vYm9vdHN0cmFwJztcbmV4cG9ydCAqIGZyb20gJy4vZGVwbG95JztcbmV4cG9ydCAqIGZyb20gJy4vZGVzdHJveSc7XG5leHBvcnQgKiBmcm9tICcuL2RpZmYnO1xuZXhwb3J0ICogZnJvbSAnLi9saXN0JztcbmV4cG9ydCAqIGZyb20gJy4vcm9sbGJhY2snO1xuZXhwb3J0ICogZnJvbSAnLi9zeW50aCc7XG5leHBvcnQgKiBmcm9tICcuL3dhdGNoJztcbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJpbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7O0FBQUEsOENBQTRCO0FBQzVCLDJDQUF5QjtBQUN6Qiw0Q0FBMEI7QUFDMUIseUNBQXVCO0FBQ3ZCLHlDQUF1QjtBQUN2Qiw2Q0FBMkI7QUFDM0IsNkNBQTJCO0FBQzNCLDBDQUF3QjtBQUN4QiwwQ0FBd0IiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2Jvb3RzdHJhcCc7XG5leHBvcnQgKiBmcm9tICcuL2RlcGxveSc7XG5leHBvcnQgKiBmcm9tICcuL2Rlc3Ryb3knO1xuZXhwb3J0ICogZnJvbSAnLi9kaWZmJztcbmV4cG9ydCAqIGZyb20gJy4vbGlzdCc7XG5leHBvcnQgKiBmcm9tICcuL3JlZmFjdG9yJztcbmV4cG9ydCAqIGZyb20gJy4vcm9sbGJhY2snO1xuZXhwb3J0ICogZnJvbSAnLi9zeW50aCc7XG5leHBvcnQgKiBmcm9tICcuL3dhdGNoJztcbiJdfQ==

package/lib/actions/refactor/index.d.ts

@@ -0,0 +1,15 @@
+import type { StackSelector } from '../../api/cloud-assembly';
+export interface RefactorOptions {
+    /**
+     * Whether to only show the proposed refactor, without applying it
+     *
+     * @default false
+     */
+    readonly dryRun?: boolean;
+    /**
+     * Criteria for selecting stacks to deploy
+     *
+     * @default - all stacks
+     */
+    stacks?: StackSelector;
+}

package/lib/actions/refactor/index.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJpbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHR5cGUgeyBTdGFja1NlbGVjdG9yIH0gZnJvbSAnLi4vLi4vYXBpL2Nsb3VkLWFzc2VtYmx5JztcblxuZXhwb3J0IGludGVyZmFjZSBSZWZhY3Rvck9wdGlvbnMge1xuICAvKipcbiAgICogV2hldGhlciB0byBvbmx5IHNob3cgdGhlIHByb3Bvc2VkIHJlZmFjdG9yLCB3aXRob3V0IGFwcGx5aW5nIGl0XG4gICAqXG4gICAqIEBkZWZhdWx0IGZhbHNlXG4gICAqL1xuICByZWFkb25seSBkcnlSdW4/OiBib29sZWFuO1xuXG4gIC8qKlxuICAgKiBDcml0ZXJpYSBmb3Igc2VsZWN0aW5nIHN0YWNrcyB0byBkZXBsb3lcbiAgICpcbiAgICogQGRlZmF1bHQgLSBhbGwgc3RhY2tzXG4gICAqL1xuICBzdGFja3M/OiBTdGFja1NlbGVjdG9yO1xufVxuIl19

package/lib/api/cloud-assembly/cached-source.d.ts

@@ -0,0 +1,37 @@
+import '../../private/dispose-polyfill';
+import type * as cxapi from '@aws-cdk/cx-api';
+import type { ICloudAssemblySource, IReadableCloudAssembly } from './types';
+/**
+ * A CloudAssemblySource that is caching its result once produced.
+ *
+ * Most Toolkit interactions should use a cached source. Not caching is
+ * relevant when the source changes frequently and it is to expensive to predict
+ * if the source has changed.
+ *
+ * The `CachedCloudAssembly` is both itself a readable CloudAssembly, as well as
+ * a Cloud Assembly Source. The lifetimes of cloud assemblies produced by this
+ * source are coupled to the lifetime of the `CachedCloudAssembly`. In other
+ * words: the `dispose()` functions of those cloud assemblies don't do anything;
+ * only the `dispose()` function of the `CachedCloudAssembly` will be used.
+ *
+ * NOTE: if we are concerned about borrowed assemblies outliving the parent
+ * (i.e. the parent getting disposed while someone is still working with the
+ * borrowed copies), we could consider referencing counting here. That seems
+ * unnecessarily complicated for now, we will just assume that everyone is
+ * being a good citizen an borrowed copies are only used by the toolkit and
+ * immediately disposed of.
+ *
+ * Because `dispose()` is a no-op on the borrowed assembly, you can omit it
+ * without changing behavior, but that would turn into a leak if we ever introduced
+ * reference counting. Failing to dispose the result if a `produce()` call of a
+ * `CachedCloudAssembly` is considered a bug.
+ */
+export declare class CachedCloudAssembly implements ICloudAssemblySource, IReadableCloudAssembly {
+    private asm;
+    constructor(asm: IReadableCloudAssembly);
+    get cloudAssembly(): cxapi.CloudAssembly;
+    produce(): Promise<IReadableCloudAssembly>;
+    _unlock(): Promise<void>;
+    dispose(): Promise<void>;
+    [Symbol.asyncDispose](): Promise<void>;
+}

package/lib/api/cloud-assembly/cached-source.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CachedCloudAssembly = void 0;
+require("../../private/dispose-polyfill");
+const borrowed_assembly_1 = require("./private/borrowed-assembly");
+/**
+ * A CloudAssemblySource that is caching its result once produced.
+ *
+ * Most Toolkit interactions should use a cached source. Not caching is
+ * relevant when the source changes frequently and it is to expensive to predict
+ * if the source has changed.
+ *
+ * The `CachedCloudAssembly` is both itself a readable CloudAssembly, as well as
+ * a Cloud Assembly Source. The lifetimes of cloud assemblies produced by this
+ * source are coupled to the lifetime of the `CachedCloudAssembly`. In other
+ * words: the `dispose()` functions of those cloud assemblies don't do anything;
+ * only the `dispose()` function of the `CachedCloudAssembly` will be used.
+ *
+ * NOTE: if we are concerned about borrowed assemblies outliving the parent
+ * (i.e. the parent getting disposed while someone is still working with the
+ * borrowed copies), we could consider referencing counting here. That seems
+ * unnecessarily complicated for now, we will just assume that everyone is
+ * being a good citizen an borrowed copies are only used by the toolkit and
+ * immediately disposed of.
+ *
+ * Because `dispose()` is a no-op on the borrowed assembly, you can omit it
+ * without changing behavior, but that would turn into a leak if we ever introduced
+ * reference counting. Failing to dispose the result if a `produce()` call of a
+ * `CachedCloudAssembly` is considered a bug.
+ */
+class CachedCloudAssembly {
+    asm;
+    constructor(asm) {
+        this.asm = asm;
+    }
+    get cloudAssembly() {
+        return this.asm.cloudAssembly;
+    }
+    async produce() {
+        return new borrowed_assembly_1.BorrowedAssembly(this.asm.cloudAssembly);
+    }
+    _unlock() {
+        return this.asm._unlock();
+    }
+    dispose() {
+        return this.asm.dispose();
+    }
+    [Symbol.asyncDispose]() {
+        return this.dispose();
+    }
+}
+exports.CachedCloudAssembly = CachedCloudAssembly;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/api/cloud-assembly/index.d.ts

@@ -1,3 +1,4 @@
 export { StackSelectionStrategy, StackSelector } from '../../api/shared-public';
+export * from './cached-source';
 export * from './source-builder';
 export * from './types';

package/lib/api/cloud-assembly/index.js

@@ -17,6 +17,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.StackSelectionStrategy = void 0;
 var shared_public_1 = require("../../api/shared-public");
 Object.defineProperty(exports, "StackSelectionStrategy", { enumerable: true, get: function () { return shared_public_1.StackSelectionStrategy; } });
+__exportStar(require("./cached-source"), exports);
 __exportStar(require("./source-builder"), exports);
 __exportStar(require("./types"), exports);
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJpbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7OztBQUFBLHlEQUFnRjtBQUF2RSx1SEFBQSxzQkFBc0IsT0FBQTtBQUMvQixtREFBaUM7QUFDakMsMENBQXdCIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IHsgU3RhY2tTZWxlY3Rpb25TdHJhdGVneSwgU3RhY2tTZWxlY3RvciB9IGZyb20gJy4uLy4uL2FwaS9zaGFyZWQtcHVibGljJztcbmV4cG9ydCAqIGZyb20gJy4vc291cmNlLWJ1aWxkZXInO1xuZXhwb3J0ICogZnJvbSAnLi90eXBlcyc7XG5cbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJpbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7OztBQUFBLHlEQUFnRjtBQUF2RSx1SEFBQSxzQkFBc0IsT0FBQTtBQUMvQixrREFBZ0M7QUFDaEMsbURBQWlDO0FBQ2pDLDBDQUF3QiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCB7IFN0YWNrU2VsZWN0aW9uU3RyYXRlZ3ksIFN0YWNrU2VsZWN0b3IgfSBmcm9tICcuLi8uLi9hcGkvc2hhcmVkLXB1YmxpYyc7XG5leHBvcnQgKiBmcm9tICcuL2NhY2hlZC1zb3VyY2UnO1xuZXhwb3J0ICogZnJvbSAnLi9zb3VyY2UtYnVpbGRlcic7XG5leHBvcnQgKiBmcm9tICcuL3R5cGVzJztcblxuIl19

package/lib/api/cloud-assembly/private/borrowed-assembly.d.ts

@@ -0,0 +1,15 @@
+import '../../../private/dispose-polyfill';
+import type * as cxapi from '@aws-cdk/cx-api';
+import type { IReadableCloudAssembly } from '../types';
+/**
+ * An implementation of `IReadableCloudAssembly` that does nothing except hold on to the CloudAssembly object
+ *
+ * It does not own a lock, and it does not clean the underlying directory.
+ */
+export declare class BorrowedAssembly implements IReadableCloudAssembly {
+    readonly cloudAssembly: cxapi.CloudAssembly;
+    constructor(cloudAssembly: cxapi.CloudAssembly);
+    _unlock(): Promise<void>;
+    dispose(): Promise<void>;
+    [Symbol.asyncDispose](): Promise<void>;
+}

package/lib/api/cloud-assembly/private/borrowed-assembly.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BorrowedAssembly = void 0;
+require("../../../private/dispose-polyfill");
+/**
+ * An implementation of `IReadableCloudAssembly` that does nothing except hold on to the CloudAssembly object
+ *
+ * It does not own a lock, and it does not clean the underlying directory.
+ */
+class BorrowedAssembly {
+    cloudAssembly;
+    constructor(cloudAssembly) {
+        this.cloudAssembly = cloudAssembly;
+    }
+    async _unlock() {
+    }
+    async dispose() {
+    }
+    async [Symbol.asyncDispose]() {
+    }
+}
+exports.BorrowedAssembly = BorrowedAssembly;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYm9ycm93ZWQtYXNzZW1ibHkuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJib3Jyb3dlZC1hc3NlbWJseS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFBQSw2Q0FBMkM7QUFJM0M7Ozs7R0FJRztBQUNILE1BQWEsZ0JBQWdCO0lBQ0M7SUFBNUIsWUFBNEIsYUFBa0M7UUFBbEMsa0JBQWEsR0FBYixhQUFhLENBQXFCO0lBQzlELENBQUM7SUFFTSxLQUFLLENBQUMsT0FBTztJQUNwQixDQUFDO0lBRU0sS0FBSyxDQUFDLE9BQU87SUFDcEIsQ0FBQztJQUVNLEtBQUssQ0FBQyxDQUFDLE1BQU0sQ0FBQyxZQUFZLENBQUM7SUFDbEMsQ0FBQztDQUNGO0FBWkQsNENBWUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgJy4uLy4uLy4uL3ByaXZhdGUvZGlzcG9zZS1wb2x5ZmlsbCc7XG5pbXBvcnQgdHlwZSAqIGFzIGN4YXBpIGZyb20gJ0Bhd3MtY2RrL2N4LWFwaSc7XG5pbXBvcnQgdHlwZSB7IElSZWFkYWJsZUNsb3VkQXNzZW1ibHkgfSBmcm9tICcuLi90eXBlcyc7XG5cbi8qKlxuICogQW4gaW1wbGVtZW50YXRpb24gb2YgYElSZWFkYWJsZUNsb3VkQXNzZW1ibHlgIHRoYXQgZG9lcyBub3RoaW5nIGV4Y2VwdCBob2xkIG9uIHRvIHRoZSBDbG91ZEFzc2VtYmx5IG9iamVjdFxuICpcbiAqIEl0IGRvZXMgbm90IG93biBhIGxvY2ssIGFuZCBpdCBkb2VzIG5vdCBjbGVhbiB0aGUgdW5kZXJseWluZyBkaXJlY3RvcnkuXG4gKi9cbmV4cG9ydCBjbGFzcyBCb3Jyb3dlZEFzc2VtYmx5IGltcGxlbWVudHMgSVJlYWRhYmxlQ2xvdWRBc3NlbWJseSB7XG4gIGNvbnN0cnVjdG9yKHB1YmxpYyByZWFkb25seSBjbG91ZEFzc2VtYmx5OiBjeGFwaS5DbG91ZEFzc2VtYmx5KSB7XG4gIH1cblxuICBwdWJsaWMgYXN5bmMgX3VubG9jaygpOiBQcm9taXNlPHZvaWQ+IHtcbiAgfVxuXG4gIHB1YmxpYyBhc3luYyBkaXNwb3NlKCk6IFByb21pc2U8dm9pZD4ge1xuICB9XG5cbiAgcHVibGljIGFzeW5jIFtTeW1ib2wuYXN5bmNEaXNwb3NlXSgpOiBQcm9taXNlPHZvaWQ+IHtcbiAgfVxufVxuXG4iXX0=

package/lib/api/cloud-assembly/private/context-aware-source.d.ts

@@ -1,7 +1,6 @@
-import type * as cxapi from '@aws-cdk/cx-api';
 import type { ToolkitServices } from '../../../toolkit/private';
 import { type Context } from '../../shared-private';
-import type { ICloudAssemblySource } from '../types';
+import type { ICloudAssemblySource, IReadableCloudAssembly } from '../types';
 export interface ContextAwareCloudAssemblyProps {
     /**
      * AWS object (used by contextprovider)
@@ -28,9 +27,23 @@ export interface ContextAwareCloudAssemblyProps {
     readonly lookups?: boolean;
 }
 /**
- * Represent the Cloud Executable and the synthesis we can do on it
+ * A CloudAssemblySource that wraps another CloudAssemblySource and runs a lookup loop on it
+ *
+ * This means that if the underlying CloudAssemblySource produces a manifest
+ * with provider queries in it, the `ContextAwareCloudAssemblySource` will
+ * perform the necessary context lookups and invoke the underlying
+ * `CloudAssemblySource` again with thew missing context information.
+ *
+ * This is only useful if the underlying `CloudAssemblySource` can respond to
+ * this new context information (it must be a CDK app source); if it is just a
+ * static directory, then the contents of the assembly won't change in response
+ * to context.
+ *
+ * The context is passed between `ContextAwareCloudAssemblySource` and the wrapped
+ * cloud assembly source via a contex file on disk, so the wrapped assembly source
+ * should re-read the context file on every invocation.
  */
-export declare class ContextAwareCloudAssembly implements ICloudAssemblySource {
+export declare class ContextAwareCloudAssemblySource implements ICloudAssemblySource {
     private readonly source;
     private readonly props;
     private canLookup;
@@ -41,5 +54,5 @@ export declare class ContextAwareCloudAssembly implements ICloudAssemblySource {
     /**
      * Produce a Cloud Assembly, i.e. a set of stacks
      */
-    produce(): Promise<cxapi.CloudAssembly>;
+    produce(): Promise<IReadableCloudAssembly>;
 }