@aws-cdk/toolkit-lib 1.12.4 → 1.13.0

package/build-info.json

@@ -1,4 +1,4 @@
 {
-  "comment": "Generated at 2026-01-06T16:03:26Z by build-info.sh",
-  "commit": "0aa3e98"
+  "comment": "Generated at 2026-01-15T09:02:55Z by build-info.sh",
+  "commit": "92af268"
 }

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

@@ -185,4 +185,30 @@ export declare class BootstrapSource {
      */
     static customTemplate(templateFile: string): BootstrapOptions['source'];
 }
+/**
+ * Represents a bootstrap template that can be serialized to YAML or JSON
+ */
+export declare class BootstrapTemplate {
+    private readonly template;
+    /**
+     * Load a bootstrap template from a source
+     *
+     * @param source - The bootstrap template source configuration
+     * @returns A BootstrapTemplate instance
+     */
+    static fromSource(source?: BootstrapOptions['source']): Promise<BootstrapTemplate>;
+    private constructor();
+    /**
+     * Serialize the template as YAML
+     *
+     * @returns The template as a YAML string
+     */
+    asYAML(): string;
+    /**
+     * Serialize the template as JSON
+     *
+     * @returns The template as a JSON string
+     */
+    asJSON(): string;
+}
 //# sourceMappingURL=index.d.ts.map

package/lib/actions/bootstrap/index.js

