@aws-cdk/toolkit-lib 0.1.0

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

@@ -0,0 +1,178 @@
+import type { BaseDeployOptions } from './private/deploy-options';
+import type { StackActivityProgress, Tag } from '../../api/aws-cdk';
+export type DeploymentMethod = DirectDeploymentMethod | ChangeSetDeploymentMethod;
+export interface DirectDeploymentMethod {
+    /**
+     * Use stack APIs to the deploy stack changes
+     */
+    readonly method: 'direct';
+}
+export interface ChangeSetDeploymentMethod {
+    /**
+     * Use change-set APIS to deploy a stack changes
+     */
+    readonly method: 'change-set';
+    /**
+     * Whether to execute the changeset or leave it in review.
+     *
+     * @default true
+     */
+    readonly execute?: boolean;
+    /**
+     * Optional name to use for the CloudFormation change set.
+     * If not provided, a name will be generated automatically.
+     */
+    readonly changeSetName?: string;
+}
+/**
+ * When to build assets
+ */
+export declare enum AssetBuildTime {
+    /**
+     * Build all assets before deploying the first stack
+     *
+     * This is intended for expensive Docker image builds; so that if the Docker image build
+     * fails, no stacks are unnecessarily deployed (with the attendant wait time).
+     */
+    ALL_BEFORE_DEPLOY = "all-before-deploy",
+    /**
+     * Build assets just-in-time, before publishing
+     */
+    JUST_IN_TIME = "just-in-time"
+}
+export declare enum RequireApproval {
+    /**
+     * Never require any security approvals
+     */
+    NEVER = "never",
+    /**
+     * Any security changes require an approval
+     */
+    ANY_CHANGE = "any-change",
+    /**
+     * Require approval only for changes that are access broadening
+     */
+    BROADENING = "broadening"
+}
+export declare enum HotswapMode {
+    /**
+     * Will fall back to CloudFormation when a non-hotswappable change is detected
+     */
+    FALL_BACK = "fall-back",
+    /**
+     * Will not fall back to CloudFormation when a non-hotswappable change is detected
+     */
+    HOTSWAP_ONLY = "hotswap-only",
+    /**
+     * Will not attempt to hotswap anything and instead go straight to CloudFormation
+     */
+    FULL_DEPLOYMENT = "full-deployment"
+}
+export declare class StackParameters {
+    /**
+     * Use only existing parameters on the stack.
+     */
+    static onlyExisting(): StackParameters;
+    /**
+     * Use exactly these parameters and remove any other existing parameters from the stack.
+     */
+    static exactly(params: {
+        [name: string]: string | undefined;
+    }): StackParameters;
+    /**
+     * Define additional parameters for the stack, while keeping existing parameters for unspecified values.
+     */
+    static withExisting(params: {
+        [name: string]: string | undefined;
+    }): StackParameters;
+    readonly parameters: Map<string, string | undefined>;
+    readonly keepExistingParameters: boolean;
+    private constructor();
+}
+export interface DeployOptions extends BaseDeployOptions {
+    /**
+     * ARNs of SNS topics that CloudFormation will notify with stack related events
+     */
+    readonly notificationArns?: string[];
+    /**
+     * Require a confirmation for security relevant changes before continuing with the deployment
+     *
+     * @default RequireApproval.NEVER
+     * @deprecated in future a message containing the full diff will be emitted and a response requested.
+     * Approval workflows should be implemented in the `IIoHost`.
+     */
+    readonly requireApproval?: RequireApproval;
+    /**
+     * Tags to pass to CloudFormation for deployment
+     */
+    readonly tags?: Tag[];
+    /**
+     * Stack parameters for CloudFormation used at deploy time
+     * @default StackParameters.onlyExisting()
+     */
+    readonly parameters?: StackParameters;
+    /**
+     * Path to file where stack outputs will be written after a successful deploy as JSON
+     * @default - Outputs are not written to any file
+     */
+    readonly outputsFile?: string;
+    /**
+     * Build/publish assets for a single stack in parallel
+     *
+     * Independent of whether stacks are being done in parallel or no.
+     *
+     * @default true
+     */
+    readonly assetParallelism?: boolean;
+    /**
+     * When to build assets
+     *
+     * The default is the Docker-friendly default.
+     *
+     * @default AssetBuildTime.ALL_BEFORE_DEPLOY
+     */
+    readonly assetBuildTime?: AssetBuildTime;
+    /**
+     * Change stack watcher output to CI mode.
+     *
+     * @deprecated Implement in IoHost instead
+     */
+    readonly ci?: boolean;
+    /**
+     * Display mode for stack deployment progress.
+     *
+     * @deprecated Implement in IoHost instead
+     */
+    readonly progress?: StackActivityProgress;
+    /**
+     * Represents configuration property overrides for hotswap deployments.
+     * Currently only supported by ECS.
+     *
+     * @default - no overrides
+     */
+    readonly hotswapProperties?: HotswapProperties;
+}
+/**
+ * Property overrides for ECS hotswaps
+ */
+export interface EcsHotswapProperties {
+    /**
+     * The lower limit on the number of your service's tasks that must remain
+     * in the RUNNING state during a deployment, as a percentage of the desiredCount.
+     */
+    readonly minimumHealthyPercent: number;
+    /**
+     * The upper limit on the number of your service's tasks that are allowed
+     * in the RUNNING or PENDING state during a deployment, as a percentage of the desiredCount.
+     */
+    readonly maximumHealthyPercent: number;
+}
+/**
+ * Property overrides for hotswap deployments.
+ */
+export interface HotswapProperties {
+    /**
+     * ECS specific hotswap property overrides
+     */
+    readonly ecs: EcsHotswapProperties;
+}

