aws-cdk 2.19.0 → 2.20.0

package/lib/import.d.ts

@@ -0,0 +1,151 @@
+import { ResourceDifference } from '@aws-cdk/cloudformation-diff';
+import * as cxapi from '@aws-cdk/cx-api';
+import { CloudFormationDeployments, DeployStackOptions } from './api/cloudformation-deployments';
+import { ResourceIdentifierProperties } from './api/util/cloudformation';
+/**
+ * Parameters that uniquely identify a physical resource of a given type
+ * for the import operation, example:
+ *
+ * ```
+ * {
+ *   "AWS::S3::Bucket": ["BucketName"],
+ *   "AWS::IAM::Role": ["RoleName"],
+ *   "AWS::EC2::VPC": ["VpcId"]
+ * }
+ * ```
+ */
+export declare type ResourceIdentifiers = {
+    [resourceType: string]: string[];
+};
+/**
+ * Mapping of CDK resources (L1 constructs) to physical resources to be imported
+ * in their place, example:
+ *
+ * ```
+ * {
+ *   "MyStack/MyS3Bucket/Resource": {
+ *     "BucketName": "my-manually-created-s3-bucket"
+ *   },
+ *   "MyStack/MyVpc/Resource": {
+ *     "VpcId": "vpc-123456789"
+ *   }
+ * }
+ * ```
+ */
+export declare type ResourceMap = {
+    [logicalResource: string]: ResourceIdentifierProperties;
+};
+export interface ResourceImporterOptions {
+    /**
+     * Name of toolkit stack if non-default
+     *
+     * @default - Default toolkit stack name
+     */
+    readonly toolkitStackName?: string;
+}
+/**
+ * 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.
+ */
+export declare class ResourceImporter {
+    private readonly stack;
+    private readonly cfn;
+    private readonly options;
+    private _currentTemplate;
+    constructor(stack: cxapi.CloudFormationStackArtifact, cfn: CloudFormationDeployments, options?: ResourceImporterOptions);
+    /**
+     * Ask the user for resources to import
+     */
+    askForResourceIdentifiers(available: ImportableResource[]): Promise<ImportMap>;
+    /**
+     * Load the resources to import from a file
+     */
+    loadResourceIdentifiers(available: ImportableResource[], filename: string): Promise<ImportMap>;
+    /**
+     * Based on the provided resource mapping, prepare CFN structures for import (template,
+     * ResourcesToImport structure) and perform the import operation (CloudFormation deployment)
+     *
+     * @param resourceMap Mapping from CDK construct tree path to physical resource import identifiers
+     * @param options Options to pass to CloudFormation deploy operation
+     */
+    importResources(importMap: ImportMap, options: DeployStackOptions): Promise<void>;
+    /**
+     * Perform a diff between the currently running and the new template, enusre that it is valid
+     * for importing and return a list of resources that are being added in the new version
+     *
+     * @return mapping logicalResourceId -> resourceDifference
+     */
+    discoverImportableResources(allowNonAdditions?: boolean): Promise<DiscoverImportableResourcesResult>;
+    /**
+     * Get currently deployed template of the given stack (SINGLETON)
+     *
+     * @returns Currently deployed CloudFormation template
+     */
+    private currentTemplate;
+    /**
+     * Return teh current template, with the given resources added to it
+     */
+    private currentTemplateWithAdditions;
+    /**
+     * 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
+     */
+    private resourceIdentifiers;
+    private askForResourceIdentifier;
+    /**
+     * Convert the internal "resource mapping" structure to CloudFormation accepted "ResourcesToImport" structure
+     */
+    private makeResourcesToImport;
+    /**
+     * 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
+     */
+    private describeResource;
+}
+/**
+ * Information about a resource in the template that is importable
+ */
+export interface ImportableResource {
+    /**
+     * The logical ID of the resource
+     */
+    readonly logicalId: string;
+    /**
+     * The resource definition in the new template
+     */
+    readonly resourceDefinition: any;
+    /**
+     * The diff as reported by `cloudformation-diff`.
+     */
+    readonly resourceDiff: ResourceDifference;
+}
+/**
+ * The information necessary to execute an import operation
+ */
+export interface ImportMap {
+    /**
+     * Mapping logical IDs to physical names
+     */
+    readonly resourceMap: ResourceMap;
+    /**
+     * The selection of resources we are actually importing
+     *
+     * For each of the resources in this list, there is a corresponding entry in
+     * the `resourceMap` map.
+     */
+    readonly importResources: ImportableResource[];
+}
+export interface DiscoverImportableResourcesResult {
+    readonly additions: ImportableResource[];
+    readonly hasNonAdditions: boolean;
+}

package/lib/import.js