@@ -52,11 +52,13 @@ var __disposeResources = (this && this.__disposeResources) || (function (Suppres
     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;
+exports.BootstrapTemplate = exports.BootstrapSource = exports.BootstrapStackParameters = exports.BootstrapEnvironments = void 0;
+const path = require("path");
 const private_1 = require("./private");
 const private_2 = require("../../api/cloud-assembly/private");
 const private_3 = require("../../api/io/private");
 const private_4 = require("../../toolkit/private");
+const util_1 = require("../../util");
 /**
  * Create manage bootstrap environments
  */
@@ -162,4 +164,48 @@ 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;AAE9D,kDAAkD;AAElD,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,oBAAU,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;AAqJD;;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 { asIoHelper } from '../../api/io/private';\nimport type { Tag } from '../../api/tags';\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   * Whether to force deployment if a bootstrap stack already exists\n   * @default false\n   */\n  readonly forceDeployment?: 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"]}
+/**
+ * Represents a bootstrap template that can be serialized to YAML or JSON
+ */
+class BootstrapTemplate {
+    template;
+    /**
+     * Load a bootstrap template from a source
+     *
+     * @param source - The bootstrap template source configuration
+     * @returns A BootstrapTemplate instance
+     */
+    static async fromSource(source = { source: 'default' }) {
+        let template;
+        switch (source.source) {
+            case 'custom':
+                template = await (0, util_1.loadStructuredFile)(source.templateFile);
+                break;
+            case 'default':
+                template = await (0, util_1.loadStructuredFile)(path.join((0, util_1.bundledPackageRootDir)(__dirname), 'lib', 'api', 'bootstrap', 'bootstrap-template.yaml'));
+                break;
+        }
+        return new BootstrapTemplate(template);
+    }
+    constructor(template) {
+        this.template = template;
+    }
+    /**
+     * Serialize the template as YAML
+     *
+     * @returns The template as a YAML string
+     */
+    asYAML() {
+        return (0, util_1.serializeStructure)(this.template, false);
+    }
+    /**
+     * Serialize the template as JSON
+     *
+     * @returns The template as a JSON string
+     */
+    asJSON() {
+        return (0, util_1.serializeStructure)(this.template, true);
+    }
+}
+exports.BootstrapTemplate = BootstrapTemplate;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,6BAA6B;AAE7B,uCAAwD;AAExD,8DAA8D;AAE9D,kDAAkD;AAElD,mDAA2D;AAC3D,qCAA2F;AAE3F;;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,oBAAU,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;AAqJD;;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;AAED;;GAEG;AACH,MAAa,iBAAiB;IAsBS;IArBrC;;;;;OAKG;IACH,MAAM,CAAC,KAAK,CAAC,UAAU,CAAC,SAAqC,EAAE,MAAM,EAAE,SAAS,EAAE;QAChF,IAAI,QAAa,CAAC;QAElB,QAAQ,MAAM,CAAC,MAAM,EAAE,CAAC;YACtB,KAAK,QAAQ;gBACX,QAAQ,GAAG,MAAM,IAAA,yBAAkB,EAAC,MAAM,CAAC,YAAY,CAAC,CAAC;gBACzD,MAAM;YACR,KAAK,SAAS;gBACZ,QAAQ,GAAG,MAAM,IAAA,yBAAkB,EAAC,IAAI,CAAC,IAAI,CAAC,IAAA,4BAAqB,EAAC,SAAS,CAAC,EAAE,KAAK,EAAE,KAAK,EAAE,WAAW,EAAE,yBAAyB,CAAC,CAAC,CAAC;gBACvI,MAAM;QACV,CAAC;QAED,OAAO,IAAI,iBAAiB,CAAC,QAAQ,CAAC,CAAC;IACzC,CAAC;IAED,YAAqC,QAAa;QAAb,aAAQ,GAAR,QAAQ,CAAK;IAClD,CAAC;IAED;;;;OAIG;IACI,MAAM;QACX,OAAO,IAAA,yBAAkB,EAAC,IAAI,CAAC,QAAQ,EAAE,KAAK,CAAC,CAAC;IAClD,CAAC;IAED;;;;OAIG;IACI,MAAM;QACX,OAAO,IAAA,yBAAkB,EAAC,IAAI,CAAC,QAAQ,EAAE,IAAI,CAAC,CAAC;IACjD,CAAC;CACF;AA1CD,8CA0CC","sourcesContent":["import * as path from 'path';\nimport 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 { asIoHelper } from '../../api/io/private';\nimport type { Tag } from '../../api/tags';\nimport { assemblyFromSource } from '../../toolkit/private';\nimport { bundledPackageRootDir, loadStructuredFile, serializeStructure } from '../../util';\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   * Whether to force deployment if a bootstrap stack already exists\n   * @default false\n   */\n  readonly forceDeployment?: 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\n/**\n * Represents a bootstrap template that can be serialized to YAML or JSON\n */\nexport class BootstrapTemplate {\n  /**\n   * Load a bootstrap template from a source\n   *\n   * @param source - The bootstrap template source configuration\n   * @returns A BootstrapTemplate instance\n   */\n  static async fromSource(source: BootstrapOptions['source'] = { source: 'default' }): Promise<BootstrapTemplate> {\n    let template: any;\n\n    switch (source.source) {\n      case 'custom':\n        template = await loadStructuredFile(source.templateFile);\n        break;\n      case 'default':\n        template = await loadStructuredFile(path.join(bundledPackageRootDir(__dirname), 'lib', 'api', 'bootstrap', 'bootstrap-template.yaml'));\n        break;\n    }\n\n    return new BootstrapTemplate(template);\n  }\n\n  private constructor(private readonly template: any) {\n  }\n\n  /**\n   * Serialize the template as YAML\n   *\n   * @returns The template as a YAML string\n   */\n  public asYAML(): string {\n    return serializeStructure(this.template, false);\n  }\n\n  /**\n   * Serialize the template as JSON\n   *\n   * @returns The template as a JSON string\n   */\n  public asJSON(): string {\n    return serializeStructure(this.template, true);\n  }\n}\n"]}

package/lib/api/environment/environment-resources.js

@@ -130,7 +130,14 @@ class EnvironmentResources {
         }
         const ssm = this.sdk.ssm();
         try {
-            const result = await ssm.getParameter({ Name: parameterName });
+            const result = await ssm.getParameter({
+                Name: parameterName,
+                // A custom template might use a SecureString for this, so we request the decrypted parameter.
+                // The flag is safe to set, since it will be ignored for unencrypted parameters.
+                // It is still up to user to ensure that all roles have sufficient permissions,
+                // however when using AWS Managed Keys, SSM is granted decryption permissions by default.
+                WithDecryption: true,
+            });
             const asNumber = parseInt(`${result.Parameter?.Value}`, 10);
             if (isNaN(asNumber)) {
                 throw new toolkit_error_1.ToolkitError(`SSM parameter ${parameterName} not a number: ${result.Parameter?.Value}`);
@@ -209,4 +216,4 @@ function emptyCache() {
  * The bootstrap template version that introduced ssm:GetParameter
  */
 const BOOTSTRAP_TEMPLATE_VERSION_INTRODUCING_GETPARAMETER = 5;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"environment-resources.js","sourceRoot":"","sources":["environment-resources.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Environment } from '@aws-cdk/cx-api';\nimport { ToolkitError } from '../../toolkit/toolkit-error';\nimport { formatErrorMessage } from '../../util';\nimport type { SDK } from '../aws-auth/private';\nimport type { IoHelper } from '../io/private';\nimport { Notices } from '../notices';\nimport { type EcrRepositoryInfo, ToolkitInfo } from '../toolkit-info';\n\n/**\n * Registry class for `EnvironmentResources`.\n *\n * The state management of this class is a bit non-standard. We want to cache\n * data related to toolkit stacks and SSM parameters, but we are not in charge\n * of ensuring caching of SDKs. Since `EnvironmentResources` needs an SDK to\n * function, we treat it as an ephemeral class, and store the actual cached data\n * in `EnvironmentResourcesRegistry`.\n */\nexport class EnvironmentResourcesRegistry {\n  private readonly cache = new Map<string, EnvironmentCache>();\n\n  constructor(private readonly toolkitStackName?: string) {\n  }\n\n  public for(resolvedEnvironment: Environment, sdk: SDK, ioHelper: IoHelper) {\n    const key = `${resolvedEnvironment.account}:${resolvedEnvironment.region}`;\n    let envCache = this.cache.get(key);\n    if (!envCache) {\n      envCache = emptyCache();\n      this.cache.set(key, envCache);\n    }\n    return new EnvironmentResources(resolvedEnvironment, sdk, ioHelper, envCache, this.toolkitStackName);\n  }\n}\n\n/**\n * Interface with the account and region we're deploying into\n *\n * Manages lookups for bootstrapped resources, falling back to the legacy \"CDK Toolkit\"\n * original bootstrap stack if necessary.\n *\n * The state management of this class is a bit non-standard. We want to cache\n * data related to toolkit stacks and SSM parameters, but we are not in charge\n * of ensuring caching of SDKs. Since `EnvironmentResources` needs an SDK to\n * function, we treat it as an ephemeral class, and store the actual cached data\n * in `EnvironmentResourcesRegistry`.\n */\nexport class EnvironmentResources {\n  constructor(\n    public readonly environment: Environment,\n    private readonly sdk: SDK,\n    private readonly ioHelper: IoHelper,\n    private readonly cache: EnvironmentCache,\n    private readonly toolkitStackName?: string,\n  ) {\n  }\n\n  /**\n   * Look up the toolkit for a given environment, using a given SDK\n   */\n  public async lookupToolkit() {\n    if (!this.cache.toolkitInfo) {\n      this.cache.toolkitInfo = await ToolkitInfo.lookup(this.environment, this.sdk, this.ioHelper, this.toolkitStackName);\n    }\n    return this.cache.toolkitInfo;\n  }\n\n  /**\n   * Validate that the bootstrap stack version matches or exceeds the expected version\n   *\n   * Use the SSM parameter name to read the version number if given, otherwise use the version\n   * discovered on the bootstrap stack.\n   *\n   * Pass in the SSM parameter name so we can cache the lookups an don't need to do the same\n   * lookup again and again for every artifact.\n   */\n  public async validateVersion(expectedVersion: number | undefined, ssmParameterName: string | undefined) {\n    if (expectedVersion === undefined) {\n      // No requirement\n      return;\n    }\n    const defExpectedVersion = expectedVersion;\n\n    if (ssmParameterName !== undefined) {\n      try {\n        doValidate(await this.versionFromSsmParameter(ssmParameterName), this.environment);\n        return;\n      } catch (e: any) {\n        if (e.name !== 'AccessDeniedException') {\n          throw e;\n        }\n\n        // This is a fallback! The bootstrap template that goes along with this change introduces\n        // a new 'ssm:GetParameter' permission, but when run using the previous bootstrap template we\n        // won't have the permissions yet to read the version, so we won't be able to show the\n        // message telling the user they need to update! When we see an AccessDeniedException, fall\n        // back to the version we read from Stack Outputs; but ONLY if the version we discovered via\n        // outputs is legitimately an old version. If it's newer than that, something else must be broken,\n        // so let it fail as it would if we didn't have this fallback.\n        const bootstrapStack = await this.lookupToolkit();\n        if (bootstrapStack.found && bootstrapStack.version < BOOTSTRAP_TEMPLATE_VERSION_INTRODUCING_GETPARAMETER) {\n          await this.ioHelper.defaults.warn(\n            `Could not read SSM parameter ${ssmParameterName}: ${formatErrorMessage(e)}, falling back to version from ${bootstrapStack}`,\n          );\n          doValidate(bootstrapStack.version, this.environment);\n          return;\n        }\n\n        throw new ToolkitError(\n          `This CDK deployment requires bootstrap stack version '${expectedVersion}', but during the confirmation via SSM parameter ${ssmParameterName} the following error occurred: ${e}`,\n        );\n      }\n    }\n\n    // No SSM parameter\n    const bootstrapStack = await this.lookupToolkit();\n    doValidate(bootstrapStack.version, this.environment);\n\n    function doValidate(version: number, environment: Environment) {\n      const notices = Notices.get();\n      if (notices) {\n        // if `Notices` hasn't been initialized there is probably a good\n        // reason for it. handle gracefully.\n        notices.addBootstrappedEnvironment({ bootstrapStackVersion: version, environment });\n      }\n      if (defExpectedVersion > version) {\n        throw new ToolkitError(\n          `This CDK deployment requires bootstrap stack version '${expectedVersion}', found '${version}'. Please run 'cdk bootstrap'.`,\n        );\n      }\n    }\n  }\n\n  /**\n   * Read a version from an SSM parameter, cached\n   */\n  public async versionFromSsmParameter(parameterName: string): Promise<number> {\n    const existing = this.cache.ssmParameters.get(parameterName);\n    if (existing !== undefined) {\n      return existing;\n    }\n\n    const ssm = this.sdk.ssm();\n\n    try {\n      const result = await ssm.getParameter({ Name: parameterName });\n\n      const asNumber = parseInt(`${result.Parameter?.Value}`, 10);\n      if (isNaN(asNumber)) {\n        throw new ToolkitError(`SSM parameter ${parameterName} not a number: ${result.Parameter?.Value}`);\n      }\n\n      this.cache.ssmParameters.set(parameterName, asNumber);\n      return asNumber;\n    } catch (e: any) {\n      if (e.name === 'ParameterNotFound') {\n        throw new ToolkitError(\n          `SSM parameter ${parameterName} not found. Has the environment been bootstrapped? Please run \\'cdk bootstrap\\' (see https://docs.aws.amazon.com/cdk/latest/guide/bootstrapping.html)`,\n        );\n      }\n      throw e;\n    }\n  }\n\n  public async prepareEcrRepository(repositoryName: string): Promise<EcrRepositoryInfo> {\n    if (!this.sdk) {\n      throw new ToolkitError('ToolkitInfo needs to have been initialized with an sdk to call prepareEcrRepository');\n    }\n    const ecr = this.sdk.ecr();\n\n    // check if repo already exists\n    try {\n      await this.ioHelper.defaults.debug(`${repositoryName}: checking if ECR repository already exists`);\n      const describeResponse = await ecr.describeRepositories({\n        repositoryNames: [repositoryName],\n      });\n      const existingRepositoryUri = describeResponse.repositories![0]?.repositoryUri;\n      if (existingRepositoryUri) {\n        return { repositoryUri: existingRepositoryUri };\n      }\n    } catch (e: any) {\n      if (e.name !== 'RepositoryNotFoundException') {\n        throw e;\n      }\n    }\n\n    // create the repo (tag it so it will be easier to garbage collect in the future)\n    await this.ioHelper.defaults.debug(`${repositoryName}: creating ECR repository`);\n    const assetTag = { Key: 'awscdk:asset', Value: 'true' };\n    const response = await ecr.createRepository({\n      repositoryName,\n      tags: [assetTag],\n    });\n    const repositoryUri = response.repository?.repositoryUri;\n    if (!repositoryUri) {\n      throw new ToolkitError(`CreateRepository did not return a repository URI for ${repositoryUri}`);\n    }\n\n    // configure image scanning on push (helps in identifying software vulnerabilities, no additional charge)\n    await this.ioHelper.defaults.debug(`${repositoryName}: enable image scanning`);\n    await ecr.putImageScanningConfiguration({\n      repositoryName,\n      imageScanningConfiguration: { scanOnPush: true },\n    });\n\n    return { repositoryUri };\n  }\n}\n\nexport class NoBootstrapStackEnvironmentResources extends EnvironmentResources {\n  constructor(environment: Environment, sdk: SDK, ioHelper: IoHelper) {\n    super(environment, sdk, ioHelper, emptyCache());\n  }\n\n  /**\n   * Look up the toolkit for a given environment, using a given SDK\n   */\n  public async lookupToolkit(): Promise<ToolkitInfo> {\n    throw new ToolkitError(\n      'Trying to perform an operation that requires a bootstrap stack; you should not see this error, this is a bug in the CDK CLI.',\n    );\n  }\n}\n\n/**\n * Data that is cached on a per-environment level\n *\n * This cache may be shared between different instances of the `EnvironmentResources` class.\n */\ninterface EnvironmentCache {\n  readonly ssmParameters: Map<string, number>;\n  toolkitInfo?: ToolkitInfo;\n}\n\nfunction emptyCache(): EnvironmentCache {\n  return {\n    ssmParameters: new Map(),\n    toolkitInfo: undefined,\n  };\n}\n\n/**\n * The bootstrap template version that introduced ssm:GetParameter\n */\nconst BOOTSTRAP_TEMPLATE_VERSION_INTRODUCING_GETPARAMETER = 5;\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"environment-resources.js","sourceRoot":"","sources":["environment-resources.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Environment } from '@aws-cdk/cx-api';\nimport { ToolkitError } from '../../toolkit/toolkit-error';\nimport { formatErrorMessage } from '../../util';\nimport type { SDK } from '../aws-auth/private';\nimport type { IoHelper } from '../io/private';\nimport { Notices } from '../notices';\nimport { type EcrRepositoryInfo, ToolkitInfo } from '../toolkit-info';\n\n/**\n * Registry class for `EnvironmentResources`.\n *\n * The state management of this class is a bit non-standard. We want to cache\n * data related to toolkit stacks and SSM parameters, but we are not in charge\n * of ensuring caching of SDKs. Since `EnvironmentResources` needs an SDK to\n * function, we treat it as an ephemeral class, and store the actual cached data\n * in `EnvironmentResourcesRegistry`.\n */\nexport class EnvironmentResourcesRegistry {\n  private readonly cache = new Map<string, EnvironmentCache>();\n\n  constructor(private readonly toolkitStackName?: string) {\n  }\n\n  public for(resolvedEnvironment: Environment, sdk: SDK, ioHelper: IoHelper) {\n    const key = `${resolvedEnvironment.account}:${resolvedEnvironment.region}`;\n    let envCache = this.cache.get(key);\n    if (!envCache) {\n      envCache = emptyCache();\n      this.cache.set(key, envCache);\n    }\n    return new EnvironmentResources(resolvedEnvironment, sdk, ioHelper, envCache, this.toolkitStackName);\n  }\n}\n\n/**\n * Interface with the account and region we're deploying into\n *\n * Manages lookups for bootstrapped resources, falling back to the legacy \"CDK Toolkit\"\n * original bootstrap stack if necessary.\n *\n * The state management of this class is a bit non-standard. We want to cache\n * data related to toolkit stacks and SSM parameters, but we are not in charge\n * of ensuring caching of SDKs. Since `EnvironmentResources` needs an SDK to\n * function, we treat it as an ephemeral class, and store the actual cached data\n * in `EnvironmentResourcesRegistry`.\n */\nexport class EnvironmentResources {\n  constructor(\n    public readonly environment: Environment,\n    private readonly sdk: SDK,\n    private readonly ioHelper: IoHelper,\n    private readonly cache: EnvironmentCache,\n    private readonly toolkitStackName?: string,\n  ) {\n  }\n\n  /**\n   * Look up the toolkit for a given environment, using a given SDK\n   */\n  public async lookupToolkit() {\n    if (!this.cache.toolkitInfo) {\n      this.cache.toolkitInfo = await ToolkitInfo.lookup(this.environment, this.sdk, this.ioHelper, this.toolkitStackName);\n    }\n    return this.cache.toolkitInfo;\n  }\n\n  /**\n   * Validate that the bootstrap stack version matches or exceeds the expected version\n   *\n   * Use the SSM parameter name to read the version number if given, otherwise use the version\n   * discovered on the bootstrap stack.\n   *\n   * Pass in the SSM parameter name so we can cache the lookups an don't need to do the same\n   * lookup again and again for every artifact.\n   */\n  public async validateVersion(expectedVersion: number | undefined, ssmParameterName: string | undefined) {\n    if (expectedVersion === undefined) {\n      // No requirement\n      return;\n    }\n    const defExpectedVersion = expectedVersion;\n\n    if (ssmParameterName !== undefined) {\n      try {\n        doValidate(await this.versionFromSsmParameter(ssmParameterName), this.environment);\n        return;\n      } catch (e: any) {\n        if (e.name !== 'AccessDeniedException') {\n          throw e;\n        }\n\n        // This is a fallback! The bootstrap template that goes along with this change introduces\n        // a new 'ssm:GetParameter' permission, but when run using the previous bootstrap template we\n        // won't have the permissions yet to read the version, so we won't be able to show the\n        // message telling the user they need to update! When we see an AccessDeniedException, fall\n        // back to the version we read from Stack Outputs; but ONLY if the version we discovered via\n        // outputs is legitimately an old version. If it's newer than that, something else must be broken,\n        // so let it fail as it would if we didn't have this fallback.\n        const bootstrapStack = await this.lookupToolkit();\n        if (bootstrapStack.found && bootstrapStack.version < BOOTSTRAP_TEMPLATE_VERSION_INTRODUCING_GETPARAMETER) {\n          await this.ioHelper.defaults.warn(\n            `Could not read SSM parameter ${ssmParameterName}: ${formatErrorMessage(e)}, falling back to version from ${bootstrapStack}`,\n          );\n          doValidate(bootstrapStack.version, this.environment);\n          return;\n        }\n\n        throw new ToolkitError(\n          `This CDK deployment requires bootstrap stack version '${expectedVersion}', but during the confirmation via SSM parameter ${ssmParameterName} the following error occurred: ${e}`,\n        );\n      }\n    }\n\n    // No SSM parameter\n    const bootstrapStack = await this.lookupToolkit();\n    doValidate(bootstrapStack.version, this.environment);\n\n    function doValidate(version: number, environment: Environment) {\n      const notices = Notices.get();\n      if (notices) {\n        // if `Notices` hasn't been initialized there is probably a good\n        // reason for it. handle gracefully.\n        notices.addBootstrappedEnvironment({ bootstrapStackVersion: version, environment });\n      }\n      if (defExpectedVersion > version) {\n        throw new ToolkitError(\n          `This CDK deployment requires bootstrap stack version '${expectedVersion}', found '${version}'. Please run 'cdk bootstrap'.`,\n        );\n      }\n    }\n  }\n\n  /**\n   * Read a version from an SSM parameter, cached\n   */\n  public async versionFromSsmParameter(parameterName: string): Promise<number> {\n    const existing = this.cache.ssmParameters.get(parameterName);\n    if (existing !== undefined) {\n      return existing;\n    }\n\n    const ssm = this.sdk.ssm();\n\n    try {\n      const result = await ssm.getParameter({\n        Name: parameterName,\n        // A custom template might use a SecureString for this, so we request the decrypted parameter.\n        // The flag is safe to set, since it will be ignored for unencrypted parameters.\n        // It is still up to user to ensure that all roles have sufficient permissions,\n        // however when using AWS Managed Keys, SSM is granted decryption permissions by default.\n        WithDecryption: true,\n      });\n\n      const asNumber = parseInt(`${result.Parameter?.Value}`, 10);\n      if (isNaN(asNumber)) {\n        throw new ToolkitError(`SSM parameter ${parameterName} not a number: ${result.Parameter?.Value}`);\n      }\n\n      this.cache.ssmParameters.set(parameterName, asNumber);\n      return asNumber;\n    } catch (e: any) {\n      if (e.name === 'ParameterNotFound') {\n        throw new ToolkitError(\n          `SSM parameter ${parameterName} not found. Has the environment been bootstrapped? Please run \\'cdk bootstrap\\' (see https://docs.aws.amazon.com/cdk/latest/guide/bootstrapping.html)`,\n        );\n      }\n      throw e;\n    }\n  }\n\n  public async prepareEcrRepository(repositoryName: string): Promise<EcrRepositoryInfo> {\n    if (!this.sdk) {\n      throw new ToolkitError('ToolkitInfo needs to have been initialized with an sdk to call prepareEcrRepository');\n    }\n    const ecr = this.sdk.ecr();\n\n    // check if repo already exists\n    try {\n      await this.ioHelper.defaults.debug(`${repositoryName}: checking if ECR repository already exists`);\n      const describeResponse = await ecr.describeRepositories({\n        repositoryNames: [repositoryName],\n      });\n      const existingRepositoryUri = describeResponse.repositories![0]?.repositoryUri;\n      if (existingRepositoryUri) {\n        return { repositoryUri: existingRepositoryUri };\n      }\n    } catch (e: any) {\n      if (e.name !== 'RepositoryNotFoundException') {\n        throw e;\n      }\n    }\n\n    // create the repo (tag it so it will be easier to garbage collect in the future)\n    await this.ioHelper.defaults.debug(`${repositoryName}: creating ECR repository`);\n    const assetTag = { Key: 'awscdk:asset', Value: 'true' };\n    const response = await ecr.createRepository({\n      repositoryName,\n      tags: [assetTag],\n    });\n    const repositoryUri = response.repository?.repositoryUri;\n    if (!repositoryUri) {\n      throw new ToolkitError(`CreateRepository did not return a repository URI for ${repositoryUri}`);\n    }\n\n    // configure image scanning on push (helps in identifying software vulnerabilities, no additional charge)\n    await this.ioHelper.defaults.debug(`${repositoryName}: enable image scanning`);\n    await ecr.putImageScanningConfiguration({\n      repositoryName,\n      imageScanningConfiguration: { scanOnPush: true },\n    });\n\n    return { repositoryUri };\n  }\n}\n\nexport class NoBootstrapStackEnvironmentResources extends EnvironmentResources {\n  constructor(environment: Environment, sdk: SDK, ioHelper: IoHelper) {\n    super(environment, sdk, ioHelper, emptyCache());\n  }\n\n  /**\n   * Look up the toolkit for a given environment, using a given SDK\n   */\n  public async lookupToolkit(): Promise<ToolkitInfo> {\n    throw new ToolkitError(\n      'Trying to perform an operation that requires a bootstrap stack; you should not see this error, this is a bug in the CDK CLI.',\n    );\n  }\n}\n\n/**\n * Data that is cached on a per-environment level\n *\n * This cache may be shared between different instances of the `EnvironmentResources` class.\n */\ninterface EnvironmentCache {\n  readonly ssmParameters: Map<string, number>;\n  toolkitInfo?: ToolkitInfo;\n}\n\nfunction emptyCache(): EnvironmentCache {\n  return {\n    ssmParameters: new Map(),\n    toolkitInfo: undefined,\n  };\n}\n\n/**\n * The bootstrap template version that introduced ssm:GetParameter\n */\nconst BOOTSTRAP_TEMPLATE_VERSION_INTRODUCING_GETPARAMETER = 5;\n"]}

package/lib/context-providers/cc-api-provider.js

@@ -37,7 +37,7 @@ class CcApiContextProviderPlugin {
             }
             else if (args.propertyMatch) {
                 // use listResource
-                resources = await this.listResources(cloudControl, args.typeName, args.propertyMatch, args.expectedMatchCount);
+                resources = await this.listResources(cloudControl, args.typeName, args.propertyMatch, args.expectedMatchCount, args.resourceModel);
             }
             else {
                 throw new toolkit_error_1.ContextProviderError(`Provider protocol error: neither exactIdentifier nor propertyMatch is specified in ${JSON.stringify(args)}.`);
@@ -87,13 +87,15 @@ class CcApiContextProviderPlugin {
      *
      * Does not currently paginate through more than one result page.
      */
-    async listResources(cc, typeName, propertyMatch, expectedMatchCount) {
+    async listResources(cc, typeName, propertyMatch, expectedMatchCount, resourceModel) {
         try {
             const found = [];
             let nextToken = undefined;
+            const resourceModelJSON = resourceModel ? JSON.stringify(resourceModel) : undefined;
             do {
                 const result = await cc.listResources({
                     TypeName: typeName,
+                    ResourceModel: resourceModelJSON,
                     MaxResults: 100,
                     ...nextToken ? { NextToken: nextToken } : {},
                 });
@@ -160,4 +162,4 @@ function expectedMatchCountText(expectation) {
             return expectation;
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cc-api-provider.js","sourceRoot":"","sources":["cc-api-provider.ts"],"names":[],"mappings":"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","sourcesContent":["import type { CcApiContextQuery } from '@aws-cdk/cloud-assembly-schema';\nimport type { ResourceDescription } from '@aws-sdk/client-cloudcontrol';\nimport { ResourceNotFoundException } from '@aws-sdk/client-cloudcontrol';\nimport type { ICloudControlClient, SdkProvider } from '../api/aws-auth/private';\nimport { initContextProviderSdk } from '../api/aws-auth/private';\nimport type { ContextProviderPlugin } from '../api/plugin';\nimport { ContextProviderError, NoResultsFoundError } from '../toolkit/toolkit-error';\nimport { findJsonValue, getResultObj } from '../util';\n\nexport class CcApiContextProviderPlugin implements ContextProviderPlugin {\n  constructor(private readonly aws: SdkProvider) {\n  }\n\n  /**\n   * This returns a data object with the value from CloudControl API result.\n   *\n   * See the documentation in the Cloud Assembly Schema for the semantics of\n   * each query parameter.\n   */\n  public async getValue(args: CcApiContextQuery) {\n    // Validate input\n    if (args.exactIdentifier && args.propertyMatch) {\n      throw new ContextProviderError(`Provider protocol error: specify either exactIdentifier or propertyMatch, but not both (got ${JSON.stringify(args)})`);\n    }\n    if (args.ignoreErrorOnMissingContext && args.dummyValue === undefined) {\n      throw new ContextProviderError(`Provider protocol error: if ignoreErrorOnMissingContext is set, a dummyValue must be supplied (got ${JSON.stringify(args)})`);\n    }\n    if (args.dummyValue !== undefined && (!Array.isArray(args.dummyValue) || !args.dummyValue.every(isObject))) {\n      throw new ContextProviderError(`Provider protocol error: dummyValue must be an array of objects (got ${JSON.stringify(args.dummyValue)})`);\n    }\n\n    // Do the lookup\n    const cloudControl = (await initContextProviderSdk(this.aws, args)).cloudControl();\n\n    try {\n      let resources: FoundResource[];\n      if (args.exactIdentifier) {\n        // use getResource to get the exact identifier\n        resources = await this.getResource(cloudControl, args.typeName, args.exactIdentifier);\n      } else if (args.propertyMatch) {\n        // use listResource\n        resources = await this.listResources(cloudControl, args.typeName, args.propertyMatch, args.expectedMatchCount);\n      } else {\n        throw new ContextProviderError(`Provider protocol error: neither exactIdentifier nor propertyMatch is specified in ${JSON.stringify(args)}.`);\n      }\n\n      return resources.map((r) => getResultObj(r.properties, r.identifier, args.propertiesToReturn));\n    } catch (err) {\n      if (ContextProviderError.isNoResultsFoundError(err) && args.ignoreErrorOnMissingContext) {\n        // We've already type-checked dummyValue.\n        return args.dummyValue;\n      }\n      throw err;\n    }\n  }\n\n  /**\n   * Calls getResource from CC API to get the resource.\n   * See https://docs.aws.amazon.com/cli/latest/reference/cloudcontrol/get-resource.html\n   *\n   * Will always return exactly one resource, or fail.\n   */\n  private async getResource(\n    cc: ICloudControlClient,\n    typeName: string,\n    exactIdentifier: string,\n  ): Promise<FoundResource[]> {\n    try {\n      const result = await cc.getResource({\n        TypeName: typeName,\n        Identifier: exactIdentifier,\n      });\n      if (!result.ResourceDescription) {\n        throw new ContextProviderError('Unexpected CloudControl API behavior: returned empty response');\n      }\n\n      return [foundResourceFromCcApi(result.ResourceDescription)];\n    } catch (err: any) {\n      if (err instanceof ResourceNotFoundException || (err as any).name === 'ResourceNotFoundException') {\n        throw new NoResultsFoundError(`No resource of type ${typeName} with identifier: ${exactIdentifier}`);\n      }\n      if (!ContextProviderError.isContextProviderError(err)) {\n        throw ContextProviderError.withCause(`Encountered CC API error while getting ${typeName} resource ${exactIdentifier}`, err);\n      }\n      throw err;\n    }\n  }\n\n  /**\n   * Calls listResources from CC API to get the resources and apply args.propertyMatch to find the resources.\n   * See https://docs.aws.amazon.com/cli/latest/reference/cloudcontrol/list-resources.html\n   *\n   * Will return 0 or more resources.\n   *\n   * Does not currently paginate through more than one result page.\n   */\n  private async listResources(\n    cc: ICloudControlClient,\n    typeName: string,\n    propertyMatch: Record<string, unknown>,\n    expectedMatchCount?: CcApiContextQuery['expectedMatchCount'],\n  ): Promise<FoundResource[]> {\n    try {\n      const found: FoundResource[] = [];\n      let nextToken: string | undefined = undefined;\n\n      do {\n        const result = await cc.listResources({\n          TypeName: typeName,\n          MaxResults: 100,\n          ...nextToken ? { NextToken: nextToken } : {},\n        });\n\n        found.push(\n          ...(result.ResourceDescriptions ?? [])\n            .map(foundResourceFromCcApi)\n            .filter((r) => {\n              return Object.entries(propertyMatch).every(([propPath, expected]) => {\n                const actual = findJsonValue(r.properties, propPath);\n                return propertyMatchesFilter(actual, expected);\n              });\n            }),\n        );\n\n        nextToken = result.NextToken;\n\n        // This allows us to error out early, before we have consumed all pages.\n        if ((expectedMatchCount === 'at-most-one' || expectedMatchCount === 'exactly-one') && found.length > 1) {\n          const atLeast = nextToken ? 'at least ' : '';\n          throw new ContextProviderError(`Found ${atLeast}${found.length} resources matching ${JSON.stringify(propertyMatch)}; expected ${expectedMatchCountText(expectedMatchCount)}. Please narrow the search criteria`);\n        }\n      } while (nextToken);\n\n      if ((expectedMatchCount === 'at-least-one' || expectedMatchCount === 'exactly-one') && found.length === 0) {\n        throw new NoResultsFoundError(`Could not find any resources matching ${JSON.stringify(propertyMatch)}; expected ${expectedMatchCountText(expectedMatchCount)}.`);\n      }\n\n      return found;\n    } catch (err: any) {\n      if (!ContextProviderError.isContextProviderError(err)) {\n        throw ContextProviderError.withCause(`Encountered CC API error while listing ${typeName} resources matching ${JSON.stringify(propertyMatch)}`, err);\n      }\n      throw err;\n    }\n  }\n}\n\n/**\n * Convert a CC API response object into a nicer object (parse the JSON)\n */\nfunction foundResourceFromCcApi(desc: ResourceDescription): FoundResource {\n  return {\n    identifier: desc.Identifier ?? '*MISSING*',\n    properties: JSON.parse(desc.Properties ?? '{}'),\n  };\n}\n\n/**\n * Whether the given property value matches the given filter\n *\n * For now we just check for strict equality, but we can implement pattern matching and fuzzy matching here later\n */\nfunction propertyMatchesFilter(actual: unknown, expected: unknown) {\n  return expected === actual;\n}\n\nfunction isObject(x: unknown): x is { [key: string]: unknown } {\n  return typeof x === 'object' && x !== null && !Array.isArray(x);\n}\n\nfunction expectedMatchCountText(expectation: NonNullable<CcApiContextQuery['expectedMatchCount']>): string {\n  switch (expectation) {\n    case 'at-least-one':\n      return 'at least one';\n    case 'at-most-one':\n      return 'at most one';\n    case 'exactly-one':\n      return 'exactly one';\n    case 'any':\n      return 'any number';\n    default:\n      return expectation;\n  }\n}\n\n/**\n * A parsed version of the return value from CCAPI\n */\ninterface FoundResource {\n  readonly identifier: string;\n  readonly properties: Record<string, unknown>;\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cc-api-provider.js","sourceRoot":"","sources":["cc-api-provider.ts"],"names":[],"mappings":"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","sourcesContent":["import type { CcApiContextQuery } from '@aws-cdk/cloud-assembly-schema';\nimport type { ResourceDescription } from '@aws-sdk/client-cloudcontrol';\nimport { ResourceNotFoundException } from '@aws-sdk/client-cloudcontrol';\nimport type { ICloudControlClient, SdkProvider } from '../api/aws-auth/private';\nimport { initContextProviderSdk } from '../api/aws-auth/private';\nimport type { ContextProviderPlugin } from '../api/plugin';\nimport { ContextProviderError, NoResultsFoundError } from '../toolkit/toolkit-error';\nimport { findJsonValue, getResultObj } from '../util';\n\nexport class CcApiContextProviderPlugin implements ContextProviderPlugin {\n  constructor(private readonly aws: SdkProvider) {\n  }\n\n  /**\n   * This returns a data object with the value from CloudControl API result.\n   *\n   * See the documentation in the Cloud Assembly Schema for the semantics of\n   * each query parameter.\n   */\n  public async getValue(args: CcApiContextQuery) {\n    // Validate input\n    if (args.exactIdentifier && args.propertyMatch) {\n      throw new ContextProviderError(`Provider protocol error: specify either exactIdentifier or propertyMatch, but not both (got ${JSON.stringify(args)})`);\n    }\n    if (args.ignoreErrorOnMissingContext && args.dummyValue === undefined) {\n      throw new ContextProviderError(`Provider protocol error: if ignoreErrorOnMissingContext is set, a dummyValue must be supplied (got ${JSON.stringify(args)})`);\n    }\n    if (args.dummyValue !== undefined && (!Array.isArray(args.dummyValue) || !args.dummyValue.every(isObject))) {\n      throw new ContextProviderError(`Provider protocol error: dummyValue must be an array of objects (got ${JSON.stringify(args.dummyValue)})`);\n    }\n\n    // Do the lookup\n    const cloudControl = (await initContextProviderSdk(this.aws, args)).cloudControl();\n\n    try {\n      let resources: FoundResource[];\n      if (args.exactIdentifier) {\n        // use getResource to get the exact identifier\n        resources = await this.getResource(cloudControl, args.typeName, args.exactIdentifier);\n      } else if (args.propertyMatch) {\n        // use listResource\n        resources = await this.listResources(cloudControl, args.typeName, args.propertyMatch, args.expectedMatchCount, args.resourceModel);\n      } else {\n        throw new ContextProviderError(`Provider protocol error: neither exactIdentifier nor propertyMatch is specified in ${JSON.stringify(args)}.`);\n      }\n\n      return resources.map((r) => getResultObj(r.properties, r.identifier, args.propertiesToReturn));\n    } catch (err) {\n      if (ContextProviderError.isNoResultsFoundError(err) && args.ignoreErrorOnMissingContext) {\n        // We've already type-checked dummyValue.\n        return args.dummyValue;\n      }\n      throw err;\n    }\n  }\n\n  /**\n   * Calls getResource from CC API to get the resource.\n   * See https://docs.aws.amazon.com/cli/latest/reference/cloudcontrol/get-resource.html\n   *\n   * Will always return exactly one resource, or fail.\n   */\n  private async getResource(\n    cc: ICloudControlClient,\n    typeName: string,\n    exactIdentifier: string,\n  ): Promise<FoundResource[]> {\n    try {\n      const result = await cc.getResource({\n        TypeName: typeName,\n        Identifier: exactIdentifier,\n      });\n      if (!result.ResourceDescription) {\n        throw new ContextProviderError('Unexpected CloudControl API behavior: returned empty response');\n      }\n\n      return [foundResourceFromCcApi(result.ResourceDescription)];\n    } catch (err: any) {\n      if (err instanceof ResourceNotFoundException || (err as any).name === 'ResourceNotFoundException') {\n        throw new NoResultsFoundError(`No resource of type ${typeName} with identifier: ${exactIdentifier}`);\n      }\n      if (!ContextProviderError.isContextProviderError(err)) {\n        throw ContextProviderError.withCause(`Encountered CC API error while getting ${typeName} resource ${exactIdentifier}`, err);\n      }\n      throw err;\n    }\n  }\n\n  /**\n   * Calls listResources from CC API to get the resources and apply args.propertyMatch to find the resources.\n   * See https://docs.aws.amazon.com/cli/latest/reference/cloudcontrol/list-resources.html\n   *\n   * Will return 0 or more resources.\n   *\n   * Does not currently paginate through more than one result page.\n   */\n  private async listResources(\n    cc: ICloudControlClient,\n    typeName: string,\n    propertyMatch: Record<string, unknown>,\n    expectedMatchCount?: CcApiContextQuery['expectedMatchCount'],\n    resourceModel?: Record<string, unknown>,\n  ): Promise<FoundResource[]> {\n    try {\n      const found: FoundResource[] = [];\n      let nextToken: string | undefined = undefined;\n      const resourceModelJSON: string | undefined = resourceModel ? JSON.stringify(resourceModel) : undefined;\n\n      do {\n        const result = await cc.listResources({\n          TypeName: typeName,\n          ResourceModel: resourceModelJSON,\n          MaxResults: 100,\n          ...nextToken ? { NextToken: nextToken } : {},\n        });\n\n        found.push(\n          ...(result.ResourceDescriptions ?? [])\n            .map(foundResourceFromCcApi)\n            .filter((r) => {\n              return Object.entries(propertyMatch).every(([propPath, expected]) => {\n                const actual = findJsonValue(r.properties, propPath);\n                return propertyMatchesFilter(actual, expected);\n              });\n            }),\n        );\n\n        nextToken = result.NextToken;\n\n        // This allows us to error out early, before we have consumed all pages.\n        if ((expectedMatchCount === 'at-most-one' || expectedMatchCount === 'exactly-one') && found.length > 1) {\n          const atLeast = nextToken ? 'at least ' : '';\n          throw new ContextProviderError(`Found ${atLeast}${found.length} resources matching ${JSON.stringify(propertyMatch)}; expected ${expectedMatchCountText(expectedMatchCount)}. Please narrow the search criteria`);\n        }\n      } while (nextToken);\n\n      if ((expectedMatchCount === 'at-least-one' || expectedMatchCount === 'exactly-one') && found.length === 0) {\n        throw new NoResultsFoundError(`Could not find any resources matching ${JSON.stringify(propertyMatch)}; expected ${expectedMatchCountText(expectedMatchCount)}.`);\n      }\n\n      return found;\n    } catch (err: any) {\n      if (!ContextProviderError.isContextProviderError(err)) {\n        throw ContextProviderError.withCause(`Encountered CC API error while listing ${typeName} resources matching ${JSON.stringify(propertyMatch)}`, err);\n      }\n      throw err;\n    }\n  }\n}\n\n/**\n * Convert a CC API response object into a nicer object (parse the JSON)\n */\nfunction foundResourceFromCcApi(desc: ResourceDescription): FoundResource {\n  return {\n    identifier: desc.Identifier ?? '*MISSING*',\n    properties: JSON.parse(desc.Properties ?? '{}'),\n  };\n}\n\n/**\n * Whether the given property value matches the given filter\n *\n * For now we just check for strict equality, but we can implement pattern matching and fuzzy matching here later\n */\nfunction propertyMatchesFilter(actual: unknown, expected: unknown) {\n  return expected === actual;\n}\n\nfunction isObject(x: unknown): x is { [key: string]: unknown } {\n  return typeof x === 'object' && x !== null && !Array.isArray(x);\n}\n\nfunction expectedMatchCountText(expectation: NonNullable<CcApiContextQuery['expectedMatchCount']>): string {\n  switch (expectation) {\n    case 'at-least-one':\n      return 'at least one';\n    case 'at-most-one':\n      return 'at most one';\n    case 'exactly-one':\n      return 'exactly one';\n    case 'any':\n      return 'any number';\n    default:\n      return expectation;\n  }\n}\n\n/**\n * A parsed version of the return value from CCAPI\n */\ninterface FoundResource {\n  readonly identifier: string;\n  readonly properties: Record<string, unknown>;\n}\n"]}

package/lib/context-providers/ssm-parameters.d.ts

@@ -11,7 +11,7 @@ export declare class SSMContextProviderPlugin implements ContextProviderPlugin {
     constructor(aws: SdkProvider, io: IContextProviderMessages);
     getValue(args: SSMParameterContextQuery): Promise<unknown>;
     /**
-     * Gets the value of an SSM Parameter, while not throwin if the parameter does not exist.
+     * Gets the value of an SSM Parameter, while not thrown if the parameter does not exist.
      * @param account       - the account in which the SSM Parameter is expected to be.
      * @param region        - the region in which the SSM Parameter is expected to be.
      * @param parameterName - the name of the SSM Parameter

package/lib/context-providers/ssm-parameters.js

@@ -34,7 +34,7 @@ class SSMContextProviderPlugin {
         return response.Parameter.Value;
     }
     /**
-     * Gets the value of an SSM Parameter, while not throwin if the parameter does not exist.
+     * Gets the value of an SSM Parameter, while not thrown if the parameter does not exist.
      * @param account       - the account in which the SSM Parameter is expected to be.
      * @param region        - the region in which the SSM Parameter is expected to be.
      * @param parameterName - the name of the SSM Parameter
@@ -58,4 +58,4 @@ class SSMContextProviderPlugin {
     }
 }
 exports.SSMContextProviderPlugin = SSMContextProviderPlugin;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3NtLXBhcmFtZXRlcnMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJzc20tcGFyYW1ldGVycy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFHQSxxREFBbUY7QUFFbkYsNERBQWdFO0FBRWhFOztHQUVHO0FBQ0gsTUFBYSx3QkFBd0I7SUFDTjtJQUFtQztJQUFoRSxZQUE2QixHQUFnQixFQUFtQixFQUE0QjtRQUEvRCxRQUFHLEdBQUgsR0FBRyxDQUFhO1FBQW1CLE9BQUUsR0FBRixFQUFFLENBQTBCO0lBQzVGLENBQUM7SUFFTSxLQUFLLENBQUMsUUFBUSxDQUFDLElBQThCO1FBQ2xELE1BQU0sTUFBTSxHQUFHLElBQUksQ0FBQyxNQUFNLENBQUM7UUFDM0IsTUFBTSxPQUFPLEdBQUcsSUFBSSxDQUFDLE9BQU8sQ0FBQztRQUU3QixJQUFJLENBQUMsQ0FBQyxlQUFlLElBQUksSUFBSSxDQUFDLEVBQUUsQ0FBQztZQUMvQixNQUFNLElBQUksb0NBQW9CLENBQUMsc0VBQXNFLENBQUMsQ0FBQztRQUN6RyxDQUFDO1FBQ0QsTUFBTSxhQUFhLEdBQUcsSUFBSSxDQUFDLGFBQWEsQ0FBQztRQUN6QyxNQUFNLElBQUksQ0FBQyxFQUFFLENBQUMsS0FBSyxDQUFDLHlCQUF5QixPQUFPLElBQUksTUFBTSxJQUFJLGFBQWEsRUFBRSxDQUFDLENBQUM7UUFFbkYsTUFBTSxRQUFRLEdBQUcsTUFBTSxJQUFJLENBQUMsb0JBQW9CLENBQUMsSUFBSSxDQUFDLENBQUM7UUFDdkQsTUFBTSxpQkFBaUIsR0FBWSxDQUFDLFFBQVEsQ0FBQyxTQUFTLElBQUksUUFBUSxDQUFDLFNBQVMsQ0FBQyxLQUFLLEtBQUssU0FBUyxDQUFDO1FBQ2pHLE1BQU0sYUFBYSxHQUFHLDZCQUE2QixJQUFJLElBQUksSUFBSyxJQUFJLENBQUMsMkJBQXVDLENBQUM7UUFDN0csSUFBSSxpQkFBaUIsSUFBSSxhQUFhLElBQUksWUFBWSxJQUFJLElBQUksRUFBRSxDQUFDO1lBQy9ELE9BQU8sSUFBSSxDQUFDLFVBQVUsQ0FBQztRQUN6QixDQUFDO1FBQ0QsSUFBSSxpQkFBaUIsRUFBRSxDQUFDO1lBQ3RCLE1BQU0sSUFBSSxvQ0FBb0IsQ0FBQywwQ0FBMEMsT0FBTyxZQUFZLE1BQU0sS0FBSyxhQUFhLEVBQUUsQ0FBQyxDQUFDO1FBQzFILENBQUM7UUFDRCxvRUFBb0U7UUFDcEUsT0FBTyxRQUFRLENBQUMsU0FBVSxDQUFDLEtBQUssQ0FBQztJQUNuQyxDQUFDO0lBRUQ7Ozs7Ozs7Ozs7T0FVRztJQUNLLEtBQUssQ0FBQyxvQkFBb0IsQ0FBQyxJQUE4QjtRQUMvRCxNQUFNLEdBQUcsR0FBRyxDQUFDLE1BQU0sSUFBQSxnQ0FBc0IsRUFBQyxJQUFJLENBQUMsR0FBRyxFQUFFLElBQUksQ0FBQyxDQUFDLENBQUMsR0FBRyxFQUFFLENBQUM7UUFDakUsSUFBSSxDQUFDO1lBQ0gsT0FBTyxNQUFNLEdBQUcsQ0FBQyxZQUFZLENBQUMsRUFBRSxJQUFJLEVBQUUsSUFBSSxDQUFDLGFBQWEsRUFBRSxDQUFDLENBQUM7UUFDOUQsQ0FBQztRQUFDLE9BQU8sQ0FBTSxFQUFFLENBQUM7WUFDaEIsSUFBSSxDQUFDLENBQUMsSUFBSSxLQUFLLG1CQUFtQixFQUFFLENBQUM7Z0JBQ25DLE9BQU8sRUFBRSxTQUFTLEVBQUUsRUFBRSxFQUFFLENBQUM7WUFDM0IsQ0FBQztZQUNELE1BQU0sQ0FBQyxDQUFDO1FBQ1YsQ0FBQztJQUNILENBQUM7Q0FDRjtBQWpERCw0REFpREMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgdHlwZSB7IFNTTVBhcmFtZXRlckNvbnRleHRRdWVyeSB9IGZyb20gJ0Bhd3MtY2RrL2Nsb3VkLWFzc2VtYmx5LXNjaGVtYSc7XG5pbXBvcnQgdHlwZSB7IEdldFBhcmFtZXRlckNvbW1hbmRPdXRwdXQgfSBmcm9tICdAYXdzLXNkay9jbGllbnQtc3NtJztcbmltcG9ydCB0eXBlIHsgSUNvbnRleHRQcm92aWRlck1lc3NhZ2VzIH0gZnJvbSAnLic7XG5pbXBvcnQgeyB0eXBlIFNka1Byb3ZpZGVyLCBpbml0Q29udGV4dFByb3ZpZGVyU2RrIH0gZnJvbSAnLi4vYXBpL2F3cy1hdXRoL3ByaXZhdGUnO1xuaW1wb3J0IHR5cGUgeyBDb250ZXh0UHJvdmlkZXJQbHVnaW4gfSBmcm9tICcuLi9hcGkvcGx1Z2luJztcbmltcG9ydCB7IENvbnRleHRQcm92aWRlckVycm9yIH0gZnJvbSAnLi4vdG9vbGtpdC90b29sa2l0LWVycm9yJztcblxuLyoqXG4gKiBQbHVnaW4gdG8gcmVhZCBhcmJpdHJhcnkgU1NNIHBhcmFtZXRlciBuYW1lc1xuICovXG5leHBvcnQgY2xhc3MgU1NNQ29udGV4dFByb3ZpZGVyUGx1Z2luIGltcGxlbWVudHMgQ29udGV4dFByb3ZpZGVyUGx1Z2luIHtcbiAgY29uc3RydWN0b3IocHJpdmF0ZSByZWFkb25seSBhd3M6IFNka1Byb3ZpZGVyLCBwcml2YXRlIHJlYWRvbmx5IGlvOiBJQ29udGV4dFByb3ZpZGVyTWVzc2FnZXMpIHtcbiAgfVxuXG4gIHB1YmxpYyBhc3luYyBnZXRWYWx1ZShhcmdzOiBTU01QYXJhbWV0ZXJDb250ZXh0UXVlcnkpIHtcbiAgICBjb25zdCByZWdpb24gPSBhcmdzLnJlZ2lvbjtcbiAgICBjb25zdCBhY2NvdW50ID0gYXJncy5hY2NvdW50O1xuXG4gICAgaWYgKCEoJ3BhcmFtZXRlck5hbWUnIGluIGFyZ3MpKSB7XG4gICAgICB0aHJvdyBuZXcgQ29udGV4dFByb3ZpZGVyRXJyb3IoJ3BhcmFtZXRlck5hbWUgbXVzdCBiZSBwcm92aWRlZCBpbiBwcm9wcyBmb3IgU1NNQ29udGV4dFByb3ZpZGVyUGx1Z2luJyk7XG4gICAgfVxuICAgIGNvbnN0IHBhcmFtZXRlck5hbWUgPSBhcmdzLnBhcmFtZXRlck5hbWU7XG4gICAgYXdhaXQgdGhpcy5pby5kZWJ1ZyhgUmVhZGluZyBTU00gcGFyYW1ldGVyICR7YWNjb3VudH06JHtyZWdpb259OiR7cGFyYW1ldGVyTmFtZX1gKTtcblxuICAgIGNvbnN0IHJlc3BvbnNlID0gYXdhaXQgdGhpcy5nZXRTc21QYXJhbWV0ZXJWYWx1ZShhcmdzKTtcbiAgICBjb25zdCBwYXJhbWV0ZXJOb3RGb3VuZDogYm9vbGVhbiA9ICFyZXNwb25zZS5QYXJhbWV0ZXIgfHwgcmVzcG9uc2UuUGFyYW1ldGVyLlZhbHVlID09PSB1bmRlZmluZWQ7XG4gICAgY29uc3Qgc3VwcHJlc3NFcnJvciA9ICdpZ25vcmVFcnJvck9uTWlzc2luZ0NvbnRleHQnIGluIGFyZ3MgJiYgKGFyZ3MuaWdub3JlRXJyb3JPbk1pc3NpbmdDb250ZXh0IGFzIGJvb2xlYW4pO1xuICAgIGlmIChwYXJhbWV0ZXJOb3RGb3VuZCAmJiBzdXBwcmVzc0Vycm9yICYmICdkdW1teVZhbHVlJyBpbiBhcmdzKSB7XG4gICAgICByZXR1cm4gYXJncy5kdW1teVZhbHVlO1xuICAgIH1cbiAgICBpZiAocGFyYW1ldGVyTm90Rm91bmQpIHtcbiAgICAgIHRocm93IG5ldyBDb250ZXh0UHJvdmlkZXJFcnJvcihgU1NNIHBhcmFtZXRlciBub3QgYXZhaWxhYmxlIGluIGFjY291bnQgJHthY2NvdW50fSwgcmVnaW9uICR7cmVnaW9ufTogJHtwYXJhbWV0ZXJOYW1lfWApO1xuICAgIH1cbiAgICAvLyB3aWxsIG5vdCBiZSB1bmRlZmluZWQgYmVjYXVzZSB3ZSd2ZSBoYW5kbGVkIHVuZGVmaW5lZCBjYXNlcyBhYm92ZVxuICAgIHJldHVybiByZXNwb25zZS5QYXJhbWV0ZXIhLlZhbHVlO1xuICB9XG5cbiAgLyoqXG4gICAqIEdldHMgdGhlIHZhbHVlIG9mIGFuIFNTTSBQYXJhbWV0ZXIsIHdoaWxlIG5vdCB0aHJvd2luIGlmIHRoZSBwYXJhbWV0ZXIgZG9lcyBub3QgZXhpc3QuXG4gICAqIEBwYXJhbSBhY2NvdW50ICAgICAgIC0gdGhlIGFjY291bnQgaW4gd2hpY2ggdGhlIFNTTSBQYXJhbWV0ZXIgaXMgZXhwZWN0ZWQgdG8gYmUuXG4gICAqIEBwYXJhbSByZWdpb24gICAgICAgIC0gdGhlIHJlZ2lvbiBpbiB3aGljaCB0aGUgU1NNIFBhcmFtZXRlciBpcyBleHBlY3RlZCB0byBiZS5cbiAgICogQHBhcmFtIHBhcmFtZXRlck5hbWUgLSB0aGUgbmFtZSBvZiB0aGUgU1NNIFBhcmFtZXRlclxuICAgKiBAcGFyYW0gbG9va3VwUm9sZUFybiAtIHRoZSBBUk4gb2YgdGhlIGxvb2t1cCByb2xlLlxuICAgKlxuICAgKiBAcmV0dXJucyB0aGUgcmVzdWx0IG9mIHRoZSBgYEdldFBhcmFtZXRlcmBgIG9wZXJhdGlvbi5cbiAgICpcbiAgICogQHRocm93cyBFcnJvciBpZiBhIHNlcnZpY2UgZXJyb3IgKG90aGVyIHRoYW4gYGBQYXJhbWV0ZXJOb3RGb3VuZGBgKSBvY2N1cnMuXG4gICAqL1xuICBwcml2YXRlIGFzeW5jIGdldFNzbVBhcmFtZXRlclZhbHVlKGFyZ3M6IFNTTVBhcmFtZXRlckNvbnRleHRRdWVyeSk6IFByb21pc2U8R2V0UGFyYW1ldGVyQ29tbWFuZE91dHB1dD4ge1xuICAgIGNvbnN0IHNzbSA9IChhd2FpdCBpbml0Q29udGV4dFByb3ZpZGVyU2RrKHRoaXMuYXdzLCBhcmdzKSkuc3NtKCk7XG4gICAgdHJ5IHtcbiAgICAgIHJldHVybiBhd2FpdCBzc20uZ2V0UGFyYW1ldGVyKHsgTmFtZTogYXJncy5wYXJhbWV0ZXJOYW1lIH0pO1xuICAgIH0gY2F0Y2ggKGU6IGFueSkge1xuICAgICAgaWYgKGUubmFtZSA9PT0gJ1BhcmFtZXRlck5vdEZvdW5kJykge1xuICAgICAgICByZXR1cm4geyAkbWV0YWRhdGE6IHt9IH07XG4gICAgICB9XG4gICAgICB0aHJvdyBlO1xuICAgIH1cbiAgfVxufVxuIl19
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3NtLXBhcmFtZXRlcnMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJzc20tcGFyYW1ldGVycy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFHQSxxREFBbUY7QUFFbkYsNERBQWdFO0FBRWhFOztHQUVHO0FBQ0gsTUFBYSx3QkFBd0I7SUFDTjtJQUFtQztJQUFoRSxZQUE2QixHQUFnQixFQUFtQixFQUE0QjtRQUEvRCxRQUFHLEdBQUgsR0FBRyxDQUFhO1FBQW1CLE9BQUUsR0FBRixFQUFFLENBQTBCO0lBQzVGLENBQUM7SUFFTSxLQUFLLENBQUMsUUFBUSxDQUFDLElBQThCO1FBQ2xELE1BQU0sTUFBTSxHQUFHLElBQUksQ0FBQyxNQUFNLENBQUM7UUFDM0IsTUFBTSxPQUFPLEdBQUcsSUFBSSxDQUFDLE9BQU8sQ0FBQztRQUU3QixJQUFJLENBQUMsQ0FBQyxlQUFlLElBQUksSUFBSSxDQUFDLEVBQUUsQ0FBQztZQUMvQixNQUFNLElBQUksb0NBQW9CLENBQUMsc0VBQXNFLENBQUMsQ0FBQztRQUN6RyxDQUFDO1FBQ0QsTUFBTSxhQUFhLEdBQUcsSUFBSSxDQUFDLGFBQWEsQ0FBQztRQUN6QyxNQUFNLElBQUksQ0FBQyxFQUFFLENBQUMsS0FBSyxDQUFDLHlCQUF5QixPQUFPLElBQUksTUFBTSxJQUFJLGFBQWEsRUFBRSxDQUFDLENBQUM7UUFFbkYsTUFBTSxRQUFRLEdBQUcsTUFBTSxJQUFJLENBQUMsb0JBQW9CLENBQUMsSUFBSSxDQUFDLENBQUM7UUFDdkQsTUFBTSxpQkFBaUIsR0FBWSxDQUFDLFFBQVEsQ0FBQyxTQUFTLElBQUksUUFBUSxDQUFDLFNBQVMsQ0FBQyxLQUFLLEtBQUssU0FBUyxDQUFDO1FBQ2pHLE1BQU0sYUFBYSxHQUFHLDZCQUE2QixJQUFJLElBQUksSUFBSyxJQUFJLENBQUMsMkJBQXVDLENBQUM7UUFDN0csSUFBSSxpQkFBaUIsSUFBSSxhQUFhLElBQUksWUFBWSxJQUFJLElBQUksRUFBRSxDQUFDO1lBQy9ELE9BQU8sSUFBSSxDQUFDLFVBQVUsQ0FBQztRQUN6QixDQUFDO1FBQ0QsSUFBSSxpQkFBaUIsRUFBRSxDQUFDO1lBQ3RCLE1BQU0sSUFBSSxvQ0FBb0IsQ0FBQywwQ0FBMEMsT0FBTyxZQUFZLE1BQU0sS0FBSyxhQUFhLEVBQUUsQ0FBQyxDQUFDO1FBQzFILENBQUM7UUFDRCxvRUFBb0U7UUFDcEUsT0FBTyxRQUFRLENBQUMsU0FBVSxDQUFDLEtBQUssQ0FBQztJQUNuQyxDQUFDO0lBRUQ7Ozs7Ozs7Ozs7T0FVRztJQUNLLEtBQUssQ0FBQyxvQkFBb0IsQ0FBQyxJQUE4QjtRQUMvRCxNQUFNLEdBQUcsR0FBRyxDQUFDLE1BQU0sSUFBQSxnQ0FBc0IsRUFBQyxJQUFJLENBQUMsR0FBRyxFQUFFLElBQUksQ0FBQyxDQUFDLENBQUMsR0FBRyxFQUFFLENBQUM7UUFDakUsSUFBSSxDQUFDO1lBQ0gsT0FBTyxNQUFNLEdBQUcsQ0FBQyxZQUFZLENBQUMsRUFBRSxJQUFJLEVBQUUsSUFBSSxDQUFDLGFBQWEsRUFBRSxDQUFDLENBQUM7UUFDOUQsQ0FBQztRQUFDLE9BQU8sQ0FBTSxFQUFFLENBQUM7WUFDaEIsSUFBSSxDQUFDLENBQUMsSUFBSSxLQUFLLG1CQUFtQixFQUFFLENBQUM7Z0JBQ25DLE9BQU8sRUFBRSxTQUFTLEVBQUUsRUFBRSxFQUFFLENBQUM7WUFDM0IsQ0FBQztZQUNELE1BQU0sQ0FBQyxDQUFDO1FBQ1YsQ0FBQztJQUNILENBQUM7Q0FDRjtBQWpERCw0REFpREMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgdHlwZSB7IFNTTVBhcmFtZXRlckNvbnRleHRRdWVyeSB9IGZyb20gJ0Bhd3MtY2RrL2Nsb3VkLWFzc2VtYmx5LXNjaGVtYSc7XG5pbXBvcnQgdHlwZSB7IEdldFBhcmFtZXRlckNvbW1hbmRPdXRwdXQgfSBmcm9tICdAYXdzLXNkay9jbGllbnQtc3NtJztcbmltcG9ydCB0eXBlIHsgSUNvbnRleHRQcm92aWRlck1lc3NhZ2VzIH0gZnJvbSAnLic7XG5pbXBvcnQgeyB0eXBlIFNka1Byb3ZpZGVyLCBpbml0Q29udGV4dFByb3ZpZGVyU2RrIH0gZnJvbSAnLi4vYXBpL2F3cy1hdXRoL3ByaXZhdGUnO1xuaW1wb3J0IHR5cGUgeyBDb250ZXh0UHJvdmlkZXJQbHVnaW4gfSBmcm9tICcuLi9hcGkvcGx1Z2luJztcbmltcG9ydCB7IENvbnRleHRQcm92aWRlckVycm9yIH0gZnJvbSAnLi4vdG9vbGtpdC90b29sa2l0LWVycm9yJztcblxuLyoqXG4gKiBQbHVnaW4gdG8gcmVhZCBhcmJpdHJhcnkgU1NNIHBhcmFtZXRlciBuYW1lc1xuICovXG5leHBvcnQgY2xhc3MgU1NNQ29udGV4dFByb3ZpZGVyUGx1Z2luIGltcGxlbWVudHMgQ29udGV4dFByb3ZpZGVyUGx1Z2luIHtcbiAgY29uc3RydWN0b3IocHJpdmF0ZSByZWFkb25seSBhd3M6IFNka1Byb3ZpZGVyLCBwcml2YXRlIHJlYWRvbmx5IGlvOiBJQ29udGV4dFByb3ZpZGVyTWVzc2FnZXMpIHtcbiAgfVxuXG4gIHB1YmxpYyBhc3luYyBnZXRWYWx1ZShhcmdzOiBTU01QYXJhbWV0ZXJDb250ZXh0UXVlcnkpIHtcbiAgICBjb25zdCByZWdpb24gPSBhcmdzLnJlZ2lvbjtcbiAgICBjb25zdCBhY2NvdW50ID0gYXJncy5hY2NvdW50O1xuXG4gICAgaWYgKCEoJ3BhcmFtZXRlck5hbWUnIGluIGFyZ3MpKSB7XG4gICAgICB0aHJvdyBuZXcgQ29udGV4dFByb3ZpZGVyRXJyb3IoJ3BhcmFtZXRlck5hbWUgbXVzdCBiZSBwcm92aWRlZCBpbiBwcm9wcyBmb3IgU1NNQ29udGV4dFByb3ZpZGVyUGx1Z2luJyk7XG4gICAgfVxuICAgIGNvbnN0IHBhcmFtZXRlck5hbWUgPSBhcmdzLnBhcmFtZXRlck5hbWU7XG4gICAgYXdhaXQgdGhpcy5pby5kZWJ1ZyhgUmVhZGluZyBTU00gcGFyYW1ldGVyICR7YWNjb3VudH06JHtyZWdpb259OiR7cGFyYW1ldGVyTmFtZX1gKTtcblxuICAgIGNvbnN0IHJlc3BvbnNlID0gYXdhaXQgdGhpcy5nZXRTc21QYXJhbWV0ZXJWYWx1ZShhcmdzKTtcbiAgICBjb25zdCBwYXJhbWV0ZXJOb3RGb3VuZDogYm9vbGVhbiA9ICFyZXNwb25zZS5QYXJhbWV0ZXIgfHwgcmVzcG9uc2UuUGFyYW1ldGVyLlZhbHVlID09PSB1bmRlZmluZWQ7XG4gICAgY29uc3Qgc3VwcHJlc3NFcnJvciA9ICdpZ25vcmVFcnJvck9uTWlzc2luZ0NvbnRleHQnIGluIGFyZ3MgJiYgKGFyZ3MuaWdub3JlRXJyb3JPbk1pc3NpbmdDb250ZXh0IGFzIGJvb2xlYW4pO1xuICAgIGlmIChwYXJhbWV0ZXJOb3RGb3VuZCAmJiBzdXBwcmVzc0Vycm9yICYmICdkdW1teVZhbHVlJyBpbiBhcmdzKSB7XG4gICAgICByZXR1cm4gYXJncy5kdW1teVZhbHVlO1xuICAgIH1cbiAgICBpZiAocGFyYW1ldGVyTm90Rm91bmQpIHtcbiAgICAgIHRocm93IG5ldyBDb250ZXh0UHJvdmlkZXJFcnJvcihgU1NNIHBhcmFtZXRlciBub3QgYXZhaWxhYmxlIGluIGFjY291bnQgJHthY2NvdW50fSwgcmVnaW9uICR7cmVnaW9ufTogJHtwYXJhbWV0ZXJOYW1lfWApO1xuICAgIH1cbiAgICAvLyB3aWxsIG5vdCBiZSB1bmRlZmluZWQgYmVjYXVzZSB3ZSd2ZSBoYW5kbGVkIHVuZGVmaW5lZCBjYXNlcyBhYm92ZVxuICAgIHJldHVybiByZXNwb25zZS5QYXJhbWV0ZXIhLlZhbHVlO1xuICB9XG5cbiAgLyoqXG4gICAqIEdldHMgdGhlIHZhbHVlIG9mIGFuIFNTTSBQYXJhbWV0ZXIsIHdoaWxlIG5vdCB0aHJvd24gaWYgdGhlIHBhcmFtZXRlciBkb2VzIG5vdCBleGlzdC5cbiAgICogQHBhcmFtIGFjY291bnQgICAgICAgLSB0aGUgYWNjb3VudCBpbiB3aGljaCB0aGUgU1NNIFBhcmFtZXRlciBpcyBleHBlY3RlZCB0byBiZS5cbiAgICogQHBhcmFtIHJlZ2lvbiAgICAgICAgLSB0aGUgcmVnaW9uIGluIHdoaWNoIHRoZSBTU00gUGFyYW1ldGVyIGlzIGV4cGVjdGVkIHRvIGJlLlxuICAgKiBAcGFyYW0gcGFyYW1ldGVyTmFtZSAtIHRoZSBuYW1lIG9mIHRoZSBTU00gUGFyYW1ldGVyXG4gICAqIEBwYXJhbSBsb29rdXBSb2xlQXJuIC0gdGhlIEFSTiBvZiB0aGUgbG9va3VwIHJvbGUuXG4gICAqXG4gICAqIEByZXR1cm5zIHRoZSByZXN1bHQgb2YgdGhlIGBgR2V0UGFyYW1ldGVyYGAgb3BlcmF0aW9uLlxuICAgKlxuICAgKiBAdGhyb3dzIEVycm9yIGlmIGEgc2VydmljZSBlcnJvciAob3RoZXIgdGhhbiBgYFBhcmFtZXRlck5vdEZvdW5kYGApIG9jY3Vycy5cbiAgICovXG4gIHByaXZhdGUgYXN5bmMgZ2V0U3NtUGFyYW1ldGVyVmFsdWUoYXJnczogU1NNUGFyYW1ldGVyQ29udGV4dFF1ZXJ5KTogUHJvbWlzZTxHZXRQYXJhbWV0ZXJDb21tYW5kT3V0cHV0PiB7XG4gICAgY29uc3Qgc3NtID0gKGF3YWl0IGluaXRDb250ZXh0UHJvdmlkZXJTZGsodGhpcy5hd3MsIGFyZ3MpKS5zc20oKTtcbiAgICB0cnkge1xuICAgICAgcmV0dXJuIGF3YWl0IHNzbS5nZXRQYXJhbWV0ZXIoeyBOYW1lOiBhcmdzLnBhcmFtZXRlck5hbWUgfSk7XG4gICAgfSBjYXRjaCAoZTogYW55KSB7XG4gICAgICBpZiAoZS5uYW1lID09PSAnUGFyYW1ldGVyTm90Rm91bmQnKSB7XG4gICAgICAgIHJldHVybiB7ICRtZXRhZGF0YToge30gfTtcbiAgICAgIH1cbiAgICAgIHRocm93IGU7XG4gICAgfVxuICB9XG59XG4iXX0=

package/package.json

@@ -79,7 +79,7 @@
   },
   "dependencies": {
     "@aws-cdk/cdk-assets-lib": "^1",
-    "@aws-cdk/cloud-assembly-schema": ">=49.4.0",
+    "@aws-cdk/cloud-assembly-schema": ">=50.0.0",
     "@aws-cdk/cloudformation-diff": "^2",
     "@aws-cdk/cx-api": "^2",
     "@aws-sdk/client-appsync": "^3",
@@ -136,7 +136,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "1.12.4",
+  "version": "1.13.0",
   "types": "lib/index.d.ts",
   "exports": {
     ".": {