package/lib/actions/deploy/index.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StackParameters = exports.HotswapMode = exports.RequireApproval = exports.AssetBuildTime = void 0;
+/**
+ * When to build assets
+ */
+var AssetBuildTime;
+(function (AssetBuildTime) {
+    /**
+     * Build all assets before deploying the first stack
+     *
+     * This is intended for expensive Docker image builds; so that if the Docker image build
+     * fails, no stacks are unnecessarily deployed (with the attendant wait time).
+     */
+    AssetBuildTime["ALL_BEFORE_DEPLOY"] = "all-before-deploy";
+    /**
+     * Build assets just-in-time, before publishing
+     */
+    AssetBuildTime["JUST_IN_TIME"] = "just-in-time";
+})(AssetBuildTime || (exports.AssetBuildTime = AssetBuildTime = {}));
+var RequireApproval;
+(function (RequireApproval) {
+    /**
+     * Never require any security approvals
+     */
+    RequireApproval["NEVER"] = "never";
+    /**
+     * Any security changes require an approval
+     */
+    RequireApproval["ANY_CHANGE"] = "any-change";
+    /**
+     * Require approval only for changes that are access broadening
+     */
+    RequireApproval["BROADENING"] = "broadening";
+})(RequireApproval || (exports.RequireApproval = RequireApproval = {}));
+var HotswapMode;
+(function (HotswapMode) {
+    /**
+     * Will fall back to CloudFormation when a non-hotswappable change is detected
+     */
+    HotswapMode["FALL_BACK"] = "fall-back";
+    /**
+     * Will not fall back to CloudFormation when a non-hotswappable change is detected
+     */
+    HotswapMode["HOTSWAP_ONLY"] = "hotswap-only";
+    /**
+     * Will not attempt to hotswap anything and instead go straight to CloudFormation
+     */
+    HotswapMode["FULL_DEPLOYMENT"] = "full-deployment";
+})(HotswapMode || (exports.HotswapMode = HotswapMode = {}));
+class StackParameters {
+    /**
+     * Use only existing parameters on the stack.
+     */
+    static onlyExisting() {
+        return new StackParameters({}, true);
+    }
+    /**
+     * Use exactly these parameters and remove any other existing parameters from the stack.
+     */
+    static exactly(params) {
+        return new StackParameters(params, false);
+    }
+    /**
+     * Define additional parameters for the stack, while keeping existing parameters for unspecified values.
+     */
+    static withExisting(params) {
+        return new StackParameters(params, true);
+    }
+    parameters;
+    keepExistingParameters;
+    constructor(params, usePreviousParameters = true) {
+        this.keepExistingParameters = usePreviousParameters;
+        this.parameters = new Map(Object.entries(params));
+    }
+}
+exports.StackParameters = StackParameters;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["index.ts"],"names":[],"mappings":";;;AAgCA;;GAEG;AACH,IAAY,cAaX;AAbD,WAAY,cAAc;IACxB;;;;;OAKG;IACH,yDAAuC,CAAA;IAEvC;;OAEG;IACH,+CAA6B,CAAA;AAC/B,CAAC,EAbW,cAAc,8BAAd,cAAc,QAazB;AAED,IAAY,eAaX;AAbD,WAAY,eAAe;IACzB;;OAEG;IACH,kCAAe,CAAA;IACf;;OAEG;IACH,4CAAyB,CAAA;IACzB;;OAEG;IACH,4CAAyB,CAAA;AAC3B,CAAC,EAbW,eAAe,+BAAf,eAAe,QAa1B;AAED,IAAY,WAeX;AAfD,WAAY,WAAW;IACrB;;OAEG;IACH,sCAAuB,CAAA;IAEvB;;OAEG;IACH,4CAA6B,CAAA;IAE7B;;OAEG;IACH,kDAAmC,CAAA;AACrC,CAAC,EAfW,WAAW,2BAAX,WAAW,QAetB;AAED,MAAa,eAAe;IAC1B;;OAEG;IACI,MAAM,CAAC,YAAY;QACxB,OAAO,IAAI,eAAe,CAAC,EAAE,EAAE,IAAI,CAAC,CAAC;IACvC,CAAC;IAED;;OAEG;IACI,MAAM,CAAC,OAAO,CAAC,MAA8C;QAClE,OAAO,IAAI,eAAe,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;IAC5C,CAAC;IAED;;OAEG;IACI,MAAM,CAAC,YAAY,CAAC,MAA8C;QACvE,OAAO,IAAI,eAAe,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;IAC3C,CAAC;IAEe,UAAU,CAAkC;IAC5C,sBAAsB,CAAU;IAEhD,YAAoB,MAA8C,EAAE,qBAAqB,GAAG,IAAI;QAC9F,IAAI,CAAC,sBAAsB,GAAG,qBAAqB,CAAC;QACpD,IAAI,CAAC,UAAU,GAAG,IAAI,GAAG,CAAC,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC;IACpD,CAAC;CACF;AA7BD,0CA6BC","sourcesContent":["import type { BaseDeployOptions } from './private/deploy-options';\nimport type { StackActivityProgress, Tag } from '../../api/aws-cdk';\n\nexport type DeploymentMethod = DirectDeploymentMethod | ChangeSetDeploymentMethod;\n\nexport interface DirectDeploymentMethod {\n  /**\n   * Use stack APIs to the deploy stack changes\n   */\n  readonly method: 'direct';\n}\n\nexport interface ChangeSetDeploymentMethod {\n  /**\n   * Use change-set APIS to deploy a stack changes\n   */\n  readonly method: 'change-set';\n\n  /**\n   * Whether to execute the changeset or leave it in review.\n   *\n   * @default true\n   */\n  readonly execute?: boolean;\n\n  /**\n   * Optional name to use for the CloudFormation change set.\n   * If not provided, a name will be generated automatically.\n   */\n  readonly changeSetName?: string;\n}\n\n/**\n * When to build assets\n */\nexport enum AssetBuildTime {\n  /**\n   * Build all assets before deploying the first stack\n   *\n   * This is intended for expensive Docker image builds; so that if the Docker image build\n   * fails, no stacks are unnecessarily deployed (with the attendant wait time).\n   */\n  ALL_BEFORE_DEPLOY = 'all-before-deploy',\n\n  /**\n   * Build assets just-in-time, before publishing\n   */\n  JUST_IN_TIME = 'just-in-time',\n}\n\nexport enum RequireApproval {\n  /**\n   * Never require any security approvals\n   */\n  NEVER = 'never',\n  /**\n   * Any security changes require an approval\n   */\n  ANY_CHANGE = 'any-change',\n  /**\n   * Require approval only for changes that are access broadening\n   */\n  BROADENING = 'broadening',\n}\n\nexport enum HotswapMode {\n  /**\n   * Will fall back to CloudFormation when a non-hotswappable change is detected\n   */\n  FALL_BACK = 'fall-back',\n\n  /**\n   * Will not fall back to CloudFormation when a non-hotswappable change is detected\n   */\n  HOTSWAP_ONLY = 'hotswap-only',\n\n  /**\n   * Will not attempt to hotswap anything and instead go straight to CloudFormation\n   */\n  FULL_DEPLOYMENT = 'full-deployment',\n}\n\nexport class StackParameters {\n  /**\n   * Use only existing parameters on the stack.\n   */\n  public static onlyExisting() {\n    return new StackParameters({}, true);\n  }\n\n  /**\n   * Use exactly these parameters and remove any other existing parameters from the stack.\n   */\n  public static exactly(params: { [name: string]: string | undefined }) {\n    return new StackParameters(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: { [name: string]: string | undefined }) {\n    return new StackParameters(params, true);\n  }\n\n  public readonly parameters: Map<string, string | undefined>;\n  public readonly keepExistingParameters: boolean;\n\n  private constructor(params: { [name: string]: string | undefined }, usePreviousParameters = true) {\n    this.keepExistingParameters = usePreviousParameters;\n    this.parameters = new Map(Object.entries(params));\n  }\n}\n\nexport interface DeployOptions extends BaseDeployOptions {\n  /**\n   * ARNs of SNS topics that CloudFormation will notify with stack related events\n   */\n  readonly notificationArns?: string[];\n\n  /**\n   * Require a confirmation for security relevant changes before continuing with the deployment\n   *\n   * @default RequireApproval.NEVER\n   * @deprecated in future a message containing the full diff will be emitted and a response requested.\n   * Approval workflows should be implemented in the `IIoHost`.\n   */\n  readonly requireApproval?: RequireApproval;\n\n  /**\n   * Tags to pass to CloudFormation for deployment\n   */\n  readonly tags?: Tag[];\n\n  /**\n   * Stack parameters for CloudFormation used at deploy time\n   * @default StackParameters.onlyExisting()\n   */\n  readonly parameters?: StackParameters;\n\n  /**\n   * Path to file where stack outputs will be written after a successful deploy as JSON\n   * @default - Outputs are not written to any file\n   */\n  readonly outputsFile?: string;\n\n  /**\n   * Build/publish assets for a single stack in parallel\n   *\n   * Independent of whether stacks are being done in parallel or no.\n   *\n   * @default true\n   */\n  readonly assetParallelism?: boolean;\n\n  /**\n   * When to build assets\n   *\n   * The default is the Docker-friendly default.\n   *\n   * @default AssetBuildTime.ALL_BEFORE_DEPLOY\n   */\n  readonly assetBuildTime?: AssetBuildTime;\n\n  /**\n   * Change stack watcher output to CI mode.\n   *\n   * @deprecated Implement in IoHost instead\n   */\n  readonly ci?: boolean;\n\n  /**\n   * Display mode for stack deployment progress.\n   *\n   * @deprecated Implement in IoHost instead\n   */\n  readonly progress?: StackActivityProgress;\n\n  /**\n   * Represents configuration property overrides for hotswap deployments.\n   * Currently only supported by ECS.\n   *\n   * @default - no overrides\n   */\n  readonly hotswapProperties?: HotswapProperties;\n}\n\n/**\n * Property overrides for ECS hotswaps\n */\nexport interface EcsHotswapProperties {\n  /**\n   * The lower limit on the number of your service's tasks that must remain\n   * in the RUNNING state during a deployment, as a percentage of the desiredCount.\n   */\n  readonly minimumHealthyPercent: number;\n\n  /**\n   * The upper limit on the number of your service's tasks that are allowed\n   * in the RUNNING or PENDING state during a deployment, as a percentage of the desiredCount.\n   */\n  readonly maximumHealthyPercent: number;\n}\n\n/**\n * Property overrides for hotswap deployments.\n */\nexport interface HotswapProperties {\n  /**\n   * ECS specific hotswap property overrides\n   */\n  readonly ecs: EcsHotswapProperties;\n}\n"]}

