@depup/aws-cdk 2.1117.0-depup.0

package/lib/commands/migrate.js

@@ -0,0 +1,801 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FromScan = exports.CfnTemplateGeneratorProvider = exports.FilterType = exports.ScanStatus = exports.TemplateSourceOptions = void 0;
+exports.generateCdkApp = generateCdkApp;
+exports.generateStack = generateStack;
+exports.readFromPath = readFromPath;
+exports.readFromStack = readFromStack;
+exports.generateTemplate = generateTemplate;
+exports.chunks = chunks;
+exports.setEnvironment = setEnvironment;
+exports.parseSourceOptions = parseSourceOptions;
+exports.printBar = printBar;
+exports.printDots = printDots;
+exports.rewriteLine = rewriteLine;
+exports.writeMigrateJsonFile = writeMigrateJsonFile;
+exports.getMigrateScanType = getMigrateScanType;
+exports.isThereAWarning = isThereAWarning;
+exports.buildGeneratedTemplateOutput = buildGeneratedTemplateOutput;
+exports.buildCfnClient = buildCfnClient;
+exports.appendWarningsToReadme = appendWarningsToReadme;
+/* eslint-disable @typescript-eslint/no-require-imports */
+/* eslint-disable @typescript-eslint/no-var-requires */
+const fs = require("fs");
+const path = require("path");
+const cloud_assembly_api_1 = require("@aws-cdk/cloud-assembly-api");
+const toolkit_lib_1 = require("@aws-cdk/toolkit-lib");
+const cdk_from_cfn = require("cdk-from-cfn");
+const chalk = require("chalk");
+const init_1 = require("./init");
+const cloudformation_1 = require("../api/cloudformation");
+const plugin_1 = require("../api/plugin");
+const util_1 = require("../util");
+const camelCase = require('camelcase');
+const decamelize = require('decamelize');
+/** The list of languages supported by the built-in noctilucent binary. */
+const MIGRATE_SUPPORTED_LANGUAGES = cdk_from_cfn.supported_languages();
+/**
+ * Generates a CDK app from a yaml or json template.
+ *
+ * @param stackName - The name to assign to the stack in the generated app
+ * @param stack - The yaml or json template for the stack
+ * @param language - The language to generate the CDK app in
+ * @param outputPath - The path at which to generate the CDK app
+ */
+async function generateCdkApp(ioHelper, stackName, stack, language, outputPath, compress) {
+    const resolvedOutputPath = path.join(outputPath ?? process.cwd(), stackName);
+    const formattedStackName = decamelize(stackName);
+    try {
+        fs.rmSync(resolvedOutputPath, { recursive: true, force: true });
+        fs.mkdirSync(resolvedOutputPath, { recursive: true });
+        const generateOnly = compress;
+        await (0, init_1.cliInit)({
+            ioHelper,
+            type: 'app',
+            language,
+            canUseNetwork: true,
+            generateOnly,
+            workDir: resolvedOutputPath,
+            stackName,
+            migrate: true,
+        });
+        let stackFileName;
+        switch (language) {
+            case 'typescript':
+                stackFileName = `${resolvedOutputPath}/lib/${formattedStackName}-stack.ts`;
+                break;
+            case 'java':
+                stackFileName = `${resolvedOutputPath}/src/main/java/com/myorg/${camelCase(formattedStackName, { pascalCase: true })}Stack.java`;
+                break;
+            case 'python':
+                stackFileName = `${resolvedOutputPath}/${formattedStackName.replace(/-/g, '_')}/${formattedStackName.replace(/-/g, '_')}_stack.py`;
+                break;
+            case 'csharp':
+                stackFileName = `${resolvedOutputPath}/src/${camelCase(formattedStackName, { pascalCase: true })}/${camelCase(formattedStackName, { pascalCase: true })}Stack.cs`;
+                break;
+            case 'go':
+                stackFileName = `${resolvedOutputPath}/${formattedStackName}.go`;
+                break;
+            default:
+                throw new toolkit_lib_1.ToolkitError('UnsupportedMigrateLanguage', `${language} is not supported by CDK Migrate. Please choose from: ${MIGRATE_SUPPORTED_LANGUAGES.join(', ')}`);
+        }
+        fs.writeFileSync(stackFileName, stack);
+        if (compress) {
+            await (0, util_1.zipDirectory)(resolvedOutputPath, `${resolvedOutputPath}.zip`);
+            fs.rmSync(resolvedOutputPath, { recursive: true, force: true });
+        }
+    }
+    catch (error) {
+        fs.rmSync(resolvedOutputPath, { recursive: true, force: true });
+        throw error;
+    }
+}
+/**
+ * Generates a CDK stack file.
+ * @param template - The template to translate into a CDK stack
+ * @param stackName - The name to assign to the stack
+ * @param language - The language to generate the stack in
+ * @returns A string representation of a CDK stack file
+ */
+function generateStack(template, stackName, language) {
+    const formattedStackName = `${camelCase(decamelize(stackName), { pascalCase: true })}Stack`;
+    try {
+        return cdk_from_cfn.transmute(template, language, formattedStackName);
+    }
+    catch (e) {
+        throw new toolkit_lib_1.ToolkitError('StackGenerationFailed', `${formattedStackName} could not be generated because ${e.message}`);
+    }
+}
+/**
+ * Reads and returns a stack template from a local path.
+ *
+ * @param inputPath - The location of the template
+ * @returns A string representation of the template if present, otherwise undefined
+ */
+function readFromPath(inputPath) {
+    let readFile;
+    try {
+        readFile = fs.readFileSync(inputPath, 'utf8');
+    }
+    catch (e) {
+        throw new toolkit_lib_1.ToolkitError('InvalidPath', `'${inputPath}' is not a valid path.`);
+    }
+    if (readFile == '') {
+        throw new toolkit_lib_1.ToolkitError('EmptyTemplateFile', `Cloudformation template filepath: '${inputPath}' is an empty file.`);
+    }
+    return readFile;
+}
+/**
+ * Reads and returns a stack template from a deployed CloudFormation stack.
+ *
+ * @param stackName - The name of the stack
+ * @param sdkProvider - The sdk provider for making CloudFormation calls
+ * @param environment - The account and region where the stack is deployed
+ * @returns A string representation of the template if present, otherwise undefined
+ */
+async function readFromStack(stackName, sdkProvider, environment) {
+    const cloudFormation = (await sdkProvider.forEnvironment(environment, plugin_1.Mode.ForReading)).sdk.cloudFormation();
+    const stack = await cloudformation_1.CloudFormationStack.lookup(cloudFormation, stackName, true);
+    if (stack.stackStatus.isDeploySuccess || stack.stackStatus.isRollbackSuccess) {
+        return JSON.stringify(await stack.template());
+    }
+    else {
+        throw new toolkit_lib_1.ToolkitError('UnhealthyStackStatus', `Stack '${stackName}' in account ${environment.account} and region ${environment.region} has a status of '${stack.stackStatus.name}' due to '${stack.stackStatus.reason}'. The stack cannot be migrated until it is in a healthy state.`);
+    }
+}
+/**
+ * Takes in a stack name and account and region and returns a generated cloudformation template using the cloudformation
+ * template generator.
+ *
+ * @param GenerateTemplateOptions - An object containing the stack name, filters, sdkProvider, environment, and newScan flag
+ * @returns a generated cloudformation template
+ */
+async function generateTemplate(options) {
+    const cfn = new CfnTemplateGeneratorProvider(await buildCfnClient(options.sdkProvider, options.environment), options.ioHelper);
+    const ioHelper = options.ioHelper;
+    const scanId = await findLastSuccessfulScan(cfn, options);
+    // if a customer accidentally ctrl-c's out of the command and runs it again, this will continue the progress bar where it left off
+    const curScan = await cfn.describeResourceScan(scanId);
+    if (curScan.Status == ScanStatus.IN_PROGRESS) {
+        await ioHelper.defaults.info('Resource scan in progress. Please wait, this can take 10 minutes or longer.');
+        await scanProgressBar(ioHelper, scanId, cfn);
+    }
+    await displayTimeDiff(ioHelper, new Date(), new Date(curScan.StartTime));
+    let resources = await cfn.listResourceScanResources(scanId, options.filters);
+    await ioHelper.defaults.info('finding related resources.');
+    let relatedResources = await cfn.getResourceScanRelatedResources(scanId, resources);
+    await ioHelper.defaults.info(`Found ${relatedResources.length} resources.`);
+    await ioHelper.defaults.info('Generating CFN template from scanned resources.');
+    const templateArn = (await cfn.createGeneratedTemplate(options.stackName, relatedResources)).GeneratedTemplateId;
+    let generatedTemplate = await cfn.describeGeneratedTemplate(templateArn);
+    await ioHelper.defaults.info('Please wait, template creation in progress. This may take a couple minutes.');
+    while (generatedTemplate.Status !== ScanStatus.COMPLETE && generatedTemplate.Status !== ScanStatus.FAILED) {
+        await printDots(`[${generatedTemplate.Status}] Template Creation in Progress`, 400);
+        generatedTemplate = await cfn.describeGeneratedTemplate(templateArn);
+    }
+    await ioHelper.defaults.info('\nTemplate successfully generated!');
+    return buildGeneratedTemplateOutput(generatedTemplate, (await cfn.getGeneratedTemplate(templateArn)).TemplateBody, templateArn);
+}
+async function findLastSuccessfulScan(cfn, options) {
+    const ioHelper = options.ioHelper;
+    let resourceScanSummaries = [];
+    const clientRequestToken = `cdk-migrate-${options.environment.account}-${options.environment.region}`;
+    if (options.fromScan === FromScan.NEW) {
+        await ioHelper.defaults.info(`Starting new scan for account ${options.environment.account} in region ${options.environment.region}`);
+        try {
+            await cfn.startResourceScan(clientRequestToken);
+            resourceScanSummaries = (await cfn.listResourceScans()).ResourceScanSummaries;
+        }
+        catch (e) {
+            // continuing here because if the scan fails on a new-scan it is very likely because there is either already a scan in progress
+            // or the customer hit a rate limit. In either case we want to continue with the most recent scan.
+            // If this happens to fail for a credential error then that will be caught immediately after anyway.
+            await ioHelper.defaults.info(`Scan failed to start due to error '${e.message}', defaulting to latest scan.`);
+        }
+    }
+    else {
+        resourceScanSummaries = (await cfn.listResourceScans()).ResourceScanSummaries;
+        await cfn.checkForResourceScan(resourceScanSummaries, options, clientRequestToken);
+    }
+    // get the latest scan, which we know will exist
+    resourceScanSummaries = (await cfn.listResourceScans()).ResourceScanSummaries;
+    let scanId = resourceScanSummaries[0].ResourceScanId;
+    // find the most recent scan that isn't in a failed state in case we didn't start a new one
+    for (const summary of resourceScanSummaries) {
+        if (summary.Status !== ScanStatus.FAILED) {
+            scanId = summary.ResourceScanId;
+            break;
+        }
+    }
+    return scanId;
+}
+/**
+ * Takes a string of filters in the format of key1=value1,key2=value2 and returns a map of the filters.
+ *
+ * @param filters - a string of filters in the format of key1=value1,key2=value2
+ * @returns a map of the filters
+ */
+function parseFilters(filters) {
+    if (!filters) {
+        return {
+            'resource-identifier': undefined,
+            'resource-type-prefix': undefined,
+            'tag-key': undefined,
+            'tag-value': undefined,
+        };
+    }
+    const filterShorthands = {
+        'identifier': FilterType.RESOURCE_IDENTIFIER,
+        'id': FilterType.RESOURCE_IDENTIFIER,
+        'type': FilterType.RESOURCE_TYPE_PREFIX,
+        'type-prefix': FilterType.RESOURCE_TYPE_PREFIX,
+    };
+    const filterList = filters.split(',');
+    let filterMap = {
+        [FilterType.RESOURCE_IDENTIFIER]: undefined,
+        [FilterType.RESOURCE_TYPE_PREFIX]: undefined,
+        [FilterType.TAG_KEY]: undefined,
+        [FilterType.TAG_VALUE]: undefined,
+    };
+    for (const fil of filterList) {
+        const filter = fil.split('=');
+        let filterKey = filter[0];
+        const filterValue = filter[1];
+        // if the key is a shorthand, replace it with the full name
+        if (filterKey in filterShorthands) {
+            filterKey = filterShorthands[filterKey];
+        }
+        if (Object.values(FilterType).includes(filterKey)) {
+            filterMap[filterKey] = filterValue;
+        }
+        else {
+            throw new toolkit_lib_1.ToolkitError('InvalidFilter', `Invalid filter: ${filterKey}`);
+        }
+    }
+    return filterMap;
+}
+/**
+ * Takes a list of any type and breaks it up into chunks of a specified size.
+ *
+ * @param list - The list to break up
+ * @param chunkSize - The size of each chunk
+ * @returns A list of lists of the specified size
+ */
+function chunks(list, chunkSize) {
+    const chunkedList = [];
+    for (let i = 0; i < list.length; i += chunkSize) {
+        chunkedList.push(list.slice(i, i + chunkSize));
+    }
+    return chunkedList;
+}
+/**
+ * Sets the account and region for making CloudFormation calls.
+ * @param account - The account to use
+ * @param region - The region to use
+ * @returns The environment object
+ */
+function setEnvironment(account, region) {
+    return {
+        account: account ?? cloud_assembly_api_1.UNKNOWN_ACCOUNT,
+        region: region ?? cloud_assembly_api_1.UNKNOWN_REGION,
+        name: 'cdk-migrate-env',
+    };
+}
+/**
+ * Enum for the source options for the template
+ */
+var TemplateSourceOptions;
+(function (TemplateSourceOptions) {
+    TemplateSourceOptions["PATH"] = "path";
+    TemplateSourceOptions["STACK"] = "stack";
+    TemplateSourceOptions["SCAN"] = "scan";
+})(TemplateSourceOptions || (exports.TemplateSourceOptions = TemplateSourceOptions = {}));
+/**
+ * Enum for the status of a resource scan
+ */
+var ScanStatus;
+(function (ScanStatus) {
+    ScanStatus["IN_PROGRESS"] = "IN_PROGRESS";
+    ScanStatus["COMPLETE"] = "COMPLETE";
+    ScanStatus["FAILED"] = "FAILED";
+})(ScanStatus || (exports.ScanStatus = ScanStatus = {}));
+var FilterType;
+(function (FilterType) {
+    FilterType["RESOURCE_IDENTIFIER"] = "resource-identifier";
+    FilterType["RESOURCE_TYPE_PREFIX"] = "resource-type-prefix";
+    FilterType["TAG_KEY"] = "tag-key";
+    FilterType["TAG_VALUE"] = "tag-value";
+})(FilterType || (exports.FilterType = FilterType = {}));
+/**
+ * Validates that exactly one source option has been provided.
+ * @param fromPath - The content of the flag `--from-path`
+ * @param fromStack - the content of the flag `--from-stack`
+ */
+function parseSourceOptions(fromPath, fromStack, stackName) {
+    if (fromPath && fromStack) {
+        throw new toolkit_lib_1.ToolkitError('ConflictingSourceOptions', 'Only one of `--from-path` or `--from-stack` may be provided.');
+    }
+    if (!stackName) {
+        throw new toolkit_lib_1.ToolkitError('MissingStackName', '`--stack-name` is a required field.');
+    }
+    if (!fromPath && !fromStack) {
+        return { source: TemplateSourceOptions.SCAN };
+    }
+    if (fromPath) {
+        return { source: TemplateSourceOptions.PATH, templatePath: fromPath };
+    }
+    return { source: TemplateSourceOptions.STACK, stackName: stackName };
+}
+/**
+ * Takes a set of resources and removes any with the managedbystack flag set to true.
+ *
+ * @param resourceList - the list of resources provided by the list scanned resources calls
+ * @returns a list of resources not managed by cfn stacks
+ */
+function excludeManaged(resourceList) {
+    return resourceList
+        .filter((r) => !r.ManagedByStack)
+        .map((r) => ({
+        ResourceType: r.ResourceType,
+        ResourceIdentifier: r.ResourceIdentifier,
+    }));
+}
+/**
+ * Transforms a list of resources into a list of resource identifiers by removing the ManagedByStack flag.
+ * Setting the value of the field to undefined effectively removes it from the object.
+ *
+ * @param resourceList - the list of resources provided by the list scanned resources calls
+ * @returns a list of ScannedResourceIdentifier[]
+ */
+function resourceIdentifiers(resourceList) {
+    const identifiers = [];
+    resourceList.forEach((r) => {
+        const identifier = {
+            ResourceType: r.ResourceType,
+            ResourceIdentifier: r.ResourceIdentifier,
+        };
+        identifiers.push(identifier);
+    });
+    return identifiers;
+}
+/**
+ * Takes a scan id and maintains a progress bar to display the progress of a scan to the user.
+ *
+ * @param scanId - A string representing the scan id
+ * @param cloudFormation - The CloudFormation sdk client to use
+ */
+async function scanProgressBar(ioHelper, scanId, cfn) {
+    let curProgress = 0.5;
+    // we know it's in progress initially since we wouldn't have gotten here if it wasn't
+    let curScan = {
+        Status: ScanStatus.IN_PROGRESS,
+        $metadata: {},
+    };
+    while (curScan.Status == ScanStatus.IN_PROGRESS) {
+        curScan = await cfn.describeResourceScan(scanId);
+        curProgress = curScan.PercentageCompleted ?? curProgress;
+        printBar(30, curProgress);
+        await new Promise((resolve) => setTimeout(resolve, 2000));
+    }
+    await ioHelper.defaults.info('\n✅ Scan Complete!');
+}
+/**
+ * Prints a progress bar to the console. To be used in a while loop to show progress of a long running task.
+ * The progress bar deletes the current line on the console and rewrites it with the progress amount.
+ *
+ * @param width - The width of the progress bar
+ * @param progress - The current progress to display as a percentage of 100
+ */
+function printBar(width, progress) {
+    if (!process.env.MIGRATE_INTEG_TEST) {
+        const FULL_BLOCK = '█';
+        const PARTIAL_BLOCK = ['', '▏', '▎', '▍', '▌', '▋', '▊', '▉'];
+        const fraction = Math.min(progress / 100, 1);
+        const innerWidth = Math.max(1, width - 2);
+        const chars = innerWidth * fraction;
+        const remainder = chars - Math.floor(chars);
+        const fullChars = FULL_BLOCK.repeat(Math.floor(chars));
+        const partialChar = PARTIAL_BLOCK[Math.floor(remainder * PARTIAL_BLOCK.length)];
+        const filler = '·'.repeat(innerWidth - Math.floor(chars) - (partialChar ? 1 : 0));
+        const color = chalk.green;
+        rewriteLine('[' + color(fullChars + partialChar) + filler + `] (${progress}%)`);
+    }
+}
+/**
+ * Prints a message to the console with a series periods appended to it. To be used in a while loop to show progress of a long running task.
+ * The message deletes the current line and rewrites it several times to display 1-3 periods to show the user that the task is still running.
+ *
+ * @param message - The message to display
+ * @param timeoutx4 - The amount of time to wait before printing the next period
+ */
+async function printDots(message, timeoutx4) {
+    if (!process.env.MIGRATE_INTEG_TEST) {
+        rewriteLine(message + ' .');
+        await new Promise((resolve) => setTimeout(resolve, timeoutx4));
+        rewriteLine(message + ' ..');
+        await new Promise((resolve) => setTimeout(resolve, timeoutx4));
+        rewriteLine(message + ' ...');
+        await new Promise((resolve) => setTimeout(resolve, timeoutx4));
+        rewriteLine(message);
+        await new Promise((resolve) => setTimeout(resolve, timeoutx4));
+    }
+}
+/**
+ * Rewrites the current line on the console and writes a new message to it.
+ * This is a helper funciton for printDots and printBar.
+ *
+ * @param message - The message to display
+ */
+function rewriteLine(message) {
+    process.stdout.clearLine(0);
+    process.stdout.cursorTo(0);
+    process.stdout.write(message);
+}
+/**
+ * Prints the time difference between two dates in days, hours, and minutes.
+ *
+ * @param time1 - The first date to compare
+ * @param time2 - The second date to compare
+ */
+async function displayTimeDiff(ioHelper, time1, time2) {
+    const diff = Math.abs(time1.getTime() - time2.getTime());
+    const days = Math.floor(diff / (1000 * 60 * 60 * 24));
+    const hours = Math.floor((diff % (1000 * 60 * 60 * 24)) / (1000 * 60 * 60));
+    const minutes = Math.floor((diff % (1000 * 60 * 60)) / (1000 * 60));
+    await ioHelper.defaults.info(`Using the latest successful scan which is ${days} days, ${hours} hours, and ${minutes} minutes old.`);
+}
+/**
+ * Writes a migrate.json file to the output directory.
+ *
+ * @param outputPath - The path to write the migrate.json file to
+ * @param stackName - The name of the stack
+ * @param generatedOutput - The output of the template generator
+ */
+function writeMigrateJsonFile(outputPath, stackName, migrateJson) {
+    const outputToJson = {
+        '//': 'This file is generated by cdk migrate. It will be automatically deleted after the first successful deployment of this app to the environment of the original resources.',
+        'Source': migrateJson.source,
+        'Resources': migrateJson.resources,
+    };
+    fs.writeFileSync(`${path.join(outputPath ?? process.cwd(), stackName)}/migrate.json`, JSON.stringify(outputToJson, null, 2));
+}
+/**
+ * Takes a string representing the from-scan flag and returns a FromScan enum value.
+ *
+ * @param scanType - A string representing the from-scan flag
+ * @returns A FromScan enum value
+ */
+function getMigrateScanType(scanType) {
+    switch (scanType) {
+        case 'new':
+            return FromScan.NEW;
+        case 'most-recent':
+            return FromScan.MOST_RECENT;
+        case '':
+            return FromScan.DEFAULT;
+        case undefined:
+            return FromScan.DEFAULT;
+        default:
+            throw new toolkit_lib_1.ToolkitError('UnknownScanType', `Unknown scan type: ${scanType}`);
+    }
+}
+/**
+ * Takes a generatedTemplateOutput objct and returns a boolean representing whether there are any warnings on any rescources.
+ *
+ * @param generatedTemplateOutput - A GenerateTemplateOutput object
+ * @returns A boolean representing whether there are any warnings on any rescources
+ */
+function isThereAWarning(generatedTemplateOutput) {
+    if (generatedTemplateOutput.resources) {
+        for (const resource of generatedTemplateOutput.resources) {
+            if (resource.Warnings && resource.Warnings.length > 0) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+/**
+ * Builds the GenerateTemplateOutput object from the DescribeGeneratedTemplateOutput and the template body.
+ *
+ * @param generatedTemplateSummary - The output of the describe generated template call
+ * @param templateBody - The body of the generated template
+ * @returns A GenerateTemplateOutput object
+ */
+function buildGeneratedTemplateOutput(generatedTemplateSummary, templateBody, source) {
+    const resources = generatedTemplateSummary.Resources;
+    const migrateJson = {
+        templateBody: templateBody,
+        source: source,
+        resources: generatedTemplateSummary.Resources.map((r) => ({
+            ResourceType: r.ResourceType,
+            LogicalResourceId: r.LogicalResourceId,
+            ResourceIdentifier: r.ResourceIdentifier,
+        })),
+    };
+    const templateId = generatedTemplateSummary.GeneratedTemplateId;
+    return {
+        migrateJson: migrateJson,
+        resources: resources,
+        templateId: templateId,
+    };
+}
+/**
+ * Builds a CloudFormation sdk client for making requests with the CFN template generator.
+ *
+ * @param sdkProvider - The sdk provider for making CloudFormation calls
+ * @param environment - The account and region where the stack is deployed
+ * @returns A CloudFormation sdk client
+ */
+async function buildCfnClient(sdkProvider, environment) {
+    const sdk = (await sdkProvider.forEnvironment(environment, plugin_1.Mode.ForReading)).sdk;
+    sdk.appendCustomUserAgent('cdk-migrate');
+    return sdk.cloudFormation();
+}
+/**
+ * Appends a list of warnings to a readme file.
+ *
+ * @param filepath - The path to the readme file
+ * @param resources - A list of resources to append warnings for
+ */
+function appendWarningsToReadme(filepath, resources) {
+    const readme = fs.readFileSync(filepath, 'utf8');
+    const lines = readme.split('\n');
+    const index = lines.findIndex((line) => line.trim() === 'Enjoy!');
+    let linesToAdd = ['\n## Warnings'];
+    linesToAdd.push('### Write-only properties');
+    linesToAdd.push("Write-only properties are resource property values that can be written to but can't be read by AWS CloudFormation or CDK Migrate. For more information, see [IaC generator and write-only properties](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/generate-IaC-write-only-properties.html).");
+    linesToAdd.push('\n');
+    linesToAdd.push('Write-only properties discovered during migration are organized here by resource ID and categorized by write-only property type. Resolve write-only properties by providing property values in your CDK app. For guidance, see [Resolve write-only properties](https://docs.aws.amazon.com/cdk/v2/guide/migrate.html#migrate-resources-writeonly).');
+    for (const resource of resources) {
+        if (resource.Warnings && resource.Warnings.length > 0) {
+            linesToAdd.push(`### ${resource.LogicalResourceId}`);
+            for (const warning of resource.Warnings) {
+                linesToAdd.push(`- **${warning.Type}**: `);
+                for (const property of warning.Properties) {
+                    linesToAdd.push(`  - ${property.PropertyPath}: ${property.Description}`);
+                }
+            }
+        }
+    }
+    lines.splice(index, 0, ...linesToAdd);
+    fs.writeFileSync(filepath, lines.join('\n'));
+}
+/**
+ * takes a list of resources and returns a list of unique resources based on the resource type and logical resource id.
+ *
+ * @param resources - A list of resources to deduplicate
+ * @returns A list of unique resources
+ */
+function deduplicateResources(resources) {
+    let uniqueResources = {};
+    for (const resource of resources) {
+        const key = Object.keys(resource.ResourceIdentifier)[0];
+        // Creating our unique identifier using the resource type, the key, and the value of the resource identifier
+        // The resource identifier is a combination of a key value pair defined by a resource's schema, and the resource type of the resource.
+        const uniqueIdentifer = `${resource.ResourceType}:${key}:${resource.ResourceIdentifier[key]}`;
+        uniqueResources[uniqueIdentifer] = resource;
+    }
+    return Object.values(uniqueResources);
+}
+/**
+ * Class for making CloudFormation template generator calls
+ */
+class CfnTemplateGeneratorProvider {
+    constructor(cfn, ioHelper) {
+        this.cfn = cfn;
+        this.ioHelper = ioHelper;
+    }
+    async checkForResourceScan(resourceScanSummaries, options, clientRequestToken) {
+        if (!resourceScanSummaries || resourceScanSummaries.length === 0) {
+            if (options.fromScan === FromScan.MOST_RECENT) {
+                throw new toolkit_lib_1.ToolkitError('NoScansFound', 'No scans found. Please either start a new scan with the `--from-scan` new or do not specify a `--from-scan` option.');
+            }
+            else {
+                await this.ioHelper.defaults.info('No scans found. Initiating a new resource scan.');
+                await this.startResourceScan(clientRequestToken);
+            }
+        }
+    }
+    /**
+     * Retrieves a tokenized list of resources and their associated scan. If a token is present the function
+     * will loop through all pages and combine them into a single list of ScannedRelatedResources
+     *
+     * @param scanId - scan id for the to list resources for
+     * @param resources - A list of resources to find related resources for
+     */
+    async getResourceScanRelatedResources(scanId, resources) {
+        let relatedResourceList = resources;
+        // break the list of resources into chunks of 100 to avoid hitting the 100 resource limit
+        for (const chunk of chunks(resources, 100)) {
+            // get the first page of related resources
+            const res = await this.cfn.listResourceScanRelatedResources({
+                ResourceScanId: scanId,
+                Resources: chunk,
+            });
+            // add the first page to the list
+            relatedResourceList.push(...(res.RelatedResources ?? []));
+            let nextToken = res.NextToken;
+            // if there are more pages, cycle through them and add them to the list before moving on to the next chunk
+            while (nextToken) {
+                const nextRelatedResources = await this.cfn.listResourceScanRelatedResources({
+                    ResourceScanId: scanId,
+                    Resources: resourceIdentifiers(resources),
+                    NextToken: nextToken,
+                });
+                nextToken = nextRelatedResources.NextToken;
+                relatedResourceList.push(...(nextRelatedResources.RelatedResources ?? []));
+            }
+        }
+        relatedResourceList = deduplicateResources(relatedResourceList);
+        // prune the managedbystack flag off of them again.
+        return process.env.MIGRATE_INTEG_TEST
+            ? resourceIdentifiers(relatedResourceList)
+            : resourceIdentifiers(excludeManaged(relatedResourceList));
+    }
+    /**
+     * Kicks off a scan of a customers account, returning the scan id. A scan can take
+     * 10 minutes or longer to complete. However this will return a scan id as soon as
+     * the scan has begun.
+     *
+     * @returns A string representing the scan id
+     */
+    async startResourceScan(requestToken) {
+        return (await this.cfn.startResourceScan({
+            ClientRequestToken: requestToken,
+        })).ResourceScanId;
+    }
+    /**
+     * Gets the most recent scans a customer has completed
+     *
+     * @returns a list of resource scan summaries
+     */
+    async listResourceScans() {
+        return this.cfn.listResourceScans();
+    }
+    /**
+     * Retrieves a tokenized list of resources from a resource scan. If a token is present, this function
+     * will loop through all pages and combine them into a single list of ScannedResource[].
+     * Additionally will apply any filters provided by the customer.
+     *
+     * @param scanId - scan id for the to list resources for
+     * @param filters - a string of filters in the format of key1=value1,key2=value2
+     * @returns a combined list of all resources from the scan
+     */
+    async listResourceScanResources(scanId, filters = []) {
+        let resourceList = [];
+        let resourceScanInputs;
+        if (filters.length > 0) {
+            await this.ioHelper.defaults.info('Applying filters to resource scan.');
+            for (const filter of filters) {
+                const filterList = parseFilters(filter);
+                resourceScanInputs = {
+                    ResourceScanId: scanId,
+                    ResourceIdentifier: filterList[FilterType.RESOURCE_IDENTIFIER],
+                    ResourceTypePrefix: filterList[FilterType.RESOURCE_TYPE_PREFIX],
+                    TagKey: filterList[FilterType.TAG_KEY],
+                    TagValue: filterList[FilterType.TAG_VALUE],
+                };
+                const resources = await this.cfn.listResourceScanResources(resourceScanInputs);
+                resourceList = resourceList.concat(resources.Resources ?? []);
+                let nextToken = resources.NextToken;
+                // cycle through the pages adding all resources to the list until we run out of pages
+                while (nextToken) {
+                    resourceScanInputs.NextToken = nextToken;
+                    const nextResources = await this.cfn.listResourceScanResources(resourceScanInputs);
+                    nextToken = nextResources.NextToken;
+                    resourceList = resourceList.concat(nextResources.Resources ?? []);
+                }
+            }
+        }
+        else {
+            await this.ioHelper.defaults.info('No filters provided. Retrieving all resources from scan.');
+            resourceScanInputs = {
+                ResourceScanId: scanId,
+            };
+            const resources = await this.cfn.listResourceScanResources(resourceScanInputs);
+            resourceList = resourceList.concat(resources.Resources ?? []);
+            let nextToken = resources.NextToken;
+            // cycle through the pages adding all resources to the list until we run out of pages
+            while (nextToken) {
+                resourceScanInputs.NextToken = nextToken;
+                const nextResources = await this.cfn.listResourceScanResources(resourceScanInputs);
+                nextToken = nextResources.NextToken;
+                resourceList = resourceList.concat(nextResources.Resources ?? []);
+            }
+        }
+        if (resourceList.length === 0) {
+            throw new toolkit_lib_1.ToolkitError('NoResourcesFound', `No resources found with filters ${filters.join(' ')}. Please try again with different filters.`);
+        }
+        resourceList = deduplicateResources(resourceList);
+        return process.env.MIGRATE_INTEG_TEST
+            ? resourceIdentifiers(resourceList)
+            : resourceIdentifiers(excludeManaged(resourceList));
+    }
+    /**
+     * Retrieves information about a resource scan.
+     *
+     * @param scanId - scan id for the to list resources for
+     * @returns information about the scan
+     */
+    async describeResourceScan(scanId) {
+        return this.cfn.describeResourceScan({
+            ResourceScanId: scanId,
+        });
+    }
+    /**
+     * Describes the current status of the template being generated.
+     *
+     * @param templateId - A string representing the template id
+     * @returns DescribeGeneratedTemplateOutput an object containing the template status and results
+     */
+    async describeGeneratedTemplate(templateId) {
+        const generatedTemplate = await this.cfn.describeGeneratedTemplate({
+            GeneratedTemplateName: templateId,
+        });
+        if (generatedTemplate.Status == ScanStatus.FAILED) {
+            throw new toolkit_lib_1.ToolkitError('TemplateGenerationFailed', generatedTemplate.StatusReason);
+        }
+        return generatedTemplate;
+    }
+    /**
+     * Retrieves a completed generated cloudformation template from the template generator.
+     *
+     * @param templateId - A string representing the template id
+     * @param cloudFormation - The CloudFormation sdk client to use
+     * @returns DescribeGeneratedTemplateOutput an object containing the template status and body
+     */
+    async getGeneratedTemplate(templateId) {
+        return this.cfn.getGeneratedTemplate({
+            GeneratedTemplateName: templateId,
+        });
+    }
+    /**
+     * Kicks off a template generation for a set of resources.
+     *
+     * @param stackName - The name of the stack
+     * @param resources - A list of resources to generate the template from
+     * @returns CreateGeneratedTemplateOutput an object containing the template arn to query on later
+     */
+    async createGeneratedTemplate(stackName, resources) {
+        const createTemplateOutput = await this.cfn.createGeneratedTemplate({
+            Resources: resources,
+            GeneratedTemplateName: stackName,
+        });
+        if (createTemplateOutput.GeneratedTemplateId === undefined) {
+            throw new toolkit_lib_1.ToolkitError('MissingTemplateArn', 'CreateGeneratedTemplate failed to return an Arn.');
+        }
+        return createTemplateOutput;
+    }
+    /**
+     * Deletes a generated template from the template generator.
+     *
+     * @param templateArn - The arn of the template to delete
+     * @returns A promise that resolves when the template has been deleted
+     */
+    async deleteGeneratedTemplate(templateArn) {
+        await this.cfn.deleteGeneratedTemplate({
+            GeneratedTemplateName: templateArn,
+        });
+    }
+}
+exports.CfnTemplateGeneratorProvider = CfnTemplateGeneratorProvider;
+/**
+ * The possible ways to choose a scan to generate a CDK application from
+ */
+var FromScan;
+(function (FromScan) {
+    /**
+     * Initiate a new resource scan to build the CDK application from.
+     */
+    FromScan[FromScan["NEW"] = 0] = "NEW";
+    /**
+     * Use the last successful scan to build the CDK application from. Will fail if no scan is found.
+     */
+    FromScan[FromScan["MOST_RECENT"] = 1] = "MOST_RECENT";
+    /**
+     * Starts a scan if none exists, otherwise uses the most recent successful scan to build the CDK application from.
+     */
+    FromScan[FromScan["DEFAULT"] = 2] = "DEFAULT";
+})(FromScan || (exports.FromScan = FromScan = {}));
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"migrate.js","sourceRoot":"","sources":["migrate.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable @typescript-eslint/no-require-imports */\n/* eslint-disable @typescript-eslint/no-var-requires */\nimport * as fs from 'fs';\nimport * as path from 'path';\nimport type { Environment } from '@aws-cdk/cloud-assembly-api';\nimport { UNKNOWN_ACCOUNT, UNKNOWN_REGION } from '@aws-cdk/cloud-assembly-api';\nimport { ToolkitError } from '@aws-cdk/toolkit-lib';\nimport type {\n  DescribeGeneratedTemplateCommandOutput,\n  DescribeResourceScanCommandOutput,\n  GetGeneratedTemplateCommandOutput,\n  ListResourceScanResourcesCommandInput,\n  ResourceDefinition,\n  ResourceDetail,\n  ResourceIdentifierSummary,\n  ResourceScanSummary,\n  ScannedResource,\n  ScannedResourceIdentifier,\n} from '@aws-sdk/client-cloudformation';\nimport * as cdk_from_cfn from 'cdk-from-cfn';\nimport * as chalk from 'chalk';\nimport { cliInit } from './init';\nimport type { ICloudFormationClient, SdkProvider } from '../api/aws-auth';\nimport { CloudFormationStack } from '../api/cloudformation';\nimport { Mode } from '../api/plugin';\nimport type { IoHelper } from '../api-private';\nimport { zipDirectory } from '../util';\nconst camelCase = require('camelcase');\nconst decamelize = require('decamelize');\n/** The list of languages supported by the built-in noctilucent binary. */\nconst MIGRATE_SUPPORTED_LANGUAGES: readonly string[] = cdk_from_cfn.supported_languages();\n\n/**\n * Generates a CDK app from a yaml or json template.\n *\n * @param stackName - The name to assign to the stack in the generated app\n * @param stack - The yaml or json template for the stack\n * @param language - The language to generate the CDK app in\n * @param outputPath - The path at which to generate the CDK app\n */\nexport async function generateCdkApp(\n  ioHelper: IoHelper,\n  stackName: string,\n  stack: string,\n  language: string,\n  outputPath?: string,\n  compress?: boolean,\n): Promise<void> {\n  const resolvedOutputPath = path.join(outputPath ?? process.cwd(), stackName);\n  const formattedStackName = decamelize(stackName);\n\n  try {\n    fs.rmSync(resolvedOutputPath, { recursive: true, force: true });\n    fs.mkdirSync(resolvedOutputPath, { recursive: true });\n    const generateOnly = compress;\n    await cliInit({\n      ioHelper,\n      type: 'app',\n      language,\n      canUseNetwork: true,\n      generateOnly,\n      workDir: resolvedOutputPath,\n      stackName,\n      migrate: true,\n    });\n\n    let stackFileName: string;\n    switch (language) {\n      case 'typescript':\n        stackFileName = `${resolvedOutputPath}/lib/${formattedStackName}-stack.ts`;\n        break;\n      case 'java':\n        stackFileName = `${resolvedOutputPath}/src/main/java/com/myorg/${camelCase(formattedStackName, { pascalCase: true })}Stack.java`;\n        break;\n      case 'python':\n        stackFileName = `${resolvedOutputPath}/${formattedStackName.replace(/-/g, '_')}/${formattedStackName.replace(/-/g, '_')}_stack.py`;\n        break;\n      case 'csharp':\n        stackFileName = `${resolvedOutputPath}/src/${camelCase(formattedStackName, { pascalCase: true })}/${camelCase(formattedStackName, { pascalCase: true })}Stack.cs`;\n        break;\n      case 'go':\n        stackFileName = `${resolvedOutputPath}/${formattedStackName}.go`;\n        break;\n      default:\n        throw new ToolkitError(\n          'UnsupportedMigrateLanguage',\n          `${language} is not supported by CDK Migrate. Please choose from: ${MIGRATE_SUPPORTED_LANGUAGES.join(', ')}`,\n        );\n    }\n    fs.writeFileSync(stackFileName, stack);\n    if (compress) {\n      await zipDirectory(resolvedOutputPath, `${resolvedOutputPath}.zip`);\n      fs.rmSync(resolvedOutputPath, { recursive: true, force: true });\n    }\n  } catch (error) {\n    fs.rmSync(resolvedOutputPath, { recursive: true, force: true });\n    throw error;\n  }\n}\n\n/**\n * Generates a CDK stack file.\n * @param template - The template to translate into a CDK stack\n * @param stackName - The name to assign to the stack\n * @param language - The language to generate the stack in\n * @returns A string representation of a CDK stack file\n */\nexport function generateStack(template: string, stackName: string, language: string) {\n  const formattedStackName = `${camelCase(decamelize(stackName), { pascalCase: true })}Stack`;\n  try {\n    return cdk_from_cfn.transmute(template, language, formattedStackName);\n  } catch (e) {\n    throw new ToolkitError('StackGenerationFailed', `${formattedStackName} could not be generated because ${(e as Error).message}`);\n  }\n}\n\n/**\n * Reads and returns a stack template from a local path.\n *\n * @param inputPath - The location of the template\n * @returns A string representation of the template if present, otherwise undefined\n */\nexport function readFromPath(inputPath: string): string {\n  let readFile: string;\n  try {\n    readFile = fs.readFileSync(inputPath, 'utf8');\n  } catch (e) {\n    throw new ToolkitError('InvalidPath', `'${inputPath}' is not a valid path.`);\n  }\n  if (readFile == '') {\n    throw new ToolkitError('EmptyTemplateFile', `Cloudformation template filepath: '${inputPath}' is an empty file.`);\n  }\n  return readFile;\n}\n\n/**\n * Reads and returns a stack template from a deployed CloudFormation stack.\n *\n * @param stackName - The name of the stack\n * @param sdkProvider - The sdk provider for making CloudFormation calls\n * @param environment - The account and region where the stack is deployed\n * @returns A string representation of the template if present, otherwise undefined\n */\nexport async function readFromStack(\n  stackName: string,\n  sdkProvider: SdkProvider,\n  environment: Environment,\n): Promise<string | undefined> {\n  const cloudFormation = (await sdkProvider.forEnvironment(environment, Mode.ForReading)).sdk.cloudFormation();\n\n  const stack = await CloudFormationStack.lookup(cloudFormation, stackName, true);\n  if (stack.stackStatus.isDeploySuccess || stack.stackStatus.isRollbackSuccess) {\n    return JSON.stringify(await stack.template());\n  } else {\n    throw new ToolkitError(\n      'UnhealthyStackStatus',\n      `Stack '${stackName}' in account ${environment.account} and region ${environment.region} has a status of '${stack.stackStatus.name}' due to '${stack.stackStatus.reason}'. The stack cannot be migrated until it is in a healthy state.`,\n    );\n  }\n}\n\n/**\n * Takes in a stack name and account and region and returns a generated cloudformation template using the cloudformation\n * template generator.\n *\n * @param GenerateTemplateOptions - An object containing the stack name, filters, sdkProvider, environment, and newScan flag\n * @returns a generated cloudformation template\n */\nexport async function generateTemplate(options: GenerateTemplateOptions): Promise<GenerateTemplateOutput> {\n  const cfn = new CfnTemplateGeneratorProvider(await buildCfnClient(options.sdkProvider, options.environment), options.ioHelper);\n  const ioHelper = options.ioHelper;\n\n  const scanId = await findLastSuccessfulScan(cfn, options);\n\n  // if a customer accidentally ctrl-c's out of the command and runs it again, this will continue the progress bar where it left off\n  const curScan = await cfn.describeResourceScan(scanId);\n  if (curScan.Status == ScanStatus.IN_PROGRESS) {\n    await ioHelper.defaults.info('Resource scan in progress. Please wait, this can take 10 minutes or longer.');\n    await scanProgressBar(ioHelper, scanId, cfn);\n  }\n\n  await displayTimeDiff(ioHelper, new Date(), new Date(curScan.StartTime!));\n\n  let resources: ScannedResource[] = await cfn.listResourceScanResources(scanId!, options.filters);\n\n  await ioHelper.defaults.info('finding related resources.');\n  let relatedResources = await cfn.getResourceScanRelatedResources(scanId!, resources);\n\n  await ioHelper.defaults.info(`Found ${relatedResources.length} resources.`);\n\n  await ioHelper.defaults.info('Generating CFN template from scanned resources.');\n  const templateArn = (await cfn.createGeneratedTemplate(options.stackName, relatedResources)).GeneratedTemplateId!;\n\n  let generatedTemplate = await cfn.describeGeneratedTemplate(templateArn);\n\n  await ioHelper.defaults.info('Please wait, template creation in progress. This may take a couple minutes.');\n  while (generatedTemplate.Status !== ScanStatus.COMPLETE && generatedTemplate.Status !== ScanStatus.FAILED) {\n    await printDots(`[${generatedTemplate.Status}] Template Creation in Progress`, 400);\n    generatedTemplate = await cfn.describeGeneratedTemplate(templateArn);\n  }\n  await ioHelper.defaults.info('\\nTemplate successfully generated!');\n  return buildGeneratedTemplateOutput(\n    generatedTemplate,\n    (await cfn.getGeneratedTemplate(templateArn)).TemplateBody!,\n    templateArn,\n  );\n}\n\nasync function findLastSuccessfulScan(\n  cfn: CfnTemplateGeneratorProvider,\n  options: GenerateTemplateOptions,\n): Promise<string> {\n  const ioHelper = options.ioHelper;\n  let resourceScanSummaries: ResourceScanSummary[] | undefined = [];\n  const clientRequestToken = `cdk-migrate-${options.environment.account}-${options.environment.region}`;\n  if (options.fromScan === FromScan.NEW) {\n    await ioHelper.defaults.info(`Starting new scan for account ${options.environment.account} in region ${options.environment.region}`);\n    try {\n      await cfn.startResourceScan(clientRequestToken);\n      resourceScanSummaries = (await cfn.listResourceScans()).ResourceScanSummaries;\n    } catch (e) {\n      // continuing here because if the scan fails on a new-scan it is very likely because there is either already a scan in progress\n      // or the customer hit a rate limit. In either case we want to continue with the most recent scan.\n      // If this happens to fail for a credential error then that will be caught immediately after anyway.\n      await ioHelper.defaults.info(`Scan failed to start due to error '${(e as Error).message}', defaulting to latest scan.`);\n    }\n  } else {\n    resourceScanSummaries = (await cfn.listResourceScans()).ResourceScanSummaries;\n    await cfn.checkForResourceScan(resourceScanSummaries, options, clientRequestToken);\n  }\n  // get the latest scan, which we know will exist\n  resourceScanSummaries = (await cfn.listResourceScans()).ResourceScanSummaries;\n  let scanId: string | undefined = resourceScanSummaries![0].ResourceScanId;\n\n  // find the most recent scan that isn't in a failed state in case we didn't start a new one\n  for (const summary of resourceScanSummaries!) {\n    if (summary.Status !== ScanStatus.FAILED) {\n      scanId = summary.ResourceScanId!;\n      break;\n    }\n  }\n\n  return scanId!;\n}\n\n/**\n * Takes a string of filters in the format of key1=value1,key2=value2 and returns a map of the filters.\n *\n * @param filters - a string of filters in the format of key1=value1,key2=value2\n * @returns a map of the filters\n */\nfunction parseFilters(filters: string): {\n  [key in FilterType]: string | undefined;\n} {\n  if (!filters) {\n    return {\n      'resource-identifier': undefined,\n      'resource-type-prefix': undefined,\n      'tag-key': undefined,\n      'tag-value': undefined,\n    };\n  }\n\n  const filterShorthands: { [key: string]: FilterType } = {\n    'identifier': FilterType.RESOURCE_IDENTIFIER,\n    'id': FilterType.RESOURCE_IDENTIFIER,\n    'type': FilterType.RESOURCE_TYPE_PREFIX,\n    'type-prefix': FilterType.RESOURCE_TYPE_PREFIX,\n  };\n\n  const filterList = filters.split(',');\n\n  let filterMap: { [key in FilterType]: string | undefined } = {\n    [FilterType.RESOURCE_IDENTIFIER]: undefined,\n    [FilterType.RESOURCE_TYPE_PREFIX]: undefined,\n    [FilterType.TAG_KEY]: undefined,\n    [FilterType.TAG_VALUE]: undefined,\n  };\n\n  for (const fil of filterList) {\n    const filter = fil.split('=');\n    let filterKey = filter[0];\n    const filterValue = filter[1];\n    // if the key is a shorthand, replace it with the full name\n    if (filterKey in filterShorthands) {\n      filterKey = filterShorthands[filterKey];\n    }\n    if (Object.values(FilterType).includes(filterKey as any)) {\n      filterMap[filterKey as keyof typeof filterMap] = filterValue;\n    } else {\n      throw new ToolkitError('InvalidFilter', `Invalid filter: ${filterKey}`);\n    }\n  }\n  return filterMap;\n}\n\n/**\n * Takes a list of any type and breaks it up into chunks of a specified size.\n *\n * @param list - The list to break up\n * @param chunkSize - The size of each chunk\n * @returns A list of lists of the specified size\n */\nexport function chunks(list: any[], chunkSize: number): any[][] {\n  const chunkedList: any[][] = [];\n  for (let i = 0; i < list.length; i += chunkSize) {\n    chunkedList.push(list.slice(i, i + chunkSize));\n  }\n  return chunkedList;\n}\n\n/**\n * Sets the account and region for making CloudFormation calls.\n * @param account - The account to use\n * @param region - The region to use\n * @returns The environment object\n */\nexport function setEnvironment(account?: string, region?: string): Environment {\n  return {\n    account: account ?? UNKNOWN_ACCOUNT,\n    region: region ?? UNKNOWN_REGION,\n    name: 'cdk-migrate-env',\n  };\n}\n\n/**\n * Enum for the source options for the template\n */\nexport enum TemplateSourceOptions {\n  PATH = 'path',\n  STACK = 'stack',\n  SCAN = 'scan',\n}\n\n/**\n * An object representing the source of a template.\n */\ntype TemplateSource =\n  | { source: TemplateSourceOptions.SCAN }\n  | { source: TemplateSourceOptions.PATH; templatePath: string }\n  | { source: TemplateSourceOptions.STACK; stackName: string };\n\n/**\n * Enum for the status of a resource scan\n */\nexport enum ScanStatus {\n  IN_PROGRESS = 'IN_PROGRESS',\n  COMPLETE = 'COMPLETE',\n  FAILED = 'FAILED',\n}\n\nexport enum FilterType {\n  RESOURCE_IDENTIFIER = 'resource-identifier',\n  RESOURCE_TYPE_PREFIX = 'resource-type-prefix',\n  TAG_KEY = 'tag-key',\n  TAG_VALUE = 'tag-value',\n}\n\n/**\n * Validates that exactly one source option has been provided.\n * @param fromPath - The content of the flag `--from-path`\n * @param fromStack - the content of the flag `--from-stack`\n */\nexport function parseSourceOptions(fromPath?: string, fromStack?: boolean, stackName?: string): TemplateSource {\n  if (fromPath && fromStack) {\n    throw new ToolkitError('ConflictingSourceOptions', 'Only one of `--from-path` or `--from-stack` may be provided.');\n  }\n  if (!stackName) {\n    throw new ToolkitError('MissingStackName', '`--stack-name` is a required field.');\n  }\n  if (!fromPath && !fromStack) {\n    return { source: TemplateSourceOptions.SCAN };\n  }\n  if (fromPath) {\n    return { source: TemplateSourceOptions.PATH, templatePath: fromPath };\n  }\n  return { source: TemplateSourceOptions.STACK, stackName: stackName! };\n}\n\n/**\n * Takes a set of resources and removes any with the managedbystack flag set to true.\n *\n * @param resourceList - the list of resources provided by the list scanned resources calls\n * @returns a list of resources not managed by cfn stacks\n */\nfunction excludeManaged(resourceList: ScannedResource[]): ScannedResourceIdentifier[] {\n  return resourceList\n    .filter((r) => !r.ManagedByStack)\n    .map((r) => ({\n      ResourceType: r.ResourceType!,\n      ResourceIdentifier: r.ResourceIdentifier!,\n    }));\n}\n\n/**\n * Transforms a list of resources into a list of resource identifiers by removing the ManagedByStack flag.\n * Setting the value of the field to undefined effectively removes it from the object.\n *\n * @param resourceList - the list of resources provided by the list scanned resources calls\n * @returns a list of ScannedResourceIdentifier[]\n */\nfunction resourceIdentifiers(resourceList: ScannedResource[]): ScannedResourceIdentifier[] {\n  const identifiers: ScannedResourceIdentifier[] = [];\n  resourceList.forEach((r) => {\n    const identifier: ScannedResourceIdentifier = {\n      ResourceType: r.ResourceType!,\n      ResourceIdentifier: r.ResourceIdentifier!,\n    };\n    identifiers.push(identifier);\n  });\n  return identifiers;\n}\n\n/**\n * Takes a scan id and maintains a progress bar to display the progress of a scan to the user.\n *\n * @param scanId - A string representing the scan id\n * @param cloudFormation - The CloudFormation sdk client to use\n */\nasync function scanProgressBar(ioHelper: IoHelper, scanId: string, cfn: CfnTemplateGeneratorProvider) {\n  let curProgress = 0.5;\n  // we know it's in progress initially since we wouldn't have gotten here if it wasn't\n  let curScan: DescribeResourceScanCommandOutput = {\n    Status: ScanStatus.IN_PROGRESS,\n    $metadata: {},\n  };\n  while (curScan.Status == ScanStatus.IN_PROGRESS) {\n    curScan = await cfn.describeResourceScan(scanId);\n    curProgress = curScan.PercentageCompleted ?? curProgress;\n    printBar(30, curProgress);\n    await new Promise((resolve) => setTimeout(resolve, 2000));\n  }\n  await ioHelper.defaults.info('\\n✅ Scan Complete!');\n}\n\n/**\n * Prints a progress bar to the console. To be used in a while loop to show progress of a long running task.\n * The progress bar deletes the current line on the console and rewrites it with the progress amount.\n *\n * @param width - The width of the progress bar\n * @param progress - The current progress to display as a percentage of 100\n */\nexport function printBar(width: number, progress: number) {\n  if (!process.env.MIGRATE_INTEG_TEST) {\n    const FULL_BLOCK = '█';\n    const PARTIAL_BLOCK = ['', '▏', '▎', '▍', '▌', '▋', '▊', '▉'];\n    const fraction = Math.min(progress / 100, 1);\n    const innerWidth = Math.max(1, width - 2);\n    const chars = innerWidth * fraction;\n    const remainder = chars - Math.floor(chars);\n\n    const fullChars = FULL_BLOCK.repeat(Math.floor(chars));\n    const partialChar = PARTIAL_BLOCK[Math.floor(remainder * PARTIAL_BLOCK.length)];\n    const filler = '·'.repeat(innerWidth - Math.floor(chars) - (partialChar ? 1 : 0));\n\n    const color = chalk.green;\n\n    rewriteLine('[' + color(fullChars + partialChar) + filler + `] (${progress}%)`);\n  }\n}\n\n/**\n * Prints a message to the console with a series periods appended to it. To be used in a while loop to show progress of a long running task.\n * The message deletes the current line and rewrites it several times to display 1-3 periods to show the user that the task is still running.\n *\n * @param message - The message to display\n * @param timeoutx4 - The amount of time to wait before printing the next period\n */\nexport async function printDots(message: string, timeoutx4: number) {\n  if (!process.env.MIGRATE_INTEG_TEST) {\n    rewriteLine(message + ' .');\n    await new Promise((resolve) => setTimeout(resolve, timeoutx4));\n\n    rewriteLine(message + ' ..');\n    await new Promise((resolve) => setTimeout(resolve, timeoutx4));\n\n    rewriteLine(message + ' ...');\n    await new Promise((resolve) => setTimeout(resolve, timeoutx4));\n\n    rewriteLine(message);\n    await new Promise((resolve) => setTimeout(resolve, timeoutx4));\n  }\n}\n\n/**\n * Rewrites the current line on the console and writes a new message to it.\n * This is a helper funciton for printDots and printBar.\n *\n * @param message - The message to display\n */\nexport function rewriteLine(message: string) {\n  process.stdout.clearLine(0);\n  process.stdout.cursorTo(0);\n  process.stdout.write(message);\n}\n\n/**\n * Prints the time difference between two dates in days, hours, and minutes.\n *\n * @param time1 - The first date to compare\n * @param time2 - The second date to compare\n */\nasync function displayTimeDiff(ioHelper: IoHelper, time1: Date, time2: Date): Promise<void> {\n  const diff = Math.abs(time1.getTime() - time2.getTime());\n\n  const days = Math.floor(diff / (1000 * 60 * 60 * 24));\n  const hours = Math.floor((diff % (1000 * 60 * 60 * 24)) / (1000 * 60 * 60));\n  const minutes = Math.floor((diff % (1000 * 60 * 60)) / (1000 * 60));\n\n  await ioHelper.defaults.info(`Using the latest successful scan which is ${days} days, ${hours} hours, and ${minutes} minutes old.`);\n}\n\n/**\n * Writes a migrate.json file to the output directory.\n *\n * @param outputPath - The path to write the migrate.json file to\n * @param stackName - The name of the stack\n * @param generatedOutput - The output of the template generator\n */\nexport function writeMigrateJsonFile(\n  outputPath: string | undefined,\n  stackName: string,\n  migrateJson: MigrateJsonFormat,\n) {\n  const outputToJson = {\n    '//': 'This file is generated by cdk migrate. It will be automatically deleted after the first successful deployment of this app to the environment of the original resources.',\n    'Source': migrateJson.source,\n    'Resources': migrateJson.resources,\n  };\n  fs.writeFileSync(\n    `${path.join(outputPath ?? process.cwd(), stackName)}/migrate.json`,\n    JSON.stringify(outputToJson, null, 2),\n  );\n}\n\n/**\n * Takes a string representing the from-scan flag and returns a FromScan enum value.\n *\n * @param scanType - A string representing the from-scan flag\n * @returns A FromScan enum value\n */\nexport function getMigrateScanType(scanType: string) {\n  switch (scanType) {\n    case 'new':\n      return FromScan.NEW;\n    case 'most-recent':\n      return FromScan.MOST_RECENT;\n    case '':\n      return FromScan.DEFAULT;\n    case undefined:\n      return FromScan.DEFAULT;\n    default:\n      throw new ToolkitError('UnknownScanType', `Unknown scan type: ${scanType}`);\n  }\n}\n\n/**\n * Takes a generatedTemplateOutput objct and returns a boolean representing whether there are any warnings on any rescources.\n *\n * @param generatedTemplateOutput - A GenerateTemplateOutput object\n * @returns A boolean representing whether there are any warnings on any rescources\n */\nexport function isThereAWarning(generatedTemplateOutput: GenerateTemplateOutput) {\n  if (generatedTemplateOutput.resources) {\n    for (const resource of generatedTemplateOutput.resources) {\n      if (resource.Warnings && resource.Warnings.length > 0) {\n        return true;\n      }\n    }\n  }\n  return false;\n}\n\n/**\n * Builds the GenerateTemplateOutput object from the DescribeGeneratedTemplateOutput and the template body.\n *\n * @param generatedTemplateSummary - The output of the describe generated template call\n * @param templateBody - The body of the generated template\n * @returns A GenerateTemplateOutput object\n */\nexport function buildGeneratedTemplateOutput(\n  generatedTemplateSummary: DescribeGeneratedTemplateCommandOutput,\n  templateBody: string,\n  source: string,\n): GenerateTemplateOutput {\n  const resources: ResourceDetail[] | undefined = generatedTemplateSummary.Resources;\n  const migrateJson: MigrateJsonFormat = {\n    templateBody: templateBody,\n    source: source,\n    resources: generatedTemplateSummary.Resources!.map((r) => ({\n      ResourceType: r.ResourceType!,\n      LogicalResourceId: r.LogicalResourceId!,\n      ResourceIdentifier: r.ResourceIdentifier!,\n    })),\n  };\n  const templateId = generatedTemplateSummary.GeneratedTemplateId!;\n  return {\n    migrateJson: migrateJson,\n    resources: resources,\n    templateId: templateId,\n  };\n}\n\n/**\n * Builds a CloudFormation sdk client for making requests with the CFN template generator.\n *\n * @param sdkProvider - The sdk provider for making CloudFormation calls\n * @param environment - The account and region where the stack is deployed\n * @returns A CloudFormation sdk client\n */\nexport async function buildCfnClient(sdkProvider: SdkProvider, environment: Environment) {\n  const sdk = (await sdkProvider.forEnvironment(environment, Mode.ForReading)).sdk;\n  sdk.appendCustomUserAgent('cdk-migrate');\n  return sdk.cloudFormation();\n}\n\n/**\n * Appends a list of warnings to a readme file.\n *\n * @param filepath - The path to the readme file\n * @param resources - A list of resources to append warnings for\n */\nexport function appendWarningsToReadme(filepath: string, resources: ResourceDetail[]) {\n  const readme = fs.readFileSync(filepath, 'utf8');\n  const lines = readme.split('\\n');\n  const index = lines.findIndex((line) => line.trim() === 'Enjoy!');\n  let linesToAdd = ['\\n## Warnings'];\n  linesToAdd.push('### Write-only properties');\n  linesToAdd.push(\n    \"Write-only properties are resource property values that can be written to but can't be read by AWS CloudFormation or CDK Migrate. For more information, see [IaC generator and write-only properties](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/generate-IaC-write-only-properties.html).\",\n  );\n  linesToAdd.push('\\n');\n  linesToAdd.push(\n    'Write-only properties discovered during migration are organized here by resource ID and categorized by write-only property type. Resolve write-only properties by providing property values in your CDK app. For guidance, see [Resolve write-only properties](https://docs.aws.amazon.com/cdk/v2/guide/migrate.html#migrate-resources-writeonly).',\n  );\n  for (const resource of resources) {\n    if (resource.Warnings && resource.Warnings.length > 0) {\n      linesToAdd.push(`### ${resource.LogicalResourceId}`);\n      for (const warning of resource.Warnings) {\n        linesToAdd.push(`- **${warning.Type}**: `);\n        for (const property of warning.Properties!) {\n          linesToAdd.push(`  - ${property.PropertyPath}: ${property.Description}`);\n        }\n      }\n    }\n  }\n  lines.splice(index, 0, ...linesToAdd);\n  fs.writeFileSync(filepath, lines.join('\\n'));\n}\n\n/**\n * takes a list of resources and returns a list of unique resources based on the resource type and logical resource id.\n *\n * @param resources - A list of resources to deduplicate\n * @returns A list of unique resources\n */\nfunction deduplicateResources(resources: ResourceDetail[]) {\n  let uniqueResources: { [key: string]: ResourceDetail } = {};\n\n  for (const resource of resources) {\n    const key = Object.keys(resource.ResourceIdentifier!)[0];\n\n    // Creating our unique identifier using the resource type, the key, and the value of the resource identifier\n    // The resource identifier is a combination of a key value pair defined by a resource's schema, and the resource type of the resource.\n    const uniqueIdentifer = `${resource.ResourceType}:${key}:${resource.ResourceIdentifier![key]}`;\n    uniqueResources[uniqueIdentifer] = resource;\n  }\n\n  return Object.values(uniqueResources);\n}\n\n/**\n * Class for making CloudFormation template generator calls\n */\nexport class CfnTemplateGeneratorProvider {\n  private cfn: ICloudFormationClient;\n  private ioHelper: IoHelper;\n  constructor(cfn: ICloudFormationClient, ioHelper: IoHelper) {\n    this.cfn = cfn;\n    this.ioHelper = ioHelper;\n  }\n\n  async checkForResourceScan(\n    resourceScanSummaries: ResourceScanSummary[] | undefined,\n    options: GenerateTemplateOptions,\n    clientRequestToken: string,\n  ) {\n    if (!resourceScanSummaries || resourceScanSummaries.length === 0) {\n      if (options.fromScan === FromScan.MOST_RECENT) {\n        throw new ToolkitError(\n          'NoScansFound',\n          'No scans found. Please either start a new scan with the `--from-scan` new or do not specify a `--from-scan` option.',\n        );\n      } else {\n        await this.ioHelper.defaults.info('No scans found. Initiating a new resource scan.');\n        await this.startResourceScan(clientRequestToken);\n      }\n    }\n  }\n\n  /**\n   * Retrieves a tokenized list of resources and their associated scan. If a token is present the function\n   * will loop through all pages and combine them into a single list of ScannedRelatedResources\n   *\n   * @param scanId - scan id for the to list resources for\n   * @param resources - A list of resources to find related resources for\n   */\n  async getResourceScanRelatedResources(\n    scanId: string,\n    resources: ScannedResource[],\n  ): Promise<ScannedResourceIdentifier[]> {\n    let relatedResourceList = resources;\n\n    // break the list of resources into chunks of 100 to avoid hitting the 100 resource limit\n    for (const chunk of chunks(resources, 100)) {\n      // get the first page of related resources\n      const res = await this.cfn.listResourceScanRelatedResources({\n        ResourceScanId: scanId,\n        Resources: chunk,\n      });\n\n      // add the first page to the list\n      relatedResourceList.push(...(res.RelatedResources ?? []));\n      let nextToken = res.NextToken;\n\n      // if there are more pages, cycle through them and add them to the list before moving on to the next chunk\n      while (nextToken) {\n        const nextRelatedResources = await this.cfn.listResourceScanRelatedResources({\n          ResourceScanId: scanId,\n          Resources: resourceIdentifiers(resources),\n          NextToken: nextToken,\n        });\n        nextToken = nextRelatedResources.NextToken;\n        relatedResourceList.push(...(nextRelatedResources.RelatedResources ?? []));\n      }\n    }\n\n    relatedResourceList = deduplicateResources(relatedResourceList);\n\n    // prune the managedbystack flag off of them again.\n    return process.env.MIGRATE_INTEG_TEST\n      ? resourceIdentifiers(relatedResourceList)\n      : resourceIdentifiers(excludeManaged(relatedResourceList));\n  }\n\n  /**\n   * Kicks off a scan of a customers account, returning the scan id. A scan can take\n   * 10 minutes or longer to complete. However this will return a scan id as soon as\n   * the scan has begun.\n   *\n   * @returns A string representing the scan id\n   */\n  async startResourceScan(requestToken: string) {\n    return (\n      await this.cfn.startResourceScan({\n        ClientRequestToken: requestToken,\n      })\n    ).ResourceScanId;\n  }\n\n  /**\n   * Gets the most recent scans a customer has completed\n   *\n   * @returns a list of resource scan summaries\n   */\n  async listResourceScans() {\n    return this.cfn.listResourceScans();\n  }\n\n  /**\n   * Retrieves a tokenized list of resources from a resource scan. If a token is present, this function\n   * will loop through all pages and combine them into a single list of ScannedResource[].\n   * Additionally will apply any filters provided by the customer.\n   *\n   * @param scanId - scan id for the to list resources for\n   * @param filters - a string of filters in the format of key1=value1,key2=value2\n   * @returns a combined list of all resources from the scan\n   */\n  async listResourceScanResources(scanId: string, filters: string[] = []): Promise<ScannedResourceIdentifier[]> {\n    let resourceList: ScannedResource[] = [];\n    let resourceScanInputs: ListResourceScanResourcesCommandInput;\n\n    if (filters.length > 0) {\n      await this.ioHelper.defaults.info('Applying filters to resource scan.');\n      for (const filter of filters) {\n        const filterList = parseFilters(filter);\n        resourceScanInputs = {\n          ResourceScanId: scanId,\n          ResourceIdentifier: filterList[FilterType.RESOURCE_IDENTIFIER],\n          ResourceTypePrefix: filterList[FilterType.RESOURCE_TYPE_PREFIX],\n          TagKey: filterList[FilterType.TAG_KEY],\n          TagValue: filterList[FilterType.TAG_VALUE],\n        };\n        const resources = await this.cfn.listResourceScanResources(resourceScanInputs);\n        resourceList = resourceList.concat(resources.Resources ?? []);\n        let nextToken = resources.NextToken;\n\n        // cycle through the pages adding all resources to the list until we run out of pages\n        while (nextToken) {\n          resourceScanInputs.NextToken = nextToken;\n          const nextResources = await this.cfn.listResourceScanResources(resourceScanInputs);\n          nextToken = nextResources.NextToken;\n          resourceList = resourceList!.concat(nextResources.Resources ?? []);\n        }\n      }\n    } else {\n      await this.ioHelper.defaults.info('No filters provided. Retrieving all resources from scan.');\n      resourceScanInputs = {\n        ResourceScanId: scanId,\n      };\n      const resources = await this.cfn.listResourceScanResources(resourceScanInputs);\n      resourceList = resourceList!.concat(resources.Resources ?? []);\n      let nextToken = resources.NextToken;\n\n      // cycle through the pages adding all resources to the list until we run out of pages\n      while (nextToken) {\n        resourceScanInputs.NextToken = nextToken;\n        const nextResources = await this.cfn.listResourceScanResources(resourceScanInputs);\n        nextToken = nextResources.NextToken;\n        resourceList = resourceList!.concat(nextResources.Resources ?? []);\n      }\n    }\n    if (resourceList.length === 0) {\n      throw new ToolkitError('NoResourcesFound', `No resources found with filters ${filters.join(' ')}. Please try again with different filters.`);\n    }\n    resourceList = deduplicateResources(resourceList);\n\n    return process.env.MIGRATE_INTEG_TEST\n      ? resourceIdentifiers(resourceList)\n      : resourceIdentifiers(excludeManaged(resourceList));\n  }\n\n  /**\n   * Retrieves information about a resource scan.\n   *\n   * @param scanId - scan id for the to list resources for\n   * @returns information about the scan\n   */\n  async describeResourceScan(scanId: string): Promise<DescribeResourceScanCommandOutput> {\n    return this.cfn.describeResourceScan({\n      ResourceScanId: scanId,\n    });\n  }\n\n  /**\n   * Describes the current status of the template being generated.\n   *\n   * @param templateId - A string representing the template id\n   * @returns DescribeGeneratedTemplateOutput an object containing the template status and results\n   */\n  async describeGeneratedTemplate(templateId: string): Promise<DescribeGeneratedTemplateCommandOutput> {\n    const generatedTemplate = await this.cfn.describeGeneratedTemplate({\n      GeneratedTemplateName: templateId,\n    });\n\n    if (generatedTemplate.Status == ScanStatus.FAILED) {\n      throw new ToolkitError('TemplateGenerationFailed', generatedTemplate.StatusReason!);\n    }\n\n    return generatedTemplate;\n  }\n\n  /**\n   * Retrieves a completed generated cloudformation template from the template generator.\n   *\n   * @param templateId - A string representing the template id\n   * @param cloudFormation - The CloudFormation sdk client to use\n   * @returns DescribeGeneratedTemplateOutput an object containing the template status and body\n   */\n  async getGeneratedTemplate(templateId: string): Promise<GetGeneratedTemplateCommandOutput> {\n    return this.cfn.getGeneratedTemplate({\n      GeneratedTemplateName: templateId,\n    });\n  }\n\n  /**\n   * Kicks off a template generation for a set of resources.\n   *\n   * @param stackName - The name of the stack\n   * @param resources - A list of resources to generate the template from\n   * @returns CreateGeneratedTemplateOutput an object containing the template arn to query on later\n   */\n  async createGeneratedTemplate(stackName: string, resources: ResourceDefinition[]) {\n    const createTemplateOutput = await this.cfn.createGeneratedTemplate({\n      Resources: resources,\n      GeneratedTemplateName: stackName,\n    });\n\n    if (createTemplateOutput.GeneratedTemplateId === undefined) {\n      throw new ToolkitError('MissingTemplateArn', 'CreateGeneratedTemplate failed to return an Arn.');\n    }\n    return createTemplateOutput;\n  }\n\n  /**\n   * Deletes a generated template from the template generator.\n   *\n   * @param templateArn - The arn of the template to delete\n   * @returns A promise that resolves when the template has been deleted\n   */\n  async deleteGeneratedTemplate(templateArn: string): Promise<void> {\n    await this.cfn.deleteGeneratedTemplate({\n      GeneratedTemplateName: templateArn,\n    });\n  }\n}\n\n/**\n * The possible ways to choose a scan to generate a CDK application from\n */\nexport enum FromScan {\n  /**\n   * Initiate a new resource scan to build the CDK application from.\n   */\n  NEW,\n\n  /**\n   * Use the last successful scan to build the CDK application from. Will fail if no scan is found.\n   */\n  MOST_RECENT,\n\n  /**\n   * Starts a scan if none exists, otherwise uses the most recent successful scan to build the CDK application from.\n   */\n  DEFAULT,\n}\n\n/**\n * Interface for the options object passed to the generateTemplate function\n *\n * @param stackName - The name of the stack\n * @param filters - A list of filters to apply to the scan\n * @param fromScan - An enum value specifying whether a new scan should be started or the most recent successful scan should be used\n * @param sdkProvider - The sdk provider for making CloudFormation calls\n * @param environment - The account and region where the stack is deployed\n */\nexport interface GenerateTemplateOptions {\n  stackName: string;\n  filters?: string[];\n  fromScan?: FromScan;\n  sdkProvider: SdkProvider;\n  environment: Environment;\n  ioHelper: IoHelper;\n}\n\n/**\n * Interface for the output of the generateTemplate function\n *\n * @param migrateJson - The generated Migrate.json file\n * @param resources - The generated template\n */\nexport interface GenerateTemplateOutput {\n  migrateJson: MigrateJsonFormat;\n  resources?: ResourceDetail[];\n  templateId?: string;\n}\n\n/**\n * Interface defining the format of the generated Migrate.json file\n *\n * @param TemplateBody - The generated template\n * @param Source - The source of the template\n * @param Resources - A list of resources that were used to generate the template\n */\nexport interface MigrateJsonFormat {\n  templateBody: string;\n  source: string;\n  resources?: GeneratedResourceImportIdentifier[];\n}\n\n/**\n * Interface representing the format of a resource identifier required for resource import\n *\n * @param ResourceType - The type of resource\n * @param LogicalResourceId - The logical id of the resource\n * @param ResourceIdentifier - The resource identifier of the resource\n */\nexport interface GeneratedResourceImportIdentifier {\n  // cdk deploy expects the migrate.json resource identifiers to be PascalCase, not camelCase.\n  ResourceType: string;\n  LogicalResourceId: string;\n  ResourceIdentifier: ResourceIdentifierSummary;\n}\n"]}