@@ -0,0 +1,245 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResourceImporter = void 0;
+const cfnDiff = require("@aws-cdk/cloudformation-diff");
+const chalk = require("chalk");
+const fs = require("fs-extra");
+const promptly = require("promptly");
+const logging_1 = require("./logging");
+/**
+ * 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, cfn, options = {}) {
+        this.stack = stack;
+        this.cfn = cfn;
+        this.options = options;
+    }
+    /**
+     * 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) {
+                logging_1.print('%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 {
+                logging_1.print('%s: skipping', chalk.blue(descr));
+            }
+        }
+        const unknown = Object.keys(contents);
+        if (unknown.length > 0) {
+            logging_1.warning(`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 resourceMap Mapping from CDK construct tree path to physical resource import identifiers
+     * @param options Options to pass to CloudFormation deploy operation
+     */
+    async importResources(importMap, options) {
+        const resourcesToImport = await this.makeResourcesToImport(importMap);
+        const updatedTemplate = await this.currentTemplateWithAdditions(importMap.importResources);
+        try {
+            const result = await this.cfn.deployStack({
+                ...options,
+                overrideTemplate: updatedTemplate,
+                resourcesToImport,
+            });
+            const message = result.noOp
+                ? ' ✅  %s (no changes)'
+                : ' ✅  %s';
+            logging_1.success('\n' + message, options.stack.displayName);
+        }
+        catch (e) {
+            logging_1.error('\n ❌  %s failed: %s', chalk.bold(options.stack.displayName), e);
+            throw e;
+        }
+    }
+    /**
+     * Perform a diff between the currently running and the new template, enusre 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.diffTemplate(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) {
+                logging_1.warning(`Ignoring updated/deleted resources (--force): ${offendingResources.join(', ')}`);
+            }
+            else {
+                throw new Error('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]) => {
+                var _a, _b, _c;
+                return ({
+                    logicalId,
+                    resourceDiff,
+                    resourceDefinition: addDefaultDeletionPolicy((_c = (_b = (_a = this.stack.template) === null || _a === void 0 ? void 0 : _a.Resources) === null || _b === void 0 ? void 0 : _b[logicalId]) !== null && _c !== void 0 ? _c : {}),
+                });
+            }),
+            hasNonAdditions: nonAdditions.length > 0,
+        };
+    }
+    /**
+     * 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 teh 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, this.options.toolkitStackName);
+        for (const summary of resourceIdentifierSummaries) {
+            if ('ResourceType' in summary && summary.ResourceType && 'ResourceIdentifiers' in summary && summary.ResourceIdentifiers) {
+                ret[summary.ResourceType] = summary.ResourceIdentifiers;
+            }
+        }
+        return ret;
+    }
+    async askForResourceIdentifier(resourceIdentifiers, chg) {
+        var _a;
+        const resourceName = this.describeResource(chg.logicalId);
+        // Skip resources that do not support importing
+        const resourceType = chg.resourceDiff.newResourceType;
+        if (resourceType === undefined || !(resourceType in resourceIdentifiers)) {
+            logging_1.warning(`${resourceName}: unsupported resource type ${resourceType}, skipping import.`);
+            return undefined;
+        }
+        const idProps = resourceIdentifiers[resourceType];
+        const resourceProps = (_a = chg.resourceDefinition.Properties) !== null && _a !== void 0 ? _a : {};
+        const fixedIdProps = idProps.filter(p => resourceProps[p]);
+        const fixedIdInput = Object.fromEntries(fixedIdProps.map(p => [p, resourceProps[p]]));
+        const missingIdProps = idProps.filter(p => !resourceProps[p]);
+        if (missingIdProps.length === 0) {
+            // We can auto-import this, but ask the user to confirm
+            const props = fmtdict(fixedIdInput);
+            if (!await promptly.confirm(`${chalk.blue(resourceName)} (${resourceType}): import with ${chalk.yellow(props)} (yes/no) [default: yes]? `, { default: 'yes' })) {
+                logging_1.print(chalk.grey(`Skipping import of ${resourceName}`));
+                return undefined;
+            }
+        }
+        // Ask the user to provide missing props
+        const userInput = {};
+        for (const missingIdProp of missingIdProps) {
+            const response = (await promptly.prompt(`${chalk.blue(resourceName)} (${resourceType}): enter ${chalk.blue(missingIdProp)} to import (empty to skip):`, { default: '', trim: true }));
+            if (!response) {
+                logging_1.print(chalk.grey(`Skipping import of ${resourceName}`));
+                return undefined;
+            }
+            userInput[missingIdProp] = response;
+        }
+        return {
+            ...fixedIdInput,
+            ...userInput,
+        };
+    }
+    /**
+     * 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) {
+        var _a, _b, _c, _d, _e;
+        return (_e = (_d = (_c = (_b = (_a = this.stack.template) === null || _a === void 0 ? void 0 : _a.Resources) === null || _b === void 0 ? void 0 : _b[logicalId]) === null || _c === void 0 ? void 0 : _c.Metadata) === null || _d === void 0 ? void 0 : _d['aws:cdk:path']) !== null && _e !== void 0 ? _e : logicalId;
+    }
+}
+exports.ResourceImporter = ResourceImporter;
+function fmtdict(xs) {
+    return Object.entries(xs).map(([k, v]) => `${k}=${v}`).join(', ');
+}
+/**
+ * Add a default 'Delete' policy, which is required to make the import succeed
+ */
+function addDefaultDeletionPolicy(resource) {
+    if (resource.DeletionPolicy) {
+        return resource;
+    }
+    return {
+        ...resource,
+        DeletionPolicy: 'Delete',
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"import.js","sourceRoot":"","sources":["import.ts"],"names":[],"mappings":"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","sourcesContent":["import * 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 { CloudFormationDeployments, DeployStackOptions } from './api/cloudformation-deployments';\nimport { ResourceIdentifierProperties, ResourcesToImport } from './api/util/cloudformation';\nimport { error, print, success, warning } from './logging';\n\n/**\n * 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::IAM::Role\": [\"RoleName\"],\n *   \"AWS::EC2::VPC\": [\"VpcId\"]\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\nexport interface ResourceImporterOptions {\n  /**\n   * Name of toolkit stack if non-default\n   *\n   * @default - Default toolkit stack name\n   */\n  readonly toolkitStackName?: string;\n}\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  constructor(\n    private readonly stack: cxapi.CloudFormationStackArtifact,\n    private readonly cfn: CloudFormationDeployments,\n    private readonly options: ResourceImporterOptions = {}) { }\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        print('%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        print('%s: skipping', chalk.blue(descr));\n      }\n    }\n\n    const unknown = Object.keys(contents);\n    if (unknown.length > 0) {\n      warning(`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 resourceMap 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 importResources(importMap: ImportMap, options: DeployStackOptions) {\n    const resourcesToImport: ResourcesToImport = await this.makeResourcesToImport(importMap);\n    const updatedTemplate = await this.currentTemplateWithAdditions(importMap.importResources);\n\n    try {\n      const result = await this.cfn.deployStack({\n        ...options,\n        overrideTemplate: updatedTemplate,\n        resourcesToImport,\n      });\n\n      const message = result.noOp\n        ? ' ✅  %s (no changes)'\n        : ' ✅  %s';\n\n      success('\\n' + message, options.stack.displayName);\n    } catch (e) {\n      error('\\n ❌  %s failed: %s', chalk.bold(options.stack.displayName), e);\n      throw e;\n    }\n  }\n\n  /**\n   * Perform a diff between the currently running and the new template, enusre 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.diffTemplate(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        warning(`Ignoring updated/deleted resources (--force): ${offendingResources.join(', ')}`);\n      } else {\n        throw new Error('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   * 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 teh 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, this.options.toolkitStackName);\n    for (const summary of resourceIdentifierSummaries) {\n      if ('ResourceType' in summary && summary.ResourceType && 'ResourceIdentifiers' in summary && summary.ResourceIdentifiers) {\n        ret[summary.ResourceType] = summary.ResourceIdentifiers;\n      }\n    }\n    return ret;\n  }\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      warning(`${resourceName}: unsupported resource type ${resourceType}, skipping import.`);\n      return undefined;\n    }\n\n    const idProps = resourceIdentifiers[resourceType];\n    const resourceProps = chg.resourceDefinition.Properties ?? {};\n\n    const fixedIdProps = idProps.filter(p => resourceProps[p]);\n    const fixedIdInput: ResourceIdentifierProperties = Object.fromEntries(fixedIdProps.map(p => [p, resourceProps[p]]));\n\n    const missingIdProps = idProps.filter(p => !resourceProps[p]);\n\n    if (missingIdProps.length === 0) {\n      // We can auto-import this, but ask the user to confirm\n      const props = fmtdict(fixedIdInput);\n\n      if (!await promptly.confirm(\n        `${chalk.blue(resourceName)} (${resourceType}): import with ${chalk.yellow(props)} (yes/no) [default: yes]? `,\n        { default: 'yes' },\n      )) {\n        print(chalk.grey(`Skipping import of ${resourceName}`));\n        return undefined;\n      }\n    }\n\n    // Ask the user to provide missing props\n    const userInput: ResourceIdentifierProperties = {};\n    for (const missingIdProp of missingIdProps) {\n      const response = (await promptly.prompt(\n        `${chalk.blue(resourceName)} (${resourceType}): enter ${chalk.blue(missingIdProp)} to import (empty to skip):`,\n        { default: '', trim: true },\n      ));\n      if (!response) {\n        print(chalk.grey(`Skipping import of ${resourceName}`));\n        return undefined;\n      }\n      userInput[missingIdProp] = response;\n    }\n\n    return {\n      ...fixedIdInput,\n      ...userInput,\n    };\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/**\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 'Delete' policy, which is required to make the import succeed\n */\nfunction addDefaultDeletionPolicy(resource: any): any {\n  if (resource.DeletionPolicy) { return resource; }\n\n  return {\n    ...resource,\n    DeletionPolicy: 'Delete',\n  };\n}\n\nexport interface DiscoverImportableResourcesResult {\n  readonly additions: ImportableResource[];\n  readonly hasNonAdditions: boolean;\n}"]}