package/lib/actions/deploy/private/deploy-options.d.ts

@@ -0,0 +1,78 @@
+import { DeploymentMethod, DeployOptions, HotswapMode } from '..';
+import type { CloudWatchLogEventMonitor } from '../../../api/aws-cdk';
+import type { StackSelector } from '../../../api/cloud-assembly';
+export interface BaseDeployOptions {
+    /**
+     * Criteria for selecting stacks to deploy
+     *
+     * @default - all stacks
+     */
+    readonly stacks?: StackSelector;
+    /**
+     * Role to pass to CloudFormation for deployment
+     */
+    readonly roleArn?: string;
+    /**
+     * Always deploy, even if templates are identical.
+     *
+     * @default false
+     * @deprecated the options currently covers multiple different functionalities and will be split out in future
+     */
+    readonly force?: boolean;
+    /**
+     * Deployment method
+     */
+    readonly deploymentMethod?: DeploymentMethod;
+    /**
+     * Whether to perform a 'hotswap' deployment.
+     * A 'hotswap' deployment will attempt to short-circuit CloudFormation
+     * and update the affected resources like Lambda functions directly.
+     *
+     * @default - no hotswap
+     */
+    readonly hotswap?: HotswapMode;
+    /**
+     * Rollback failed deployments
+     *
+     * @default true
+     */
+    readonly rollback?: boolean;
+    /**
+     * Reuse the assets with the given asset IDs
+     */
+    readonly reuseAssets?: string[];
+    /**
+     * Maximum number of simultaneous deployments (dependency permitting) to execute.
+     * The default is '1', which executes all deployments serially.
+     *
+     * @default 1
+     */
+    readonly concurrency?: number;
+    /**
+     * Whether to send logs from all CloudWatch log groups in the template
+     * to the IoHost
+     *
+     * @default - false
+     */
+    readonly traceLogs?: boolean;
+}
+/**
+ * Deploy options needed by the watch command.
+ * Intentionally not exported because these options are not
+ * meant to be public facing.
+ */
+export interface ExtendedDeployOptions extends DeployOptions {
+    /**
+     * The extra string to append to the User-Agent header when performing AWS SDK calls.
+     *
+     * @default - nothing extra is appended to the User-Agent header
+     */
+    readonly extraUserAgent?: string;
+    /**
+     * Allows adding CloudWatch log groups to the log monitor via
+     * cloudWatchLogMonitor.setLogGroups();
+     *
+     * @default - not monitoring CloudWatch logs
+     */
+    readonly cloudWatchLogMonitor?: CloudWatchLogEventMonitor;
+}

