@aws-cdk/toolkit-lib 0.3.2 → 0.3.4

package/lib/api/bootstrap/bootstrap-props.d.ts

@@ -0,0 +1,130 @@
+import type { BootstrapSource } from './bootstrap-environment';
+import type { StringWithoutPlaceholders } from '../environment';
+import type { Tag } from '../tags';
+export declare const BUCKET_NAME_OUTPUT = "BucketName";
+export declare const REPOSITORY_NAME_OUTPUT = "ImageRepositoryName";
+export declare const BUCKET_DOMAIN_NAME_OUTPUT = "BucketDomainName";
+export declare const BOOTSTRAP_VERSION_OUTPUT = "BootstrapVersion";
+export declare const BOOTSTRAP_VERSION_RESOURCE = "CdkBootstrapVersion";
+export declare const BOOTSTRAP_VARIANT_PARAMETER = "BootstrapVariant";
+/**
+ * The assumed vendor of a template in case it is not set
+ */
+export declare const DEFAULT_BOOTSTRAP_VARIANT = "AWS CDK: Default Resources";
+/**
+ * Options for the bootstrapEnvironment operation(s)
+ */
+export interface BootstrapEnvironmentOptions {
+    readonly toolkitStackName?: string;
+    readonly roleArn?: StringWithoutPlaceholders;
+    readonly parameters?: BootstrappingParameters;
+    readonly forceDeployment?: boolean;
+    /**
+     * The source of the bootstrap stack
+     *
+     * @default - modern v2-style bootstrapping
+     */
+    readonly source?: BootstrapSource;
+    /**
+     * Whether to execute the changeset or only create it and leave it in review.
+     * @default true
+     */
+    readonly execute?: boolean;
+    /**
+     * Tags for cdktoolkit stack.
+     *
+     * @default - None.
+     */
+    readonly tags?: Tag[];
+    /**
+     * Whether the stacks created by the bootstrap process should be protected from termination.
+     * @see https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-cfn-protect-stacks.html
+     * @default true
+     */
+    readonly terminationProtection?: boolean;
+    /**
+     * Use previous values for unspecified parameters
+     *
+     * If not set, all parameters must be specified for every deployment.
+     *
+     * @default true
+     */
+    usePreviousParameters?: boolean;
+}
+/**
+ * Parameters for the bootstrapping template
+ */
+export interface BootstrappingParameters {
+    /**
+     * The name to be given to the CDK Bootstrap bucket.
+     *
+     * @default - a name is generated by CloudFormation.
+     */
+    readonly bucketName?: string;
+    /**
+     * The ID of an existing KMS key to be used for encrypting items in the bucket.
+     *
+     * @default - use the default KMS key or create a custom one
+     */
+    readonly kmsKeyId?: string;
+    /**
+     * Whether or not to create a new customer master key (CMK)
+     *
+     * Only applies to modern bootstrapping. Legacy bootstrapping will never create
+     * a CMK, only use the default S3 key.
+     *
+     * @default false
+     */
+    readonly createCustomerMasterKey?: boolean;
+    /**
+     * The list of AWS account IDs that are trusted to deploy into the environment being bootstrapped.
+     *
+     * @default - only the bootstrapped account can deploy into this environment
+     */
+    readonly trustedAccounts?: string[];
+    /**
+     * The list of AWS account IDs that are trusted to look up values in the environment being bootstrapped.
+     *
+     * @default - only the bootstrapped account can look up values in this environment
+     */
+    readonly trustedAccountsForLookup?: string[];
+    /**
+     * The list of AWS account IDs that should not be trusted by the bootstrapped environment.
+     * If these accounts are already trusted, they will be removed on bootstrapping.
+     *
+     * @default - no account will be untrusted.
+     */
+    readonly untrustedAccounts?: string[];
+    /**
+     * The ARNs of the IAM managed policies that should be attached to the role performing CloudFormation deployments.
+     * In most cases, this will be the AdministratorAccess policy.
+     * At least one policy is required if `trustedAccounts` were passed.
+     *
+     * @default - the role will have no policies attached
+     */
+    readonly cloudFormationExecutionPolicies?: string[];
+    /**
+     * Identifier to distinguish multiple bootstrapped environments
+     *
+     * @default - Default qualifier
+     */
+    readonly qualifier?: string;
+    /**
+     * Whether or not to enable S3 Staging Bucket Public Access Block Configuration
+     *
+     * @default true
+     */
+    readonly publicAccessBlockConfiguration?: boolean;
+    /**
+     * Flag for using the default permissions boundary for bootstrapping
+     *
+     * @default - No value, optional argument
+     */
+    readonly examplePermissionsBoundary?: boolean;
+    /**
+     * Name for the customer's custom permissions boundary for bootstrapping
+     *
+     * @default - No value, optional argument
+     */
+    readonly customPermissionsBoundary?: string;
+}

