aws-cdk 2.178.2 → 2.179.0

package/lib/api/garbage-collection/progress-printer.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ProgressPrinter = void 0;
 const chalk = require("chalk");
 const logging_1 = require("../../logging");
+const error_1 = require("../../toolkit/error");
 class ProgressPrinter {
     constructor(totalAssets, interval) {
         this.totalAssets = totalAssets;
@@ -28,6 +29,12 @@ class ProgressPrinter {
         this.deletedAssetsSizeMb += sizeInBytes / 1048576;
     }
     start() {
+        // If there is already a running setInterval, throw an error.
+        // This is because if this.setInterval is reassigned to another setInterval,
+        // the original setInterval remains and can no longer be cleared.
+        if (this.setInterval) {
+            throw new error_1.ToolkitError('ProgressPrinter is already running. Stop it first using the stop() method before starting it again.');
+        }
         this.setInterval = setInterval(() => {
             if (!this.isPaused) {
                 this.print();
@@ -59,4 +66,4 @@ class ProgressPrinter {
     }
 }
 exports.ProgressPrinter = ProgressPrinter;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/{import.d.ts → api/resource-import/importer.d.ts}

@@ -1,13 +1,54 @@
-import { DeployOptions } from '@aws-cdk/cloud-assembly-schema';
 import { ResourceDifference } from '@aws-cdk/cloudformation-diff';
 import * as cxapi from '@aws-cdk/cx-api';
-import { Deployments, DeploymentMethod, ResourceIdentifierProperties, ResourcesToImport } from './api/deployments';
-import { Tag } from './api/tags';
-import { StackActivityProgress } from './api/util/cloudformation/stack-activity-monitor';
-export interface ImportDeploymentOptions extends DeployOptions {
-    deploymentMethod?: DeploymentMethod;
-    progress?: StackActivityProgress;
-    tags?: Tag[];
+import { IIoHost, ToolkitAction } from '../../toolkit/cli-io-host';
+import { Deployments, DeploymentMethod, ResourceIdentifierProperties, ResourcesToImport } from '../deployments';
+import { Tag } from '../tags';
+import { StackActivityProgress } from '../util/cloudformation/stack-activity-monitor';
+export interface ResourceImporterProps {
+    deployments: Deployments;
+    ioHost: IIoHost;
+    action: ToolkitAction;
+}
+export interface ImportDeploymentOptions {
+    /**
+     * Role to pass to CloudFormation for deployment
+     *
+     * @default - Default stack role
+     */
+    readonly roleArn?: string;
+    /**
+     * Deployment method
+     *
+     * @default - Change set with default options
+     */
+    readonly deploymentMethod?: DeploymentMethod;
+    /**
+     * Stack tags (pass through to CloudFormation)
+     *
+     * @default - No tags
+     */
+    readonly tags?: Tag[];
+    /**
+     * Use previous values for unspecified parameters
+     *
+     * If not set, all parameters must be specified for every deployment.
+     *
+     * @default true
+     */
+    readonly usePreviousParameters?: boolean;
+    /**
+     * Display mode for stack deployment progress.
+     *
+     * @default - StackActivityProgress.Bar - stack events will be displayed for
+     *   the resource currently being deployed.
+     */
+    readonly progress?: StackActivityProgress;
+    /**
+     * Rollback failed deployments
+     *
+     * @default true
+     */
+    readonly rollback?: boolean;
 }
 /**
  * Set of parameters that uniquely identify a physical resource of a given type
@@ -53,10 +94,12 @@ export type ResourceMap = {
  *   importable resources, then run an IMPORT changeset.
  */
 export declare class ResourceImporter {
+    private _currentTemplate;
     private readonly stack;
     private readonly cfn;
-    private _currentTemplate;
-    constructor(stack: cxapi.CloudFormationStackArtifact, cfn: Deployments);
+    private readonly ioHost;
+    private readonly action;
+    constructor(stack: cxapi.CloudFormationStackArtifact, props: ResourceImporterProps);
     /**
      * Ask the user for resources to import
      */
@@ -72,7 +115,7 @@ export declare class ResourceImporter {
      * @param importMap Mapping from CDK construct tree path to physical resource import identifiers
      * @param options Options to pass to CloudFormation deploy operation
      */
-    importResourcesFromMap(importMap: ImportMap, options: ImportDeploymentOptions): Promise<void>;
+    importResourcesFromMap(importMap: ImportMap, options?: ImportDeploymentOptions): Promise<void>;
     /**
      * Based on the app and resources file generated by cdk migrate. Removes all items from the template that
      * cannot be included in an import change-set for new stacks and performs the import operation,
@@ -81,7 +124,7 @@ export declare class ResourceImporter {
      * @param resourcesToImport The mapping created by cdk migrate
      * @param options Options to pass to CloudFormation deploy operation
      */
-    importResourcesFromMigrate(resourcesToImport: ResourcesToImport, options: ImportDeploymentOptions): Promise<void>;
+    importResourcesFromMigrate(resourcesToImport: ResourcesToImport, options?: ImportDeploymentOptions): Promise<void>;
     private importResources;
     /**
      * Perform a diff between the currently running and the new template, ensure that it is valid

package/lib/api/resource-import/importer.js

@@ -0,0 +1,332 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResourceImporter = void 0;
+exports.removeNonImportResources = removeNonImportResources;
+const util_1 = require("util");
+const cfnDiff = require("@aws-cdk/cloudformation-diff");
+const chalk = require("chalk");
+const fs = require("fs-extra");
+const promptly = require("promptly");
+const messages_1 = require("../../cli/messages");
+const error_1 = require("../../toolkit/error");
+const deployments_1 = require("../deployments");
+/**
+ * Resource importing utility class
+ *
+ * - Determines the resources added to a template (compared to the deployed version)
+ * - Look up the identification information
+ *   - Load them from a file, or
+ *   - Ask the user, based on information supplied to us by CloudFormation's GetTemplateSummary
+ * - Translate the input to a structure expected by CloudFormation, update the template to add the
+ *   importable resources, then run an IMPORT changeset.
+ */
+class ResourceImporter {
+    constructor(stack, props) {
+        this.stack = stack;
+        this.cfn = props.deployments;
+        this.ioHost = props.ioHost;
+        this.action = props.action;
+    }
+    /**
+     * Ask the user for resources to import
+     */
+    async askForResourceIdentifiers(available) {
+        const ret = { importResources: [], resourceMap: {} };
+        const resourceIdentifiers = await this.resourceIdentifiers();
+        for (const resource of available) {
+            const identifier = await this.askForResourceIdentifier(resourceIdentifiers, resource);
+            if (!identifier) {
+                continue;
+            }
+            ret.importResources.push(resource);
+            ret.resourceMap[resource.logicalId] = identifier;
+        }
+        return ret;
+    }
+    /**
+     * Load the resources to import from a file
+     */
+    async loadResourceIdentifiers(available, filename) {
+        const contents = await fs.readJson(filename);
+        const ret = { importResources: [], resourceMap: {} };
+        for (const resource of available) {
+            const descr = this.describeResource(resource.logicalId);
+            const idProps = contents[resource.logicalId];
+            if (idProps) {
+                await this.ioHost.notify((0, messages_1.info)(this.action, (0, util_1.format)('%s: importing using %s', chalk.blue(descr), chalk.blue(fmtdict(idProps)))));
+                ret.importResources.push(resource);
+                ret.resourceMap[resource.logicalId] = idProps;
+                delete contents[resource.logicalId];
+            }
+            else {
+                await this.ioHost.notify((0, messages_1.info)(this.action, (0, util_1.format)('%s: skipping', chalk.blue(descr))));
+            }
+        }
+        const unknown = Object.keys(contents);
+        if (unknown.length > 0) {
+            await this.ioHost.notify((0, messages_1.warn)(this.action, `Unrecognized resource identifiers in mapping file: ${unknown.join(', ')}`));
+        }
+        return ret;
+    }
+    /**
+     * Based on the provided resource mapping, prepare CFN structures for import (template,
+     * ResourcesToImport structure) and perform the import operation (CloudFormation deployment)
+     *
+     * @param importMap Mapping from CDK construct tree path to physical resource import identifiers
+     * @param options Options to pass to CloudFormation deploy operation
+     */
+    async importResourcesFromMap(importMap, options = {}) {
+        const resourcesToImport = await this.makeResourcesToImport(importMap);
+        const updatedTemplate = await this.currentTemplateWithAdditions(importMap.importResources);
+        await this.importResources(updatedTemplate, resourcesToImport, options);
+    }
+    /**
+     * Based on the app and resources file generated by cdk migrate. Removes all items from the template that
+     * cannot be included in an import change-set for new stacks and performs the import operation,
+     * creating the new stack.
+     *
+     * @param resourcesToImport The mapping created by cdk migrate
+     * @param options Options to pass to CloudFormation deploy operation
+     */
+    async importResourcesFromMigrate(resourcesToImport, options = {}) {
+        const updatedTemplate = this.removeNonImportResources();
+        await this.importResources(updatedTemplate, resourcesToImport, options);
+    }
+    async importResources(overrideTemplate, resourcesToImport, options) {
+        try {
+            const result = await this.cfn.deployStack({
+                stack: this.stack,
+                deployName: this.stack.stackName,
+                ...options,
+                overrideTemplate,
+                resourcesToImport,
+            });
+            (0, deployments_1.assertIsSuccessfulDeployStackResult)(result);
+            const message = result.noOp
+                ? ' ✅  %s (no changes)'
+                : ' ✅  %s';
+            await this.ioHost.notify((0, messages_1.info)(this.action, '\n' + chalk.green((0, util_1.format)(message, this.stack.displayName))));
+        }
+        catch (e) {
+            await this.ioHost.notify((0, messages_1.error)(this.action, (0, util_1.format)('\n ❌  %s failed: %s', chalk.bold(this.stack.displayName), e), 'CDK_TOOLKIT_E3900'));
+            throw e;
+        }
+    }
+    /**
+     * Perform a diff between the currently running and the new template, ensure that it is valid
+     * for importing and return a list of resources that are being added in the new version
+     *
+     * @return mapping logicalResourceId -> resourceDifference
+     */
+    async discoverImportableResources(allowNonAdditions = false) {
+        const currentTemplate = await this.currentTemplate();
+        const diff = cfnDiff.fullDiff(currentTemplate, this.stack.template);
+        // Ignore changes to CDKMetadata
+        const resourceChanges = Object.entries(diff.resources.changes)
+            .filter(([logicalId, _]) => logicalId !== 'CDKMetadata');
+        // Split the changes into additions and non-additions. Imports only make sense
+        // for newly-added resources.
+        const nonAdditions = resourceChanges.filter(([_, dif]) => !dif.isAddition);
+        const additions = resourceChanges.filter(([_, dif]) => dif.isAddition);
+        if (nonAdditions.length) {
+            const offendingResources = nonAdditions.map(([logId, _]) => this.describeResource(logId));
+            if (allowNonAdditions) {
+                await this.ioHost.notify((0, messages_1.warn)(this.action, `Ignoring updated/deleted resources (--force): ${offendingResources.join(', ')}`));
+            }
+            else {
+                throw new error_1.ToolkitError('No resource updates or deletes are allowed on import operation. Make sure to resolve pending changes ' +
+                    `to existing resources, before attempting an import. Updated/deleted resources: ${offendingResources.join(', ')} (--force to override)`);
+            }
+        }
+        // Resources in the new template, that are not present in the current template, are a potential import candidates
+        return {
+            additions: additions.map(([logicalId, resourceDiff]) => ({
+                logicalId,
+                resourceDiff,
+                resourceDefinition: addDefaultDeletionPolicy(this.stack.template?.Resources?.[logicalId] ?? {}),
+            })),
+            hasNonAdditions: nonAdditions.length > 0,
+        };
+    }
+    /**
+     * Resolves the environment of a stack.
+     */
+    async resolveEnvironment() {
+        return this.cfn.resolveEnvironment(this.stack);
+    }
+    /**
+     * Get currently deployed template of the given stack (SINGLETON)
+     *
+     * @returns Currently deployed CloudFormation template
+     */
+    async currentTemplate() {
+        if (!this._currentTemplate) {
+            this._currentTemplate = await this.cfn.readCurrentTemplate(this.stack);
+        }
+        return this._currentTemplate;
+    }
+    /**
+     * Return the current template, with the given resources added to it
+     */
+    async currentTemplateWithAdditions(additions) {
+        const template = await this.currentTemplate();
+        if (!template.Resources) {
+            template.Resources = {};
+        }
+        for (const add of additions) {
+            template.Resources[add.logicalId] = add.resourceDefinition;
+        }
+        return template;
+    }
+    /**
+     * Get a list of import identifiers for all resource types used in the given
+     * template that do support the import operation (SINGLETON)
+     *
+     * @returns a mapping from a resource type to a list of property names that together identify the resource for import
+     */
+    async resourceIdentifiers() {
+        const ret = {};
+        const resourceIdentifierSummaries = await this.cfn.resourceIdentifierSummaries(this.stack);
+        for (const summary of resourceIdentifierSummaries) {
+            if ('ResourceType' in summary && summary.ResourceType && 'ResourceIdentifiers' in summary && summary.ResourceIdentifiers) {
+                ret[summary.ResourceType] = (summary.ResourceIdentifiers ?? [])?.map(x => x.split(','));
+            }
+        }
+        return ret;
+    }
+    /**
+     * Ask for the importable identifier for the given resource
+     *
+     * There may be more than one identifier under which a resource can be imported. The `import`
+     * operation needs exactly one of them.
+     *
+     * - If we can get one from the template, we will use one.
+     * - Otherwise, we will ask the user for one of them.
+     */
+    async askForResourceIdentifier(resourceIdentifiers, chg) {
+        const resourceName = this.describeResource(chg.logicalId);
+        // Skip resources that do not support importing
+        const resourceType = chg.resourceDiff.newResourceType;
+        if (resourceType === undefined || !(resourceType in resourceIdentifiers)) {
+            await this.ioHost.notify((0, messages_1.warn)(this.action, `${resourceName}: unsupported resource type ${resourceType}, skipping import.`));
+            return undefined;
+        }
+        const idPropSets = resourceIdentifiers[resourceType];
+        // Retain only literal strings: strip potential CFN intrinsics
+        const resourceProps = Object.fromEntries(Object.entries(chg.resourceDefinition.Properties ?? {})
+            .filter(([_, v]) => typeof v === 'string'));
+        // Find property sets that are fully satisfied in the template, ask the user to confirm them
+        const satisfiedPropSets = idPropSets.filter(ps => ps.every(p => resourceProps[p]));
+        for (const satisfiedPropSet of satisfiedPropSets) {
+            const candidateProps = Object.fromEntries(satisfiedPropSet.map(p => [p, resourceProps[p]]));
+            const displayCandidateProps = fmtdict(candidateProps);
+            if (await promptly.confirm(`${chalk.blue(resourceName)} (${resourceType}): import with ${chalk.yellow(displayCandidateProps)} (yes/no) [default: yes]? `, { default: 'yes' })) {
+                return candidateProps;
+            }
+        }
+        // If we got here and the user rejected any available identifiers, then apparently they don't want the resource at all
+        if (satisfiedPropSets.length > 0) {
+            await this.ioHost.notify((0, messages_1.info)(this.action, chalk.grey(`Skipping import of ${resourceName}`)));
+            return undefined;
+        }
+        // We cannot auto-import this, ask the user for one of the props
+        // The only difference between these cases is what we print: for multiple properties, we print a preamble
+        const prefix = `${chalk.blue(resourceName)} (${resourceType})`;
+        let preamble;
+        let promptPattern;
+        if (idPropSets.length > 1) {
+            preamble = `${prefix}: enter one of ${idPropSets.map(x => chalk.blue(x.join('+'))).join(', ')} to import (all empty to skip)`;
+            promptPattern = `${prefix}: enter %`;
+        }
+        else {
+            promptPattern = `${prefix}: enter %`;
+        }
+        // Do the input loop here
+        if (preamble) {
+            await this.ioHost.notify((0, messages_1.info)(this.action, preamble));
+        }
+        for (const idProps of idPropSets) {
+            const input = {};
+            for (const idProp of idProps) {
+                // If we have a value from the template, use it as default. This will only be a partial
+                // identifier if present, otherwise we would have done the import already above.
+                const defaultValue = resourceProps[idProp] ?? '';
+                const prompt = [
+                    promptPattern.replace(/%/g, chalk.blue(idProp)),
+                    defaultValue
+                        ? `[${defaultValue}]`
+                        : '(empty to skip)',
+                ].join(' ') + ':';
+                const response = await promptly.prompt(prompt, { default: defaultValue, trim: true });
+                if (!response) {
+                    break;
+                }
+                input[idProp] = response;
+                // Also stick this property into 'resourceProps', so that it may be reused by a subsequent question
+                // (for a different compound identifier that involves the same property). Just a small UX enhancement.
+                resourceProps[idProp] = response;
+            }
+            // If the user gave inputs for all values, we are complete
+            if (Object.keys(input).length === idProps.length) {
+                return input;
+            }
+        }
+        await this.ioHost.notify((0, messages_1.info)(this.action, chalk.grey(`Skipping import of ${resourceName}`)));
+        return undefined;
+    }
+    /**
+     * Convert the internal "resource mapping" structure to CloudFormation accepted "ResourcesToImport" structure
+     */
+    async makeResourcesToImport(resourceMap) {
+        return resourceMap.importResources.map(res => ({
+            LogicalResourceId: res.logicalId,
+            ResourceType: res.resourceDiff.newResourceType,
+            ResourceIdentifier: resourceMap.resourceMap[res.logicalId],
+        }));
+    }
+    /**
+     * Convert CloudFormation logical resource ID to CDK construct tree path
+     *
+     * @param logicalId CloudFormation logical ID of the resource (the key in the template's Resources section)
+     * @returns Forward-slash separated path of the resource in CDK construct tree, e.g. MyStack/MyBucket/Resource
+     */
+    describeResource(logicalId) {
+        return this.stack.template?.Resources?.[logicalId]?.Metadata?.['aws:cdk:path'] ?? logicalId;
+    }
+    /**
+     * Removes CDKMetadata and Outputs in the template so that only resources for importing are left.
+     * @returns template with import resources only
+     */
+    removeNonImportResources() {
+        return removeNonImportResources(this.stack);
+    }
+}
+exports.ResourceImporter = ResourceImporter;
+/**
+ * Removes CDKMetadata and Outputs in the template so that only resources for importing are left.
+ * @returns template with import resources only
+ */
+function removeNonImportResources(stack) {
+    const template = stack.template;
+    delete template.Resources.CDKMetadata;
+    delete template.Outputs;
+    return template;
+}
+function fmtdict(xs) {
+    return Object.entries(xs).map(([k, v]) => `${k}=${v}`).join(', ');
+}
+/**
+ * Add a default `DeletionPolicy` policy.
+ * The default value is set to 'Retain', to lower risk of unintentionally
+ * deleting stateful resources in the process of importing to CDK.
+ */
+function addDefaultDeletionPolicy(resource) {
+    if (resource.DeletionPolicy) {
+        return resource;
+    }
+    return {
+        ...resource,
+        DeletionPolicy: 'Retain',
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"importer.js","sourceRoot":"","sources":["importer.ts"],"names":[],"mappings":"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","sourcesContent":["import { format } from 'util';\nimport * as cfnDiff from '@aws-cdk/cloudformation-diff';\nimport { ResourceDifference } from '@aws-cdk/cloudformation-diff';\nimport * as cxapi from '@aws-cdk/cx-api';\nimport * as chalk from 'chalk';\nimport * as fs from 'fs-extra';\nimport * as promptly from 'promptly';\nimport { error, info, warn } from '../../cli/messages';\nimport { IIoHost, ToolkitAction } from '../../toolkit/cli-io-host';\nimport { ToolkitError } from '../../toolkit/error';\nimport { assertIsSuccessfulDeployStackResult, Deployments, DeploymentMethod, ResourceIdentifierProperties, ResourcesToImport } from '../deployments';\nimport { Tag } from '../tags';\nimport { StackActivityProgress } from '../util/cloudformation/stack-activity-monitor';\n\nexport interface ResourceImporterProps {\n  deployments: Deployments;\n  ioHost: IIoHost;\n  action: ToolkitAction;\n}\n\nexport interface ImportDeploymentOptions {\n  /**\n   * Role to pass to CloudFormation for deployment\n   *\n   * @default - Default stack role\n   */\n  readonly roleArn?: string;\n\n  /**\n   * Deployment method\n   *\n   * @default - Change set with default options\n   */\n  readonly deploymentMethod?: DeploymentMethod;\n\n  /**\n   * Stack tags (pass through to CloudFormation)\n   *\n   * @default - No tags\n   */\n  readonly tags?: Tag[];\n\n  /**\n   * Use previous values for unspecified parameters\n   *\n   * If not set, all parameters must be specified for every deployment.\n   *\n   * @default true\n   */\n  readonly usePreviousParameters?: boolean;\n\n  /**\n   * Display mode for stack deployment progress.\n   *\n   * @default - StackActivityProgress.Bar - stack events will be displayed for\n   *   the resource currently being deployed.\n   */\n  readonly progress?: StackActivityProgress;\n\n  /**\n   * Rollback failed deployments\n   *\n   * @default true\n   */\n  readonly rollback?: boolean;\n}\n\n/**\n * Set of parameters that uniquely identify a physical resource of a given type\n * for the import operation, example:\n *\n * ```\n * {\n *   \"AWS::S3::Bucket\": [[\"BucketName\"]],\n *   \"AWS::DynamoDB::GlobalTable\": [[\"TableName\"], [\"TableArn\"], [\"TableStreamArn\"]],\n *   \"AWS::Route53::KeySigningKey\": [[\"HostedZoneId\", \"Name\"]],\n * }\n * ```\n */\nexport type ResourceIdentifiers = { [resourceType: string]: string[][] };\n\n/**\n * Mapping of CDK resources (L1 constructs) to physical resources to be imported\n * in their place, example:\n *\n * ```\n * {\n *   \"MyStack/MyS3Bucket/Resource\": {\n *     \"BucketName\": \"my-manually-created-s3-bucket\"\n *   },\n *   \"MyStack/MyVpc/Resource\": {\n *     \"VpcId\": \"vpc-123456789\"\n *   }\n * }\n * ```\n */\nexport type ResourceMap = { [logicalResource: string]: ResourceIdentifierProperties };\n\n/**\n * Resource importing utility class\n *\n * - Determines the resources added to a template (compared to the deployed version)\n * - Look up the identification information\n *   - Load them from a file, or\n *   - Ask the user, based on information supplied to us by CloudFormation's GetTemplateSummary\n * - Translate the input to a structure expected by CloudFormation, update the template to add the\n *   importable resources, then run an IMPORT changeset.\n */\nexport class ResourceImporter {\n  private _currentTemplate: any;\n\n  private readonly stack: cxapi.CloudFormationStackArtifact;\n  private readonly cfn: Deployments;\n  private readonly ioHost: IIoHost;\n  private readonly action: ToolkitAction;\n\n  constructor(\n    stack: cxapi.CloudFormationStackArtifact,\n    props: ResourceImporterProps,\n  ) {\n    this.stack = stack;\n    this.cfn = props.deployments;\n    this.ioHost = props.ioHost;\n    this.action = props.action;\n  }\n\n  /**\n   * Ask the user for resources to import\n   */\n  public async askForResourceIdentifiers(available: ImportableResource[]): Promise<ImportMap> {\n    const ret: ImportMap = { importResources: [], resourceMap: {} };\n    const resourceIdentifiers = await this.resourceIdentifiers();\n\n    for (const resource of available) {\n      const identifier = await this.askForResourceIdentifier(resourceIdentifiers, resource);\n      if (!identifier) {\n        continue;\n      }\n\n      ret.importResources.push(resource);\n      ret.resourceMap[resource.logicalId] = identifier;\n    }\n\n    return ret;\n  }\n\n  /**\n   * Load the resources to import from a file\n   */\n  public async loadResourceIdentifiers(available: ImportableResource[], filename: string): Promise<ImportMap> {\n    const contents = await fs.readJson(filename);\n\n    const ret: ImportMap = { importResources: [], resourceMap: {} };\n    for (const resource of available) {\n      const descr = this.describeResource(resource.logicalId);\n      const idProps = contents[resource.logicalId];\n      if (idProps) {\n        await this.ioHost.notify(info(this.action, format('%s: importing using %s', chalk.blue(descr), chalk.blue(fmtdict(idProps)))));\n\n        ret.importResources.push(resource);\n        ret.resourceMap[resource.logicalId] = idProps;\n        delete contents[resource.logicalId];\n      } else {\n        await this.ioHost.notify(info(this.action, format('%s: skipping', chalk.blue(descr))));\n      }\n    }\n\n    const unknown = Object.keys(contents);\n    if (unknown.length > 0) {\n      await this.ioHost.notify(warn(this.action, `Unrecognized resource identifiers in mapping file: ${unknown.join(', ')}`));\n    }\n\n    return ret;\n  }\n\n  /**\n   * Based on the provided resource mapping, prepare CFN structures for import (template,\n   * ResourcesToImport structure) and perform the import operation (CloudFormation deployment)\n   *\n   * @param importMap Mapping from CDK construct tree path to physical resource import identifiers\n   * @param options Options to pass to CloudFormation deploy operation\n   */\n  public async importResourcesFromMap(importMap: ImportMap, options: ImportDeploymentOptions = {}) {\n    const resourcesToImport: ResourcesToImport = await this.makeResourcesToImport(importMap);\n    const updatedTemplate = await this.currentTemplateWithAdditions(importMap.importResources);\n\n    await this.importResources(updatedTemplate, resourcesToImport, options);\n  }\n\n  /**\n   * Based on the app and resources file generated by cdk migrate. Removes all items from the template that\n   * cannot be included in an import change-set for new stacks and performs the import operation,\n   * creating the new stack.\n   *\n   * @param resourcesToImport The mapping created by cdk migrate\n   * @param options Options to pass to CloudFormation deploy operation\n   */\n  public async importResourcesFromMigrate(resourcesToImport: ResourcesToImport, options: ImportDeploymentOptions = {}) {\n    const updatedTemplate = this.removeNonImportResources();\n\n    await this.importResources(updatedTemplate, resourcesToImport, options);\n  }\n\n  private async importResources(overrideTemplate: any, resourcesToImport: ResourcesToImport, options: ImportDeploymentOptions) {\n    try {\n      const result = await this.cfn.deployStack({\n        stack: this.stack,\n        deployName: this.stack.stackName,\n        ...options,\n        overrideTemplate,\n        resourcesToImport,\n      });\n\n      assertIsSuccessfulDeployStackResult(result);\n\n      const message = result.noOp\n        ? ' ✅  %s (no changes)'\n        : ' ✅  %s';\n\n      await this.ioHost.notify(info(this.action, '\\n' + chalk.green(format(message, this.stack.displayName))));\n    } catch (e) {\n      await this.ioHost.notify(error(this.action, format('\\n ❌  %s failed: %s', chalk.bold(this.stack.displayName), e), 'CDK_TOOLKIT_E3900'));\n      throw e;\n    }\n  }\n\n  /**\n   * Perform a diff between the currently running and the new template, ensure that it is valid\n   * for importing and return a list of resources that are being added in the new version\n   *\n   * @return mapping logicalResourceId -> resourceDifference\n   */\n  public async discoverImportableResources(allowNonAdditions = false): Promise<DiscoverImportableResourcesResult> {\n    const currentTemplate = await this.currentTemplate();\n\n    const diff = cfnDiff.fullDiff(currentTemplate, this.stack.template);\n\n    // Ignore changes to CDKMetadata\n    const resourceChanges = Object.entries(diff.resources.changes)\n      .filter(([logicalId, _]) => logicalId !== 'CDKMetadata');\n\n    // Split the changes into additions and non-additions. Imports only make sense\n    // for newly-added resources.\n    const nonAdditions = resourceChanges.filter(([_, dif]) => !dif.isAddition);\n    const additions = resourceChanges.filter(([_, dif]) => dif.isAddition);\n\n    if (nonAdditions.length) {\n      const offendingResources = nonAdditions.map(([logId, _]) => this.describeResource(logId));\n\n      if (allowNonAdditions) {\n        await this.ioHost.notify(warn(this.action, `Ignoring updated/deleted resources (--force): ${offendingResources.join(', ')}`));\n      } else {\n        throw new ToolkitError('No resource updates or deletes are allowed on import operation. Make sure to resolve pending changes ' +\n          `to existing resources, before attempting an import. Updated/deleted resources: ${offendingResources.join(', ')} (--force to override)`);\n      }\n    }\n\n    // Resources in the new template, that are not present in the current template, are a potential import candidates\n    return {\n      additions: additions.map(([logicalId, resourceDiff]) => ({\n        logicalId,\n        resourceDiff,\n        resourceDefinition: addDefaultDeletionPolicy(this.stack.template?.Resources?.[logicalId] ?? {}),\n      })),\n      hasNonAdditions: nonAdditions.length > 0,\n    };\n  }\n\n  /**\n   * Resolves the environment of a stack.\n   */\n  public async resolveEnvironment(): Promise<cxapi.Environment> {\n    return this.cfn.resolveEnvironment(this.stack);\n  }\n\n  /**\n   * Get currently deployed template of the given stack (SINGLETON)\n   *\n   * @returns Currently deployed CloudFormation template\n   */\n  private async currentTemplate(): Promise<any> {\n    if (!this._currentTemplate) {\n      this._currentTemplate = await this.cfn.readCurrentTemplate(this.stack);\n    }\n    return this._currentTemplate;\n  }\n\n  /**\n   * Return the current template, with the given resources added to it\n   */\n  private async currentTemplateWithAdditions(additions: ImportableResource[]): Promise<any> {\n    const template = await this.currentTemplate();\n    if (!template.Resources) {\n      template.Resources = {};\n    }\n\n    for (const add of additions) {\n      template.Resources[add.logicalId] = add.resourceDefinition;\n    }\n\n    return template;\n  }\n\n  /**\n   * Get a list of import identifiers for all resource types used in the given\n   * template that do support the import operation (SINGLETON)\n   *\n   * @returns a mapping from a resource type to a list of property names that together identify the resource for import\n   */\n  private async resourceIdentifiers(): Promise<ResourceIdentifiers> {\n    const ret: ResourceIdentifiers = {};\n    const resourceIdentifierSummaries = await this.cfn.resourceIdentifierSummaries(this.stack);\n    for (const summary of resourceIdentifierSummaries) {\n      if ('ResourceType' in summary && summary.ResourceType && 'ResourceIdentifiers' in summary && summary.ResourceIdentifiers) {\n        ret[summary.ResourceType] = (summary.ResourceIdentifiers ?? [])?.map(x => x.split(','));\n      }\n    }\n    return ret;\n  }\n\n  /**\n   * Ask for the importable identifier for the given resource\n   *\n   * There may be more than one identifier under which a resource can be imported. The `import`\n   * operation needs exactly one of them.\n   *\n   * - If we can get one from the template, we will use one.\n   * - Otherwise, we will ask the user for one of them.\n   */\n  private async askForResourceIdentifier(\n    resourceIdentifiers: ResourceIdentifiers,\n    chg: ImportableResource,\n  ): Promise<ResourceIdentifierProperties | undefined> {\n    const resourceName = this.describeResource(chg.logicalId);\n\n    // Skip resources that do not support importing\n    const resourceType = chg.resourceDiff.newResourceType;\n    if (resourceType === undefined || !(resourceType in resourceIdentifiers)) {\n      await this.ioHost.notify(warn(this.action, `${resourceName}: unsupported resource type ${resourceType}, skipping import.`));\n      return undefined;\n    }\n\n    const idPropSets = resourceIdentifiers[resourceType];\n\n    // Retain only literal strings: strip potential CFN intrinsics\n    const resourceProps = Object.fromEntries(Object.entries(chg.resourceDefinition.Properties ?? {})\n      .filter(([_, v]) => typeof v === 'string')) as Record<string, string>;\n\n    // Find property sets that are fully satisfied in the template, ask the user to confirm them\n    const satisfiedPropSets = idPropSets.filter(ps => ps.every(p => resourceProps[p]));\n    for (const satisfiedPropSet of satisfiedPropSets) {\n      const candidateProps = Object.fromEntries(satisfiedPropSet.map(p => [p, resourceProps[p]]));\n      const displayCandidateProps = fmtdict(candidateProps);\n\n      if (await promptly.confirm(\n        `${chalk.blue(resourceName)} (${resourceType}): import with ${chalk.yellow(displayCandidateProps)} (yes/no) [default: yes]? `,\n        { default: 'yes' },\n      )) {\n        return candidateProps;\n      }\n    }\n\n    // If we got here and the user rejected any available identifiers, then apparently they don't want the resource at all\n    if (satisfiedPropSets.length > 0) {\n      await this.ioHost.notify(info(this.action, chalk.grey(`Skipping import of ${resourceName}`)));\n      return undefined;\n    }\n\n    // We cannot auto-import this, ask the user for one of the props\n    // The only difference between these cases is what we print: for multiple properties, we print a preamble\n    const prefix = `${chalk.blue(resourceName)} (${resourceType})`;\n    let preamble;\n    let promptPattern;\n    if (idPropSets.length > 1) {\n      preamble = `${prefix}: enter one of ${idPropSets.map(x => chalk.blue(x.join('+'))).join(', ')} to import (all empty to skip)`;\n      promptPattern = `${prefix}: enter %`;\n    } else {\n      promptPattern = `${prefix}: enter %`;\n    }\n\n    // Do the input loop here\n    if (preamble) {\n      await this.ioHost.notify(info(this.action, preamble));\n    }\n    for (const idProps of idPropSets) {\n      const input: Record<string, string> = {};\n      for (const idProp of idProps) {\n        // If we have a value from the template, use it as default. This will only be a partial\n        // identifier if present, otherwise we would have done the import already above.\n        const defaultValue = resourceProps[idProp] ?? '';\n\n        const prompt = [\n          promptPattern.replace(/%/g, chalk.blue(idProp)),\n          defaultValue\n            ? `[${defaultValue}]`\n            : '(empty to skip)',\n        ].join(' ') + ':';\n        const response = await promptly.prompt(prompt,\n          { default: defaultValue, trim: true },\n        );\n\n        if (!response) {\n          break;\n        }\n\n        input[idProp] = response;\n        // Also stick this property into 'resourceProps', so that it may be reused by a subsequent question\n        // (for a different compound identifier that involves the same property). Just a small UX enhancement.\n        resourceProps[idProp] = response;\n      }\n\n      // If the user gave inputs for all values, we are complete\n      if (Object.keys(input).length === idProps.length) {\n        return input;\n      }\n    }\n\n    await this.ioHost.notify(info(this.action, chalk.grey(`Skipping import of ${resourceName}`)));\n    return undefined;\n  }\n\n  /**\n   * Convert the internal \"resource mapping\" structure to CloudFormation accepted \"ResourcesToImport\" structure\n   */\n  private async makeResourcesToImport(resourceMap: ImportMap): Promise<ResourcesToImport> {\n    return resourceMap.importResources.map(res => ({\n      LogicalResourceId: res.logicalId,\n      ResourceType: res.resourceDiff.newResourceType!,\n      ResourceIdentifier: resourceMap.resourceMap[res.logicalId],\n    }));\n  }\n\n  /**\n   * Convert CloudFormation logical resource ID to CDK construct tree path\n   *\n   * @param logicalId CloudFormation logical ID of the resource (the key in the template's Resources section)\n   * @returns Forward-slash separated path of the resource in CDK construct tree, e.g. MyStack/MyBucket/Resource\n   */\n  private describeResource(logicalId: string): string {\n    return this.stack.template?.Resources?.[logicalId]?.Metadata?.['aws:cdk:path'] ?? logicalId;\n  }\n\n  /**\n   * Removes CDKMetadata and Outputs in the template so that only resources for importing are left.\n   * @returns template with import resources only\n   */\n  private removeNonImportResources() {\n    return removeNonImportResources(this.stack);\n  }\n}\n\n/**\n * Removes CDKMetadata and Outputs in the template so that only resources for importing are left.\n * @returns template with import resources only\n */\nexport function removeNonImportResources(stack: cxapi.CloudFormationStackArtifact) {\n  const template = stack.template;\n  delete template.Resources.CDKMetadata;\n  delete template.Outputs;\n  return template;\n}\n\n/**\n * Information about a resource in the template that is importable\n */\nexport interface ImportableResource {\n  /**\n   * The logical ID of the resource\n   */\n  readonly logicalId: string;\n\n  /**\n   * The resource definition in the new template\n   */\n  readonly resourceDefinition: any;\n\n  /**\n   * The diff as reported by `cloudformation-diff`.\n   */\n  readonly resourceDiff: ResourceDifference;\n}\n\n/**\n * The information necessary to execute an import operation\n */\nexport interface ImportMap {\n  /**\n   * Mapping logical IDs to physical names\n   */\n  readonly resourceMap: ResourceMap;\n\n  /**\n   * The selection of resources we are actually importing\n   *\n   * For each of the resources in this list, there is a corresponding entry in\n   * the `resourceMap` map.\n   */\n  readonly importResources: ImportableResource[];\n}\n\nfunction fmtdict<A>(xs: Record<string, A>) {\n  return Object.entries(xs).map(([k, v]) => `${k}=${v}`).join(', ');\n}\n\n/**\n * Add a default `DeletionPolicy` policy.\n * The default value is set to 'Retain', to lower risk of unintentionally\n * deleting stateful resources in the process of importing to CDK.\n */\nfunction addDefaultDeletionPolicy(resource: any): any {\n  if (resource.DeletionPolicy) { return resource; }\n\n  return {\n    ...resource,\n    DeletionPolicy: 'Retain',\n  };\n}\n\nexport interface DiscoverImportableResourcesResult {\n  readonly additions: ImportableResource[];\n  readonly hasNonAdditions: boolean;\n}\n"]}

package/lib/api/resource-import/index.d.ts

@@ -0,0 +1,2 @@
+export * from './importer';
+export * from './migrator';

package/lib/api/resource-import/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("./importer"), exports);
+__exportStar(require("./migrator"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJpbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7O0FBQUEsNkNBQTJCO0FBQzNCLDZDQUEyQiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vaW1wb3J0ZXInO1xuZXhwb3J0ICogZnJvbSAnLi9taWdyYXRvcic7XG4iXX0=

package/lib/{migrator.d.ts → api/resource-import/migrator.d.ts}

@@ -1,13 +1,17 @@
 import type * as cxapi from '@aws-cdk/cx-api';
-import { StackCollection } from './api/cxapp/cloud-assembly';
-import { Deployments, ResourcesToImport } from './api/deployments';
-import { DeployOptions } from './cli/cdk-toolkit';
+import { ImportDeploymentOptions } from './importer';
+import type { IIoHost, ToolkitAction } from '../../toolkit/cli-io-host';
+import { StackCollection } from '../cxapp/cloud-assembly';
+import { Deployments, ResourcesToImport } from '../deployments';
 export interface ResourceMigratorProps {
     deployments: Deployments;
+    ioHost: IIoHost;
+    action: ToolkitAction;
 }
-type ResourceMigratorOptions = Pick<DeployOptions, 'roleArn' | 'toolkitStackName' | 'deploymentMethod' | 'progress' | 'rollback'>;
 export declare class ResourceMigrator {
     private readonly props;
+    private readonly ioHost;
+    private readonly action;
     constructor(props: ResourceMigratorProps);
     /**
      * Checks to see if a migrate.json file exists. If it does and the source is either `filepath` or
@@ -15,11 +19,10 @@ export declare class ResourceMigrator {
      * migrated to the stack using an IMPORT changeset. The normal deployment will resume after this is complete
      * to add back in any outputs and the CDKMetadata.
      */
-    tryMigrateResources(stacks: StackCollection, options: ResourceMigratorOptions): Promise<void>;
+    tryMigrateResources(stacks: StackCollection, options: ImportDeploymentOptions): Promise<void>;
     /**
      * Creates a new stack with just the resources to be migrated
      */
     private performResourceMigration;
     tryGetResources(environment: cxapi.Environment): Promise<ResourcesToImport | undefined>;
 }
-export {};