package/lib/actions/deploy/private/deploy-options.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGVwbG95LW9wdGlvbnMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJkZXBsb3ktb3B0aW9ucy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgRGVwbG95bWVudE1ldGhvZCwgRGVwbG95T3B0aW9ucywgSG90c3dhcE1vZGUgfSBmcm9tICcuLic7XG5pbXBvcnQgdHlwZSB7IENsb3VkV2F0Y2hMb2dFdmVudE1vbml0b3IgfSBmcm9tICcuLi8uLi8uLi9hcGkvYXdzLWNkayc7XG5pbXBvcnQgdHlwZSB7IFN0YWNrU2VsZWN0b3IgfSBmcm9tICcuLi8uLi8uLi9hcGkvY2xvdWQtYXNzZW1ibHknO1xuXG5leHBvcnQgaW50ZXJmYWNlIEJhc2VEZXBsb3lPcHRpb25zIHtcbiAgLyoqXG4gICAqIENyaXRlcmlhIGZvciBzZWxlY3Rpbmcgc3RhY2tzIHRvIGRlcGxveVxuICAgKlxuICAgKiBAZGVmYXVsdCAtIGFsbCBzdGFja3NcbiAgICovXG4gIHJlYWRvbmx5IHN0YWNrcz86IFN0YWNrU2VsZWN0b3I7XG5cbiAgLyoqXG4gICAqIFJvbGUgdG8gcGFzcyB0byBDbG91ZEZvcm1hdGlvbiBmb3IgZGVwbG95bWVudFxuICAgKi9cbiAgcmVhZG9ubHkgcm9sZUFybj86IHN0cmluZztcblxuICAvKipcbiAgICogQWx3YXlzIGRlcGxveSwgZXZlbiBpZiB0ZW1wbGF0ZXMgYXJlIGlkZW50aWNhbC5cbiAgICpcbiAgICogQGRlZmF1bHQgZmFsc2VcbiAgICogQGRlcHJlY2F0ZWQgdGhlIG9wdGlvbnMgY3VycmVudGx5IGNvdmVycyBtdWx0aXBsZSBkaWZmZXJlbnQgZnVuY3Rpb25hbGl0aWVzIGFuZCB3aWxsIGJlIHNwbGl0IG91dCBpbiBmdXR1cmVcbiAgICovXG4gIHJlYWRvbmx5IGZvcmNlPzogYm9vbGVhbjtcblxuICAvKipcbiAgICogRGVwbG95bWVudCBtZXRob2RcbiAgICovXG4gIHJlYWRvbmx5IGRlcGxveW1lbnRNZXRob2Q/OiBEZXBsb3ltZW50TWV0aG9kO1xuXG4gIC8qKlxuICAgKiBXaGV0aGVyIHRvIHBlcmZvcm0gYSAnaG90c3dhcCcgZGVwbG95bWVudC5cbiAgICogQSAnaG90c3dhcCcgZGVwbG95bWVudCB3aWxsIGF0dGVtcHQgdG8gc2hvcnQtY2lyY3VpdCBDbG91ZEZvcm1hdGlvblxuICAgKiBhbmQgdXBkYXRlIHRoZSBhZmZlY3RlZCByZXNvdXJjZXMgbGlrZSBMYW1iZGEgZnVuY3Rpb25zIGRpcmVjdGx5LlxuICAgKlxuICAgKiBAZGVmYXVsdCAtIG5vIGhvdHN3YXBcbiAgICovXG4gIHJlYWRvbmx5IGhvdHN3YXA/OiBIb3Rzd2FwTW9kZTtcblxuICAvKipcbiAgICogUm9sbGJhY2sgZmFpbGVkIGRlcGxveW1lbnRzXG4gICAqXG4gICAqIEBkZWZhdWx0IHRydWVcbiAgICovXG4gIHJlYWRvbmx5IHJvbGxiYWNrPzogYm9vbGVhbjtcblxuICAvKipcbiAgICogUmV1c2UgdGhlIGFzc2V0cyB3aXRoIHRoZSBnaXZlbiBhc3NldCBJRHNcbiAgICovXG4gIHJlYWRvbmx5IHJldXNlQXNzZXRzPzogc3RyaW5nW107XG5cbiAgLyoqXG4gICAqIE1heGltdW0gbnVtYmVyIG9mIHNpbXVsdGFuZW91cyBkZXBsb3ltZW50cyAoZGVwZW5kZW5jeSBwZXJtaXR0aW5nKSB0byBleGVjdXRlLlxuICAgKiBUaGUgZGVmYXVsdCBpcyAnMScsIHdoaWNoIGV4ZWN1dGVzIGFsbCBkZXBsb3ltZW50cyBzZXJpYWxseS5cbiAgICpcbiAgICogQGRlZmF1bHQgMVxuICAgKi9cbiAgcmVhZG9ubHkgY29uY3VycmVuY3k/OiBudW1iZXI7XG5cbiAgLyoqXG4gICAqIFdoZXRoZXIgdG8gc2VuZCBsb2dzIGZyb20gYWxsIENsb3VkV2F0Y2ggbG9nIGdyb3VwcyBpbiB0aGUgdGVtcGxhdGVcbiAgICogdG8gdGhlIElvSG9zdFxuICAgKlxuICAgKiBAZGVmYXVsdCAtIGZhbHNlXG4gICAqL1xuICByZWFkb25seSB0cmFjZUxvZ3M/OiBib29sZWFuO1xufVxuXG4vKipcbiAqIERlcGxveSBvcHRpb25zIG5lZWRlZCBieSB0aGUgd2F0Y2ggY29tbWFuZC5cbiAqIEludGVudGlvbmFsbHkgbm90IGV4cG9ydGVkIGJlY2F1c2UgdGhlc2Ugb3B0aW9ucyBhcmUgbm90XG4gKiBtZWFudCB0byBiZSBwdWJsaWMgZmFjaW5nLlxuICovXG5leHBvcnQgaW50ZXJmYWNlIEV4dGVuZGVkRGVwbG95T3B0aW9ucyBleHRlbmRzIERlcGxveU9wdGlvbnMge1xuICAvKipcbiAgICogVGhlIGV4dHJhIHN0cmluZyB0byBhcHBlbmQgdG8gdGhlIFVzZXItQWdlbnQgaGVhZGVyIHdoZW4gcGVyZm9ybWluZyBBV1MgU0RLIGNhbGxzLlxuICAgKlxuICAgKiBAZGVmYXVsdCAtIG5vdGhpbmcgZXh0cmEgaXMgYXBwZW5kZWQgdG8gdGhlIFVzZXItQWdlbnQgaGVhZGVyXG4gICAqL1xuICByZWFkb25seSBleHRyYVVzZXJBZ2VudD86IHN0cmluZztcblxuICAvKipcbiAgICogQWxsb3dzIGFkZGluZyBDbG91ZFdhdGNoIGxvZyBncm91cHMgdG8gdGhlIGxvZyBtb25pdG9yIHZpYVxuICAgKiBjbG91ZFdhdGNoTG9nTW9uaXRvci5zZXRMb2dHcm91cHMoKTtcbiAgICpcbiAgICogQGRlZmF1bHQgLSBub3QgbW9uaXRvcmluZyBDbG91ZFdhdGNoIGxvZ3NcbiAgICovXG4gIHJlYWRvbmx5IGNsb3VkV2F0Y2hMb2dNb25pdG9yPzogQ2xvdWRXYXRjaExvZ0V2ZW50TW9uaXRvcjtcbn1cbiJdfQ==

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