package/lib/api/bootstrap/bootstrap-props.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_BOOTSTRAP_VARIANT = exports.BOOTSTRAP_VARIANT_PARAMETER = exports.BOOTSTRAP_VERSION_RESOURCE = exports.BOOTSTRAP_VERSION_OUTPUT = exports.BUCKET_DOMAIN_NAME_OUTPUT = exports.REPOSITORY_NAME_OUTPUT = exports.BUCKET_NAME_OUTPUT = void 0;
+exports.BUCKET_NAME_OUTPUT = 'BucketName';
+exports.REPOSITORY_NAME_OUTPUT = 'ImageRepositoryName';
+exports.BUCKET_DOMAIN_NAME_OUTPUT = 'BucketDomainName';
+exports.BOOTSTRAP_VERSION_OUTPUT = 'BootstrapVersion';
+exports.BOOTSTRAP_VERSION_RESOURCE = 'CdkBootstrapVersion';
+exports.BOOTSTRAP_VARIANT_PARAMETER = 'BootstrapVariant';
+/**
+ * The assumed vendor of a template in case it is not set
+ */
+exports.DEFAULT_BOOTSTRAP_VARIANT = 'AWS CDK: Default Resources';
+//# sourceMappingURL=data:application/json;base64,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

package/lib/api/bootstrap/deploy-bootstrap.d.ts

@@ -0,0 +1,39 @@
+import type { Environment } from '@aws-cdk/cx-api';
+import type { BootstrapEnvironmentOptions } from './bootstrap-props';
+import type { SDK, SdkProvider } from '../aws-auth/private';
+import type { SuccessfulDeployStackResult } from '../deployments';
+import { type IoHelper } from '../io/private';
+import { ToolkitInfo } from '../toolkit-info';
+/**
+ * A class to hold state around stack bootstrapping
+ *
+ * This class exists so we can break bootstrapping into 2 phases:
+ *
+ * ```ts
+ * const current = BootstrapStack.lookup(...);
+ * // ...
+ * current.update(newTemplate, ...);
+ * ```
+ *
+ * And do something in between the two phases (such as look at the
+ * current bootstrap stack and doing something intelligent).
+ */
+export declare class BootstrapStack {
+    private readonly sdkProvider;
+    private readonly sdk;
+    private readonly resolvedEnvironment;
+    private readonly toolkitStackName;
+    private readonly currentToolkitInfo;
+    private readonly ioHelper;
+    static lookup(sdkProvider: SdkProvider, environment: Environment, toolkitStackName: string, ioHelper: IoHelper): Promise<BootstrapStack>;
+    protected constructor(sdkProvider: SdkProvider, sdk: SDK, resolvedEnvironment: Environment, toolkitStackName: string, currentToolkitInfo: ToolkitInfo, ioHelper: IoHelper);
+    get parameters(): Record<string, string>;
+    get terminationProtection(): boolean | undefined;
+    partition(): Promise<string>;
+    /**
+     * Perform the actual deployment of a bootstrap stack, given a template and some parameters
+     */
+    update(template: any, parameters: Record<string, string | undefined>, options: Omit<BootstrapEnvironmentOptions, 'parameters'>): Promise<SuccessfulDeployStackResult>;
+}
+export declare function bootstrapVersionFromTemplate(template: any): number;
+export declare function bootstrapVariantFromTemplate(template: any): string;

package/lib/api/bootstrap/deploy-bootstrap.js

@@ -0,0 +1,147 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BootstrapStack = void 0;
+exports.bootstrapVersionFromTemplate = bootstrapVersionFromTemplate;
+exports.bootstrapVariantFromTemplate = bootstrapVariantFromTemplate;
+const os = require("os");
+const path = require("path");
+const cloud_assembly_schema_1 = require("@aws-cdk/cloud-assembly-schema");
+const cx_api_1 = require("@aws-cdk/cx-api");
+const fs = require("fs-extra");
+const bootstrap_props_1 = require("./bootstrap-props");
+const deployments_1 = require("../deployments");
+const deploy_stack_1 = require("../deployments/deploy-stack");
+const environment_1 = require("../environment");
+const private_1 = require("../io/private");
+const plugin_1 = require("../plugin");
+const toolkit_info_1 = require("../toolkit-info");
+/**
+ * A class to hold state around stack bootstrapping
+ *
+ * This class exists so we can break bootstrapping into 2 phases:
+ *
+ * ```ts
+ * const current = BootstrapStack.lookup(...);
+ * // ...
+ * current.update(newTemplate, ...);
+ * ```
+ *
+ * And do something in between the two phases (such as look at the
+ * current bootstrap stack and doing something intelligent).
+ */
+class BootstrapStack {
+    sdkProvider;
+    sdk;
+    resolvedEnvironment;
+    toolkitStackName;
+    currentToolkitInfo;
+    ioHelper;
+    static async lookup(sdkProvider, environment, toolkitStackName, ioHelper) {
+        toolkitStackName = toolkitStackName ?? toolkit_info_1.DEFAULT_TOOLKIT_STACK_NAME;
+        const resolvedEnvironment = await sdkProvider.resolveEnvironment(environment);
+        const sdk = (await sdkProvider.forEnvironment(resolvedEnvironment, plugin_1.Mode.ForWriting)).sdk;
+        const currentToolkitInfo = await toolkit_info_1.ToolkitInfo.lookup(resolvedEnvironment, sdk, ioHelper, toolkitStackName);
+        return new BootstrapStack(sdkProvider, sdk, resolvedEnvironment, toolkitStackName, currentToolkitInfo, ioHelper);
+    }
+    constructor(sdkProvider, sdk, resolvedEnvironment, toolkitStackName, currentToolkitInfo, ioHelper) {
+        this.sdkProvider = sdkProvider;
+        this.sdk = sdk;
+        this.resolvedEnvironment = resolvedEnvironment;
+        this.toolkitStackName = toolkitStackName;
+        this.currentToolkitInfo = currentToolkitInfo;
+        this.ioHelper = ioHelper;
+    }
+    get parameters() {
+        return this.currentToolkitInfo.found ? this.currentToolkitInfo.bootstrapStack.parameters : {};
+    }
+    get terminationProtection() {
+        return this.currentToolkitInfo.found ? this.currentToolkitInfo.bootstrapStack.terminationProtection : undefined;
+    }
+    async partition() {
+        return (await this.sdk.currentAccount()).partition;
+    }
+    /**
+     * Perform the actual deployment of a bootstrap stack, given a template and some parameters
+     */
+    async update(template, parameters, options) {
+        if (this.currentToolkitInfo.found && !options.forceDeployment) {
+            // Safety checks
+            const abortResponse = {
+                type: 'did-deploy-stack',
+                noOp: true,
+                outputs: {},
+                stackArn: this.currentToolkitInfo.bootstrapStack.stackId,
+            };
+            // Validate that the bootstrap stack we're trying to replace is from the same variant as the one we're trying to deploy
+            const currentVariant = this.currentToolkitInfo.variant;
+            const newVariant = bootstrapVariantFromTemplate(template);
+            if (currentVariant !== newVariant) {
+                await this.ioHelper.notify(private_1.IO.DEFAULT_TOOLKIT_WARN.msg(`Bootstrap stack already exists, containing '${currentVariant}'. Not overwriting it with a template containing '${newVariant}' (use --force if you intend to overwrite)`));
+                return abortResponse;
+            }
+            // Validate that we're not downgrading the bootstrap stack
+            const newVersion = bootstrapVersionFromTemplate(template);
+            const currentVersion = this.currentToolkitInfo.version;
+            if (newVersion < currentVersion) {
+                await this.ioHelper.notify(private_1.IO.DEFAULT_TOOLKIT_WARN.msg(`Bootstrap stack already at version ${currentVersion}. Not downgrading it to version ${newVersion} (use --force if you intend to downgrade)`));
+                if (newVersion === 0) {
+                    // A downgrade with 0 as target version means we probably have a new-style bootstrap in the account,
+                    // and an old-style bootstrap as current target, which means the user probably forgot to put this flag in.
+                    await this.ioHelper.notify(private_1.IO.DEFAULT_TOOLKIT_WARN.msg("(Did you set the '@aws-cdk/core:newStyleStackSynthesis' feature flag in cdk.json?)"));
+                }
+                return abortResponse;
+            }
+        }
+        const outdir = await fs.mkdtemp(path.join(os.tmpdir(), 'cdk-bootstrap'));
+        const builder = new cx_api_1.CloudAssemblyBuilder(outdir);
+        const templateFile = `${this.toolkitStackName}.template.json`;
+        await fs.writeJson(path.join(builder.outdir, templateFile), template, {
+            spaces: 2,
+        });
+        builder.addArtifact(this.toolkitStackName, {
+            type: cloud_assembly_schema_1.ArtifactType.AWS_CLOUDFORMATION_STACK,
+            environment: cx_api_1.EnvironmentUtils.format(this.resolvedEnvironment.account, this.resolvedEnvironment.region),
+            properties: {
+                templateFile,
+                terminationProtection: options.terminationProtection ?? false,
+            },
+        });
+        const assembly = builder.buildAssembly();
+        const ret = await (0, deploy_stack_1.deployStack)({
+            stack: assembly.getStackByName(this.toolkitStackName),
+            resolvedEnvironment: this.resolvedEnvironment,
+            sdk: this.sdk,
+            sdkProvider: this.sdkProvider,
+            forceDeployment: options.forceDeployment,
+            roleArn: options.roleArn,
+            tags: options.tags,
+            deploymentMethod: { method: 'change-set', execute: options.execute },
+            parameters,
+            usePreviousParameters: options.usePreviousParameters ?? true,
+            // Obviously we can't need a bootstrap stack to deploy a bootstrap stack
+            envResources: new environment_1.NoBootstrapStackEnvironmentResources(this.resolvedEnvironment, this.sdk, this.ioHelper),
+        }, this.ioHelper);
+        (0, deployments_1.assertIsSuccessfulDeployStackResult)(ret);
+        return ret;
+    }
+}
+exports.BootstrapStack = BootstrapStack;
+function bootstrapVersionFromTemplate(template) {
+    const versionSources = [
+        template.Outputs?.[bootstrap_props_1.BOOTSTRAP_VERSION_OUTPUT]?.Value,
+        template.Resources?.[bootstrap_props_1.BOOTSTRAP_VERSION_RESOURCE]?.Properties?.Value,
+    ];
+    for (const vs of versionSources) {
+        if (typeof vs === 'number') {
+            return vs;
+        }
+        if (typeof vs === 'string' && !isNaN(parseInt(vs, 10))) {
+            return parseInt(vs, 10);
+        }
+    }
+    return 0;
+}
+function bootstrapVariantFromTemplate(template) {
+    return template.Parameters?.[bootstrap_props_1.BOOTSTRAP_VARIANT_PARAMETER]?.Default ?? bootstrap_props_1.DEFAULT_BOOTSTRAP_VARIANT;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"deploy-bootstrap.js","sourceRoot":"","sources":["deploy-bootstrap.ts"],"names":[],"mappings":";;;AA0JA,oEAeC;AAED,oEAEC;AA7KD,yBAAyB;AACzB,6BAA6B;AAC7B,0EAA8D;AAE9D,4CAAyE;AACzE,+BAA+B;AAE/B,uDAK2B;AAG3B,gDAAqE;AACrE,8DAA0D;AAC1D,gDAAsE;AACtE,2CAAkD;AAClD,sCAAiC;AACjC,kDAA0E;AAE1E;;;;;;;;;;;;;GAaG;AACH,MAAa,cAAc;IAaN;IACA;IACA;IACA;IACA;IACA;IAjBZ,MAAM,CAAC,KAAK,CAAC,MAAM,CAAC,WAAwB,EAAE,WAAwB,EAAE,gBAAwB,EAAE,QAAkB;QACzH,gBAAgB,GAAG,gBAAgB,IAAI,yCAA0B,CAAC;QAElE,MAAM,mBAAmB,GAAG,MAAM,WAAW,CAAC,kBAAkB,CAAC,WAAW,CAAC,CAAC;QAC9E,MAAM,GAAG,GAAG,CAAC,MAAM,WAAW,CAAC,cAAc,CAAC,mBAAmB,EAAE,aAAI,CAAC,UAAU,CAAC,CAAC,CAAC,GAAG,CAAC;QAEzF,MAAM,kBAAkB,GAAG,MAAM,0BAAW,CAAC,MAAM,CAAC,mBAAmB,EAAE,GAAG,EAAE,QAAQ,EAAE,gBAAgB,CAAC,CAAC;QAE1G,OAAO,IAAI,cAAc,CAAC,WAAW,EAAE,GAAG,EAAE,mBAAmB,EAAE,gBAAgB,EAAE,kBAAkB,EAAE,QAAQ,CAAC,CAAC;IACnH,CAAC;IAED,YACmB,WAAwB,EACxB,GAAQ,EACR,mBAAgC,EAChC,gBAAwB,EACxB,kBAA+B,EAC/B,QAAkB;QALlB,gBAAW,GAAX,WAAW,CAAa;QACxB,QAAG,GAAH,GAAG,CAAK;QACR,wBAAmB,GAAnB,mBAAmB,CAAa;QAChC,qBAAgB,GAAhB,gBAAgB,CAAQ;QACxB,uBAAkB,GAAlB,kBAAkB,CAAa;QAC/B,aAAQ,GAAR,QAAQ,CAAU;IAErC,CAAC;IAED,IAAW,UAAU;QACnB,OAAO,IAAI,CAAC,kBAAkB,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC,kBAAkB,CAAC,cAAc,CAAC,UAAU,CAAC,CAAC,CAAC,EAAE,CAAC;IAChG,CAAC;IAED,IAAW,qBAAqB;QAC9B,OAAO,IAAI,CAAC,kBAAkB,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC,kBAAkB,CAAC,cAAc,CAAC,qBAAqB,CAAC,CAAC,CAAC,SAAS,CAAC;IAClH,CAAC;IAEM,KAAK,CAAC,SAAS;QACpB,OAAO,CAAC,MAAM,IAAI,CAAC,GAAG,CAAC,cAAc,EAAE,CAAC,CAAC,SAAS,CAAC;IACrD,CAAC;IAED;;OAEG;IACI,KAAK,CAAC,MAAM,CACjB,QAAa,EACb,UAA8C,EAC9C,OAAwD;QAExD,IAAI,IAAI,CAAC,kBAAkB,CAAC,KAAK,IAAI,CAAC,OAAO,CAAC,eAAe,EAAE,CAAC;YAC9D,gBAAgB;YAChB,MAAM,aAAa,GAAG;gBACpB,IAAI,EAAE,kBAAkB;gBACxB,IAAI,EAAE,IAAI;gBACV,OAAO,EAAE,EAAE;gBACX,QAAQ,EAAE,IAAI,CAAC,kBAAkB,CAAC,cAAc,CAAC,OAAO;aACnB,CAAC;YAExC,uHAAuH;YACvH,MAAM,cAAc,GAAG,IAAI,CAAC,kBAAkB,CAAC,OAAO,CAAC;YACvD,MAAM,UAAU,GAAG,4BAA4B,CAAC,QAAQ,CAAC,CAAC;YAC1D,IAAI,cAAc,KAAK,UAAU,EAAE,CAAC;gBAClC,MAAM,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,YAAE,CAAC,oBAAoB,CAAC,GAAG,CACpD,+CAA+C,cAAc,qDAAqD,UAAU,4CAA4C,CACzK,CAAC,CAAC;gBACH,OAAO,aAAa,CAAC;YACvB,CAAC;YAED,0DAA0D;YAC1D,MAAM,UAAU,GAAG,4BAA4B,CAAC,QAAQ,CAAC,CAAC;YAC1D,MAAM,cAAc,GAAG,IAAI,CAAC,kBAAkB,CAAC,OAAO,CAAC;YACvD,IAAI,UAAU,GAAG,cAAc,EAAE,CAAC;gBAChC,MAAM,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,YAAE,CAAC,oBAAoB,CAAC,GAAG,CACpD,sCAAsC,cAAc,mCAAmC,UAAU,2CAA2C,CAC7I,CAAC,CAAC;gBACH,IAAI,UAAU,KAAK,CAAC,EAAE,CAAC;oBACrB,oGAAoG;oBACpG,0GAA0G;oBAC1G,MAAM,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,YAAE,CAAC,oBAAoB,CAAC,GAAG,CACpD,oFAAoF,CACrF,CAAC,CAAC;gBACL,CAAC;gBACD,OAAO,aAAa,CAAC;YACvB,CAAC;QACH,CAAC;QAED,MAAM,MAAM,GAAG,MAAM,EAAE,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,MAAM,EAAE,EAAE,eAAe,CAAC,CAAC,CAAC;QACzE,MAAM,OAAO,GAAG,IAAI,6BAAoB,CAAC,MAAM,CAAC,CAAC;QACjD,MAAM,YAAY,GAAG,GAAG,IAAI,CAAC,gBAAgB,gBAAgB,CAAC;QAC9D,MAAM,EAAE,CAAC,SAAS,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE,YAAY,CAAC,EAAE,QAAQ,EAAE;YACpE,MAAM,EAAE,CAAC;SACV,CAAC,CAAC;QAEH,OAAO,CAAC,WAAW,CAAC,IAAI,CAAC,gBAAgB,EAAE;YACzC,IAAI,EAAE,oCAAY,CAAC,wBAAwB;YAC3C,WAAW,EAAE,yBAAgB,CAAC,MAAM,CAAC,IAAI,CAAC,mBAAmB,CAAC,OAAO,EAAE,IAAI,CAAC,mBAAmB,CAAC,MAAM,CAAC;YACvG,UAAU,EAAE;gBACV,YAAY;gBACZ,qBAAqB,EAAE,OAAO,CAAC,qBAAqB,IAAI,KAAK;aAC9D;SACF,CAAC,CAAC;QAEH,MAAM,QAAQ,GAAG,OAAO,CAAC,aAAa,EAAE,CAAC;QAEzC,MAAM,GAAG,GAAG,MAAM,IAAA,0BAAW,EAAC;YAC5B,KAAK,EAAE,QAAQ,CAAC,cAAc,CAAC,IAAI,CAAC,gBAAgB,CAAC;YACrD,mBAAmB,EAAE,IAAI,CAAC,mBAAmB;YAC7C,GAAG,EAAE,IAAI,CAAC,GAAG;YACb,WAAW,EAAE,IAAI,CAAC,WAAW;YAC7B,eAAe,EAAE,OAAO,CAAC,eAAe;YACxC,OAAO,EAAE,OAAO,CAAC,OAAO;YACxB,IAAI,EAAE,OAAO,CAAC,IAAI;YAClB,gBAAgB,EAAE,EAAE,MAAM,EAAE,YAAY,EAAE,OAAO,EAAE,OAAO,CAAC,OAAO,EAAE;YACpE,UAAU;YACV,qBAAqB,EAAE,OAAO,CAAC,qBAAqB,IAAI,IAAI;YAC5D,wEAAwE;YACxE,YAAY,EAAE,IAAI,kDAAoC,CAAC,IAAI,CAAC,mBAAmB,EAAE,IAAI,CAAC,GAAG,EAAE,IAAI,CAAC,QAAQ,CAAC;SAC1G,EAAE,IAAI,CAAC,QAAQ,CAAC,CAAC;QAElB,IAAA,iDAAmC,EAAC,GAAG,CAAC,CAAC;QAEzC,OAAO,GAAG,CAAC;IACb,CAAC;CACF;AApHD,wCAoHC;AAED,SAAgB,4BAA4B,CAAC,QAAa;IACxD,MAAM,cAAc,GAAG;QACrB,QAAQ,CAAC,OAAO,EAAE,CAAC,0CAAwB,CAAC,EAAE,KAAK;QACnD,QAAQ,CAAC,SAAS,EAAE,CAAC,4CAA0B,CAAC,EAAE,UAAU,EAAE,KAAK;KACpE,CAAC;IAEF,KAAK,MAAM,EAAE,IAAI,cAAc,EAAE,CAAC;QAChC,IAAI,OAAO,EAAE,KAAK,QAAQ,EAAE,CAAC;YAC3B,OAAO,EAAE,CAAC;QACZ,CAAC;QACD,IAAI,OAAO,EAAE,KAAK,QAAQ,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC;YACvD,OAAO,QAAQ,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC;QAC1B,CAAC;IACH,CAAC;IACD,OAAO,CAAC,CAAC;AACX,CAAC;AAED,SAAgB,4BAA4B,CAAC,QAAa;IACxD,OAAO,QAAQ,CAAC,UAAU,EAAE,CAAC,6CAA2B,CAAC,EAAE,OAAO,IAAI,2CAAyB,CAAC;AAClG,CAAC","sourcesContent":["import * as os from 'os';\nimport * as path from 'path';\nimport { ArtifactType } from '@aws-cdk/cloud-assembly-schema';\nimport type { Environment } from '@aws-cdk/cx-api';\nimport { CloudAssemblyBuilder, EnvironmentUtils } from '@aws-cdk/cx-api';\nimport * as fs from 'fs-extra';\nimport type { BootstrapEnvironmentOptions } from './bootstrap-props';\nimport {\n  BOOTSTRAP_VARIANT_PARAMETER,\n  BOOTSTRAP_VERSION_OUTPUT,\n  BOOTSTRAP_VERSION_RESOURCE,\n  DEFAULT_BOOTSTRAP_VARIANT,\n} from './bootstrap-props';\nimport type { SDK, SdkProvider } from '../aws-auth/private';\nimport type { SuccessfulDeployStackResult } from '../deployments';\nimport { assertIsSuccessfulDeployStackResult } from '../deployments';\nimport { deployStack } from '../deployments/deploy-stack';\nimport { NoBootstrapStackEnvironmentResources } from '../environment';\nimport { IO, type IoHelper } from '../io/private';\nimport { Mode } from '../plugin';\nimport { DEFAULT_TOOLKIT_STACK_NAME, ToolkitInfo } from '../toolkit-info';\n\n/**\n * A class to hold state around stack bootstrapping\n *\n * This class exists so we can break bootstrapping into 2 phases:\n *\n * ```ts\n * const current = BootstrapStack.lookup(...);\n * // ...\n * current.update(newTemplate, ...);\n * ```\n *\n * And do something in between the two phases (such as look at the\n * current bootstrap stack and doing something intelligent).\n */\nexport class BootstrapStack {\n  public static async lookup(sdkProvider: SdkProvider, environment: Environment, toolkitStackName: string, ioHelper: IoHelper) {\n    toolkitStackName = toolkitStackName ?? DEFAULT_TOOLKIT_STACK_NAME;\n\n    const resolvedEnvironment = await sdkProvider.resolveEnvironment(environment);\n    const sdk = (await sdkProvider.forEnvironment(resolvedEnvironment, Mode.ForWriting)).sdk;\n\n    const currentToolkitInfo = await ToolkitInfo.lookup(resolvedEnvironment, sdk, ioHelper, toolkitStackName);\n\n    return new BootstrapStack(sdkProvider, sdk, resolvedEnvironment, toolkitStackName, currentToolkitInfo, ioHelper);\n  }\n\n  protected constructor(\n    private readonly sdkProvider: SdkProvider,\n    private readonly sdk: SDK,\n    private readonly resolvedEnvironment: Environment,\n    private readonly toolkitStackName: string,\n    private readonly currentToolkitInfo: ToolkitInfo,\n    private readonly ioHelper: IoHelper,\n  ) {\n  }\n\n  public get parameters(): Record<string, string> {\n    return this.currentToolkitInfo.found ? this.currentToolkitInfo.bootstrapStack.parameters : {};\n  }\n\n  public get terminationProtection() {\n    return this.currentToolkitInfo.found ? this.currentToolkitInfo.bootstrapStack.terminationProtection : undefined;\n  }\n\n  public async partition(): Promise<string> {\n    return (await this.sdk.currentAccount()).partition;\n  }\n\n  /**\n   * Perform the actual deployment of a bootstrap stack, given a template and some parameters\n   */\n  public async update(\n    template: any,\n    parameters: Record<string, string | undefined>,\n    options: Omit<BootstrapEnvironmentOptions, 'parameters'>,\n  ): Promise<SuccessfulDeployStackResult> {\n    if (this.currentToolkitInfo.found && !options.forceDeployment) {\n      // Safety checks\n      const abortResponse = {\n        type: 'did-deploy-stack',\n        noOp: true,\n        outputs: {},\n        stackArn: this.currentToolkitInfo.bootstrapStack.stackId,\n      } satisfies SuccessfulDeployStackResult;\n\n      // Validate that the bootstrap stack we're trying to replace is from the same variant as the one we're trying to deploy\n      const currentVariant = this.currentToolkitInfo.variant;\n      const newVariant = bootstrapVariantFromTemplate(template);\n      if (currentVariant !== newVariant) {\n        await this.ioHelper.notify(IO.DEFAULT_TOOLKIT_WARN.msg(\n          `Bootstrap stack already exists, containing '${currentVariant}'. Not overwriting it with a template containing '${newVariant}' (use --force if you intend to overwrite)`,\n        ));\n        return abortResponse;\n      }\n\n      // Validate that we're not downgrading the bootstrap stack\n      const newVersion = bootstrapVersionFromTemplate(template);\n      const currentVersion = this.currentToolkitInfo.version;\n      if (newVersion < currentVersion) {\n        await this.ioHelper.notify(IO.DEFAULT_TOOLKIT_WARN.msg(\n          `Bootstrap stack already at version ${currentVersion}. Not downgrading it to version ${newVersion} (use --force if you intend to downgrade)`,\n        ));\n        if (newVersion === 0) {\n          // A downgrade with 0 as target version means we probably have a new-style bootstrap in the account,\n          // and an old-style bootstrap as current target, which means the user probably forgot to put this flag in.\n          await this.ioHelper.notify(IO.DEFAULT_TOOLKIT_WARN.msg(\n            \"(Did you set the '@aws-cdk/core:newStyleStackSynthesis' feature flag in cdk.json?)\",\n          ));\n        }\n        return abortResponse;\n      }\n    }\n\n    const outdir = await fs.mkdtemp(path.join(os.tmpdir(), 'cdk-bootstrap'));\n    const builder = new CloudAssemblyBuilder(outdir);\n    const templateFile = `${this.toolkitStackName}.template.json`;\n    await fs.writeJson(path.join(builder.outdir, templateFile), template, {\n      spaces: 2,\n    });\n\n    builder.addArtifact(this.toolkitStackName, {\n      type: ArtifactType.AWS_CLOUDFORMATION_STACK,\n      environment: EnvironmentUtils.format(this.resolvedEnvironment.account, this.resolvedEnvironment.region),\n      properties: {\n        templateFile,\n        terminationProtection: options.terminationProtection ?? false,\n      },\n    });\n\n    const assembly = builder.buildAssembly();\n\n    const ret = await deployStack({\n      stack: assembly.getStackByName(this.toolkitStackName),\n      resolvedEnvironment: this.resolvedEnvironment,\n      sdk: this.sdk,\n      sdkProvider: this.sdkProvider,\n      forceDeployment: options.forceDeployment,\n      roleArn: options.roleArn,\n      tags: options.tags,\n      deploymentMethod: { method: 'change-set', execute: options.execute },\n      parameters,\n      usePreviousParameters: options.usePreviousParameters ?? true,\n      // Obviously we can't need a bootstrap stack to deploy a bootstrap stack\n      envResources: new NoBootstrapStackEnvironmentResources(this.resolvedEnvironment, this.sdk, this.ioHelper),\n    }, this.ioHelper);\n\n    assertIsSuccessfulDeployStackResult(ret);\n\n    return ret;\n  }\n}\n\nexport function bootstrapVersionFromTemplate(template: any): number {\n  const versionSources = [\n    template.Outputs?.[BOOTSTRAP_VERSION_OUTPUT]?.Value,\n    template.Resources?.[BOOTSTRAP_VERSION_RESOURCE]?.Properties?.Value,\n  ];\n\n  for (const vs of versionSources) {\n    if (typeof vs === 'number') {\n      return vs;\n    }\n    if (typeof vs === 'string' && !isNaN(parseInt(vs, 10))) {\n      return parseInt(vs, 10);\n    }\n  }\n  return 0;\n}\n\nexport function bootstrapVariantFromTemplate(template: any): string {\n  return template.Parameters?.[BOOTSTRAP_VARIANT_PARAMETER]?.Default ?? DEFAULT_BOOTSTRAP_VARIANT;\n}\n"]}

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