@@ -0,0 +1,15 @@
+import { DeployOptions, HotswapProperties } from '..';
+import { Deployments, HotswapPropertyOverrides, type WorkGraph } from '../../../api/aws-cdk';
+export declare function buildParameterMap(parameters?: Map<string, string | undefined>): {
+    [name: string]: {
+        [name: string]: string | undefined;
+    };
+};
+/**
+ * Remove the asset publishing and building from the work graph for assets that are already in place
+ */
+export declare function removePublishedAssets(graph: WorkGraph, deployments: Deployments, options: DeployOptions): Promise<void>;
+/**
+ * Create the HotswapPropertyOverrides class out of the Interface exposed to users
+ */
+export declare function createHotswapPropertyOverrides(hotswapProperties: HotswapProperties): HotswapPropertyOverrides;

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

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildParameterMap = buildParameterMap;
+exports.removePublishedAssets = removePublishedAssets;
+exports.createHotswapPropertyOverrides = createHotswapPropertyOverrides;
+const aws_cdk_1 = require("../../../api/aws-cdk");
+function buildParameterMap(parameters) {
+    const parameterMap = {};
+    parameterMap['*'] = {};
+    const entries = parameters?.entries() ?? [];
+    for (const [key, value] of entries) {
+        const [stack, parameter] = key.split(':', 2);
+        if (!parameter) {
+            parameterMap['*'][stack] = value;
+        }
+        else {
+            if (!parameterMap[stack]) {
+                parameterMap[stack] = {};
+            }
+            parameterMap[stack][parameter] = value;
+        }
+    }
+    return parameterMap;
+}
+/**
+ * Remove the asset publishing and building from the work graph for assets that are already in place
+ */
+async function removePublishedAssets(graph, deployments, options) {
+    await graph.removeUnnecessaryAssets(assetNode => deployments.isSingleAssetPublished(assetNode.assetManifest, assetNode.asset, {
+        stack: assetNode.parentStack,
+        roleArn: options.roleArn,
+        stackName: assetNode.parentStack.stackName,
+    }));
+}
+/**
+ * Create the HotswapPropertyOverrides class out of the Interface exposed to users
+ */
+function createHotswapPropertyOverrides(hotswapProperties) {
+    return new aws_cdk_1.HotswapPropertyOverrides(new aws_cdk_1.EcsHotswapProperties(hotswapProperties.ecs.minimumHealthyPercent, hotswapProperties.ecs.maximumHealthyPercent));
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/actions/deploy/private/index.d.ts

@@ -0,0 +1,2 @@
+export * from './deploy-options';
+export * from './helpers';

package/lib/actions/deploy/private/index.js

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

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

@@ -0,0 +1,17 @@
+import type { StackSelector } from '../../api/cloud-assembly';
+export interface DestroyOptions {
+    /**
+     * Criteria for selecting stacks to deploy
+     */
+    readonly stacks: StackSelector;
+    /**
+     * The arn of the IAM role to use
+     */
+    readonly roleArn?: string;
+    /**
+     * Change stack watcher output to CI mode.
+     *
+     * @deprecated Implement in IoHost instead
+     */
+    readonly ci?: boolean;
+}

package/lib/actions/destroy/index.js

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

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

@@ -0,0 +1,83 @@
+import type { StackSelector } from '../../api/cloud-assembly';
+export interface CloudFormationDiffOptions {
+    /**
+     * Whether to run the diff against the template after the CloudFormation Transforms inside it have been executed
+     * (as opposed to the original template, the default, which contains the unprocessed Transforms).
+     *
+     * @default false
+     */
+    readonly compareAgainstProcessedTemplate?: boolean;
+}
+export interface ChangeSetDiffOptions extends CloudFormationDiffOptions {
+    /**
+     * Enable falling back to template-based diff in case creating the changeset is not possible or results in an error.
+     *
+     * Should be used for stacks containing nested stacks or when change set permissions aren't available.
+     *
+     * @default true
+     */
+    readonly fallbackToTemplate?: boolean;
+    /**
+     * Additional parameters for CloudFormation when creating a diff change set
+     *
+     * @default {}
+     */
+    readonly parameters?: {
+        [name: string]: string | undefined;
+    };
+}
+export declare class DiffMethod {
+    readonly method: 'change-set' | 'template-only' | 'local-file';
+    readonly options: ChangeSetDiffOptions | CloudFormationDiffOptions | {
+        path: string;
+    };
+    /**
+     * Use a changeset to compute the diff.
+     *
+     * This will create, analyze, and subsequently delete a changeset against the CloudFormation stack.
+     */
+    static ChangeSet(options?: ChangeSetDiffOptions): DiffMethod;
+    static TemplateOnly(options?: CloudFormationDiffOptions): DiffMethod;
+    static LocalFile(path: string): DiffMethod;
+    private constructor();
+}
+export interface DiffOptions {
+    /**
+     * Select the stacks
+     */
+    readonly stacks: StackSelector;
+    /**
+     * The mode to create a stack diff.
+     *
+     * Use changeset diff for the highest fidelity, including analyze resource replacements.
+     * In this mode, diff will use the deploy role instead of the lookup role.
+     *
+     * Use template-only diff for a faster, less accurate diff that doesn't require
+     * permissions to create a change-set.
+     *
+     * Use local-template diff for a fast, local-only diff that doesn't require
+     * any permissions or internet access.
+     *
+     * @default DiffMode.ChangeSet
+     */
+    readonly method: DiffMethod;
+    /**
+     * Strict diff mode
+     * When enabled, this will not filter out AWS::CDK::Metadata resources, mangled non-ASCII characters, or the CheckBootstrapVersionRule.
+     *
+     * @default false
+     */
+    readonly strict?: boolean;
+    /**
+     * How many lines of context to show in the diff
+     *
+     * @default 3
+     */
+    readonly contextLines?: number;
+    /**
+     * Only include broadened security changes in the diff
+     *
+     * @default false
+     */
+    readonly securityOnly?: boolean;
+}

package/lib/actions/diff/index.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DiffMethod = void 0;
+class DiffMethod {
+    method;
+    options;
+    /**
+     * Use a changeset to compute the diff.
+     *
+     * This will create, analyze, and subsequently delete a changeset against the CloudFormation stack.
+     */
+    static ChangeSet(options = {}) {
+        return new class extends DiffMethod {
+            options;
+            constructor(opts) {
+                super('change-set', opts);
+                this.options = opts;
+            }
+        }(options);
+    }
+    static TemplateOnly(options = {}) {
+        return new class extends DiffMethod {
+            options;
+            constructor(opts) {
+                super('template-only', opts);
+                this.options = opts;
+            }
+        }(options);
+    }
+    static LocalFile(path) {
+        return new class extends DiffMethod {
+            options;
+            constructor(opts) {
+                super('local-file', opts);
+                this.options = opts;
+            }
+        }({ path });
+    }
+    constructor(method, options) {
+        this.method = method;
+        this.options = options;
+    }
+}
+exports.DiffMethod = DiffMethod;
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,7 @@
+import { DescribeChangeSetOutput } from '@aws-cdk/cloudformation-diff';
+import * as cxapi from '@aws-cdk/cx-api';
+import { RequireApproval } from '../../deploy';
+/**
+ * Return whether the diff has security-impacting changes that need confirmation
+ */
+export declare function diffRequiresApproval(oldTemplate: any, newTemplate: cxapi.CloudFormationStackArtifact, requireApproval: RequireApproval, changeSet?: DescribeChangeSetOutput): boolean;

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

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.diffRequiresApproval = diffRequiresApproval;
+const cloudformation_diff_1 = require("@aws-cdk/cloudformation-diff");
+const errors_1 = require("../../../api/errors");
+const deploy_1 = require("../../deploy");
+/**
+ * Return whether the diff has security-impacting changes that need confirmation
+ */
+function diffRequiresApproval(oldTemplate, newTemplate, requireApproval, changeSet) {
+    // @todo return or print the full diff.
+    const diff = (0, cloudformation_diff_1.fullDiff)(oldTemplate, newTemplate.template, changeSet);
+    switch (requireApproval) {
+        case deploy_1.RequireApproval.NEVER: return false;
+        case deploy_1.RequireApproval.ANY_CHANGE: return diff.permissionsAnyChanges;
+        case deploy_1.RequireApproval.BROADENING: return diff.permissionsBroadened;
+        default: throw new errors_1.ToolkitError(`Unrecognized approval level: ${requireApproval}`);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaGVscGVycy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbImhlbHBlcnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7QUFRQSxvREFlQztBQXZCRCxzRUFBaUY7QUFFakYsZ0RBQW1EO0FBQ25ELHlDQUErQztBQUUvQzs7R0FFRztBQUNILFNBQWdCLG9CQUFvQixDQUNsQyxXQUFnQixFQUNoQixXQUE4QyxFQUM5QyxlQUFnQyxFQUNoQyxTQUFtQztJQUVuQyx1Q0FBdUM7SUFDdkMsTUFBTSxJQUFJLEdBQUcsSUFBQSw4QkFBUSxFQUFDLFdBQVcsRUFBRSxXQUFXLENBQUMsUUFBUSxFQUFFLFNBQVMsQ0FBQyxDQUFDO0lBRXBFLFFBQVEsZUFBZSxFQUFFLENBQUM7UUFDeEIsS0FBSyx3QkFBZSxDQUFDLEtBQUssQ0FBQyxDQUFDLE9BQU8sS0FBSyxDQUFDO1FBQ3pDLEtBQUssd0JBQWUsQ0FBQyxVQUFVLENBQUMsQ0FBQyxPQUFPLElBQUksQ0FBQyxxQkFBcUIsQ0FBQztRQUNuRSxLQUFLLHdCQUFlLENBQUMsVUFBVSxDQUFDLENBQUMsT0FBTyxJQUFJLENBQUMsb0JBQW9CLENBQUM7UUFDbEUsT0FBTyxDQUFDLENBQUMsTUFBTSxJQUFJLHFCQUFZLENBQUMsZ0NBQWdDLGVBQWUsRUFBRSxDQUFDLENBQUM7SUFDckYsQ0FBQztBQUNILENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBEZXNjcmliZUNoYW5nZVNldE91dHB1dCwgZnVsbERpZmYgfSBmcm9tICdAYXdzLWNkay9jbG91ZGZvcm1hdGlvbi1kaWZmJztcbmltcG9ydCAqIGFzIGN4YXBpIGZyb20gJ0Bhd3MtY2RrL2N4LWFwaSc7XG5pbXBvcnQgeyBUb29sa2l0RXJyb3IgfSBmcm9tICcuLi8uLi8uLi9hcGkvZXJyb3JzJztcbmltcG9ydCB7IFJlcXVpcmVBcHByb3ZhbCB9IGZyb20gJy4uLy4uL2RlcGxveSc7XG5cbi8qKlxuICogUmV0dXJuIHdoZXRoZXIgdGhlIGRpZmYgaGFzIHNlY3VyaXR5LWltcGFjdGluZyBjaGFuZ2VzIHRoYXQgbmVlZCBjb25maXJtYXRpb25cbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIGRpZmZSZXF1aXJlc0FwcHJvdmFsKFxuICBvbGRUZW1wbGF0ZTogYW55LFxuICBuZXdUZW1wbGF0ZTogY3hhcGkuQ2xvdWRGb3JtYXRpb25TdGFja0FydGlmYWN0LFxuICByZXF1aXJlQXBwcm92YWw6IFJlcXVpcmVBcHByb3ZhbCxcbiAgY2hhbmdlU2V0PzogRGVzY3JpYmVDaGFuZ2VTZXRPdXRwdXQsXG4pOiBib29sZWFuIHtcbiAgLy8gQHRvZG8gcmV0dXJuIG9yIHByaW50IHRoZSBmdWxsIGRpZmYuXG4gIGNvbnN0IGRpZmYgPSBmdWxsRGlmZihvbGRUZW1wbGF0ZSwgbmV3VGVtcGxhdGUudGVtcGxhdGUsIGNoYW5nZVNldCk7XG5cbiAgc3dpdGNoIChyZXF1aXJlQXBwcm92YWwpIHtcbiAgICBjYXNlIFJlcXVpcmVBcHByb3ZhbC5ORVZFUjogcmV0dXJuIGZhbHNlO1xuICAgIGNhc2UgUmVxdWlyZUFwcHJvdmFsLkFOWV9DSEFOR0U6IHJldHVybiBkaWZmLnBlcm1pc3Npb25zQW55Q2hhbmdlcztcbiAgICBjYXNlIFJlcXVpcmVBcHByb3ZhbC5CUk9BREVOSU5HOiByZXR1cm4gZGlmZi5wZXJtaXNzaW9uc0Jyb2FkZW5lZDtcbiAgICBkZWZhdWx0OiB0aHJvdyBuZXcgVG9vbGtpdEVycm9yKGBVbnJlY29nbml6ZWQgYXBwcm92YWwgbGV2ZWw6ICR7cmVxdWlyZUFwcHJvdmFsfWApO1xuICB9XG59XG4iXX0=

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

@@ -0,0 +1 @@
+export * from './helpers';