@@ -0,0 +1,3 @@
+export * from './bootstrap-environment';
+export * from './bootstrap-props';
+export { legacyBootstrapTemplate } from './legacy-template';

package/lib/api/bootstrap/index.js

@@ -0,0 +1,23 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.legacyBootstrapTemplate = void 0;
+__exportStar(require("./bootstrap-environment"), exports);
+__exportStar(require("./bootstrap-props"), exports);
+// testing exports
+var legacy_template_1 = require("./legacy-template");
+Object.defineProperty(exports, "legacyBootstrapTemplate", { enumerable: true, get: function () { return legacy_template_1.legacyBootstrapTemplate; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJpbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7OztBQUFBLDBEQUF3QztBQUN4QyxvREFBa0M7QUFFbEMsa0JBQWtCO0FBQ2xCLHFEQUE0RDtBQUFuRCwwSEFBQSx1QkFBdUIsT0FBQSIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vYm9vdHN0cmFwLWVudmlyb25tZW50JztcbmV4cG9ydCAqIGZyb20gJy4vYm9vdHN0cmFwLXByb3BzJztcblxuLy8gdGVzdGluZyBleHBvcnRzXG5leHBvcnQgeyBsZWdhY3lCb290c3RyYXBUZW1wbGF0ZSB9IGZyb20gJy4vbGVnYWN5LXRlbXBsYXRlJztcbiJdfQ==

package/lib/api/bootstrap/legacy-template.d.ts

@@ -0,0 +1,2 @@
+import type { BootstrappingParameters } from './bootstrap-props';
+export declare function legacyBootstrapTemplate(params: BootstrappingParameters): any;

package/lib/api/bootstrap/legacy-template.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.legacyBootstrapTemplate = legacyBootstrapTemplate;
+const bootstrap_props_1 = require("./bootstrap-props");
+function legacyBootstrapTemplate(params) {
+    return {
+        Description: 'The CDK Toolkit Stack. It was created by `cdk bootstrap` and manages resources necessary for managing your Cloud Applications with AWS CDK.',
+        Conditions: {
+            UsePublicAccessBlockConfiguration: {
+                'Fn::Equals': [
+                    params.publicAccessBlockConfiguration || params.publicAccessBlockConfiguration === undefined ? 'true' : 'false',
+                    'true',
+                ],
+            },
+        },
+        Resources: {
+            StagingBucket: {
+                Type: 'AWS::S3::Bucket',
+                Properties: {
+                    BucketName: params.bucketName,
+                    AccessControl: 'Private',
+                    BucketEncryption: {
+                        ServerSideEncryptionConfiguration: [{
+                                ServerSideEncryptionByDefault: {
+                                    SSEAlgorithm: 'aws:kms',
+                                    KMSMasterKeyID: params.kmsKeyId,
+                                },
+                            }],
+                    },
+                    PublicAccessBlockConfiguration: {
+                        'Fn::If': [
+                            'UsePublicAccessBlockConfiguration',
+                            {
+                                BlockPublicAcls: true,
+                                BlockPublicPolicy: true,
+                                IgnorePublicAcls: true,
+                                RestrictPublicBuckets: true,
+                            },
+                            { Ref: 'AWS::NoValue' },
+                        ],
+                    },
+                },
+            },
+            StagingBucketPolicy: {
+                Type: 'AWS::S3::BucketPolicy',
+                Properties: {
+                    Bucket: { Ref: 'StagingBucket' },
+                    PolicyDocument: {
+                        Id: 'AccessControl',
+                        Version: '2012-10-17',
+                        Statement: [
+                            {
+                                Sid: 'AllowSSLRequestsOnly',
+                                Action: 's3:*',
+                                Effect: 'Deny',
+                                Resource: [
+                                    { 'Fn::Sub': '${StagingBucket.Arn}' },
+                                    { 'Fn::Sub': '${StagingBucket.Arn}/*' },
+                                ],
+                                Condition: {
+                                    Bool: { 'aws:SecureTransport': 'false' },
+                                },
+                                Principal: '*',
+                            },
+                        ],
+                    },
+                },
+            },
+        },
+        Outputs: {
+            [bootstrap_props_1.BUCKET_NAME_OUTPUT]: {
+                Description: 'The name of the S3 bucket owned by the CDK toolkit stack',
+                Value: { Ref: 'StagingBucket' },
+            },
+            [bootstrap_props_1.BUCKET_DOMAIN_NAME_OUTPUT]: {
+                Description: 'The domain name of the S3 bucket owned by the CDK toolkit stack',
+                Value: { 'Fn::GetAtt': ['StagingBucket', 'RegionalDomainName'] },
+            },
+        },
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,43 @@
+import type { SdkProvider } from '../aws-auth/private';
+import type { Settings } from '../settings';
+/**
+ * If we don't have region/account defined in context, we fall back to the default SDK behavior
+ * where region is retrieved from ~/.aws/config and account is based on default credentials provider
+ * chain and then STS is queried.
+ *
+ * This is done opportunistically: for example, if we can't access STS for some reason or the region
+ * is not configured, the context value will be 'null' and there could failures down the line. In
+ * some cases, synthesis does not require region/account information at all, so that might be perfectly
+ * fine in certain scenarios.
+ *
+ * @param context The context key/value bash.
+ */
+export declare function prepareDefaultEnvironment(aws: SdkProvider, debugFn: (msg: string) => Promise<void>): Promise<{
+    [key: string]: string;
+}>;
+/**
+ * Settings related to synthesis are read from context.
+ * The merging of various configuration sources like cli args or cdk.json has already happened.
+ * We now need to set the final values to the context.
+ */
+export declare function prepareContext(settings: Settings, context: {
+    [key: string]: any;
+}, env: {
+    [key: string]: string | undefined;
+}, debugFn: (msg: string) => Promise<void>): Promise<{
+    [key: string]: any;
+}>;
+export declare function spaceAvailableForContext(env: {
+    [key: string]: string;
+}, limit: number): number;
+/**
+ * Guess the executable from the command-line argument
+ *
+ * Only do this if the file is NOT marked as executable. If it is,
+ * we'll defer to the shebang inside the file itself.
+ *
+ * If we're on Windows, we ALWAYS take the handler, since it's hard to
+ * verify if registry associations have or have not been set up for this
+ * file type, so we'll assume the worst and take control.
+ */
+export declare function guessExecutable(app: string, debugFn: (msg: string) => Promise<void>): Promise<any>;