aws-cdk 2.1005.0 → 2.1006.0

package/lib/commands/diff.js

@@ -0,0 +1,215 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RequireApproval = void 0;
+exports.formatStackDiff = formatStackDiff;
+exports.formatSecurityDiff = formatSecurityDiff;
+const stream_1 = require("stream");
+const util_1 = require("util");
+const cxschema = require("@aws-cdk/cloud-assembly-schema");
+const cloudformation_diff_1 = require("@aws-cdk/cloudformation-diff");
+const chalk = require("chalk");
+const api_1 = require("../../../@aws-cdk/tmp-toolkit-helpers/src/api");
+const logging_1 = require("../logging");
+/*
+ * Custom writable stream that collects text into a string buffer.
+ * Used on classes that take in and directly write to a stream, but
+ * we intend to capture the output rather than print.
+ */
+class StringWriteStream extends stream_1.Writable {
+    constructor() {
+        super();
+        this.buffer = [];
+    }
+    _write(chunk, _encoding, callback) {
+        this.buffer.push(chunk.toString());
+        callback();
+    }
+    toString() {
+        return this.buffer.join('');
+    }
+}
+/**
+ * Formats the differences between two template states and returns it as a string.
+ *
+ * @param oldTemplate the old/current state of the stack.
+ * @param newTemplate the new/target state of the stack.
+ * @param strict      do not filter out AWS::CDK::Metadata or Rules
+ * @param context     lines of context to use in arbitrary JSON diff
+ * @param quiet       silences \'There were no differences\' messages
+ *
+ * @returns the formatted diff, and the number of stacks in this stack tree that have differences, including the top-level root stack
+ */
+function formatStackDiff(oldTemplate, newTemplate, strict, context, quiet, stackName, changeSet, isImport, nestedStackTemplates) {
+    let diff = (0, cloudformation_diff_1.fullDiff)(oldTemplate, newTemplate.template, changeSet, isImport);
+    // The stack diff is formatted via `Formatter`, which takes in a stream
+    // and sends its output directly to that stream. To faciliate use of the
+    // global CliIoHost, we create our own stream to capture the output of
+    // `Formatter` and return the output as a string for the consumer of
+    // `formatStackDiff` to decide what to do with it.
+    const stream = new StringWriteStream();
+    let numStacksWithChanges = 0;
+    let formattedDiff = '';
+    let filteredChangesCount = 0;
+    try {
+        // must output the stack name if there are differences, even if quiet
+        if (stackName && (!quiet || !diff.isEmpty)) {
+            stream.write((0, util_1.format)('Stack %s\n', chalk.bold(stackName)));
+        }
+        if (!quiet && isImport) {
+            stream.write('Parameters and rules created during migration do not affect resource configuration.\n');
+        }
+        // detect and filter out mangled characters from the diff
+        if (diff.differenceCount && !strict) {
+            const mangledNewTemplate = JSON.parse((0, cloudformation_diff_1.mangleLikeCloudFormation)(JSON.stringify(newTemplate.template)));
+            const mangledDiff = (0, cloudformation_diff_1.fullDiff)(oldTemplate, mangledNewTemplate, changeSet);
+            filteredChangesCount = Math.max(0, diff.differenceCount - mangledDiff.differenceCount);
+            if (filteredChangesCount > 0) {
+                diff = mangledDiff;
+            }
+        }
+        // filter out 'AWS::CDK::Metadata' resources from the template
+        // filter out 'CheckBootstrapVersion' rules from the template
+        if (!strict) {
+            obscureDiff(diff);
+        }
+        if (!diff.isEmpty) {
+            numStacksWithChanges++;
+            // formatDifferences updates the stream with the formatted stack diff
+            (0, cloudformation_diff_1.formatDifferences)(stream, diff, {
+                ...logicalIdMapFromTemplate(oldTemplate),
+                ...buildLogicalToPathMap(newTemplate),
+            }, context);
+            // store the stream containing a formatted stack diff
+            formattedDiff = stream.toString();
+        }
+        else if (!quiet) {
+            (0, logging_1.info)(chalk.green('There were no differences'));
+        }
+    }
+    finally {
+        stream.end();
+    }
+    if (filteredChangesCount > 0) {
+        (0, logging_1.info)(chalk.yellow(`Omitted ${filteredChangesCount} changes because they are likely mangled non-ASCII characters. Use --strict to print them.`));
+    }
+    for (const nestedStackLogicalId of Object.keys(nestedStackTemplates ?? {})) {
+        if (!nestedStackTemplates) {
+            break;
+        }
+        const nestedStack = nestedStackTemplates[nestedStackLogicalId];
+        newTemplate._template = nestedStack.generatedTemplate;
+        const nextDiff = formatStackDiff(nestedStack.deployedTemplate, newTemplate, strict, context, quiet, nestedStack.physicalName ?? nestedStackLogicalId, undefined, isImport, nestedStack.nestedStackTemplates);
+        numStacksWithChanges += nextDiff.numStacksWithChanges;
+        formattedDiff += nextDiff.formattedDiff;
+    }
+    return {
+        numStacksWithChanges,
+        formattedDiff,
+    };
+}
+var RequireApproval;
+(function (RequireApproval) {
+    RequireApproval["Never"] = "never";
+    RequireApproval["AnyChange"] = "any-change";
+    RequireApproval["Broadening"] = "broadening";
+})(RequireApproval || (exports.RequireApproval = RequireApproval = {}));
+/**
+ * Formats the security changes of this diff, if the change is impactful enough according to the approval level
+ *
+ * Returns the diff if the changes are prompt-worthy, an empty object otherwise.
+ */
+function formatSecurityDiff(oldTemplate, newTemplate, requireApproval, stackName, changeSet) {
+    const diff = (0, cloudformation_diff_1.fullDiff)(oldTemplate, newTemplate.template, changeSet);
+    if (diffRequiresApproval(diff, requireApproval)) {
+        (0, logging_1.info)((0, util_1.format)('Stack %s\n', chalk.bold(stackName)));
+        // eslint-disable-next-line max-len
+        (0, logging_1.warning)(`This deployment will make potentially sensitive changes according to your current security approval level (--require-approval ${requireApproval}).`);
+        (0, logging_1.warning)('Please confirm you intend to make the following modifications:\n');
+        // The security diff is formatted via `Formatter`, which takes in a stream
+        // and sends its output directly to that stream. To faciliate use of the
+        // global CliIoHost, we create our own stream to capture the output of
+        // `Formatter` and return the output as a string for the consumer of
+        // `formatSecurityDiff` to decide what to do with it.
+        const stream = new StringWriteStream();
+        try {
+            // formatSecurityChanges updates the stream with the formatted security diff
+            (0, cloudformation_diff_1.formatSecurityChanges)(stream, diff, buildLogicalToPathMap(newTemplate));
+        }
+        finally {
+            stream.end();
+        }
+        // store the stream containing a formatted stack diff
+        const formattedDiff = stream.toString();
+        return { formattedDiff };
+    }
+    return {};
+}
+/**
+ * Return whether the diff has security-impacting changes that need confirmation
+ *
+ * TODO: Filter the security impact determination based off of an enum that allows
+ * us to pick minimum "severities" to alert on.
+ */
+function diffRequiresApproval(diff, requireApproval) {
+    switch (requireApproval) {
+        case RequireApproval.Never: return false;
+        case RequireApproval.AnyChange: return diff.permissionsAnyChanges;
+        case RequireApproval.Broadening: return diff.permissionsBroadened;
+        default: throw new api_1.ToolkitError(`Unrecognized approval level: ${requireApproval}`);
+    }
+}
+function buildLogicalToPathMap(stack) {
+    const map = {};
+    for (const md of stack.findMetadataByType(cxschema.ArtifactMetadataEntryType.LOGICAL_ID)) {
+        map[md.data] = md.path;
+    }
+    return map;
+}
+function logicalIdMapFromTemplate(template) {
+    const ret = {};
+    for (const [logicalId, resource] of Object.entries(template.Resources ?? {})) {
+        const path = resource?.Metadata?.['aws:cdk:path'];
+        if (path) {
+            ret[logicalId] = path;
+        }
+    }
+    return ret;
+}
+/**
+ * Remove any template elements that we don't want to show users.
+ * This is currently:
+ * - AWS::CDK::Metadata resource
+ * - CheckBootstrapVersion Rule
+ */
+function obscureDiff(diff) {
+    if (diff.unknown) {
+        // see https://github.com/aws/aws-cdk/issues/17942
+        diff.unknown = diff.unknown.filter(change => {
+            if (!change) {
+                return true;
+            }
+            if (change.newValue?.CheckBootstrapVersion) {
+                return false;
+            }
+            if (change.oldValue?.CheckBootstrapVersion) {
+                return false;
+            }
+            return true;
+        });
+    }
+    if (diff.resources) {
+        diff.resources = diff.resources.filter(change => {
+            if (!change) {
+                return true;
+            }
+            if (change.newResourceType === 'AWS::CDK::Metadata') {
+                return false;
+            }
+            if (change.oldResourceType === 'AWS::CDK::Metadata') {
+                return false;
+            }
+            return true;
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"diff.js","sourceRoot":"","sources":["diff.ts"],"names":[],"mappings":"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","sourcesContent":["import { Writable } from 'stream';\nimport { format } from 'util';\nimport * as cxschema from '@aws-cdk/cloud-assembly-schema';\nimport {\n  type DescribeChangeSetOutput,\n  type TemplateDiff,\n  formatDifferences,\n  formatSecurityChanges,\n  fullDiff,\n  mangleLikeCloudFormation,\n} from '@aws-cdk/cloudformation-diff';\nimport type * as cxapi from '@aws-cdk/cx-api';\nimport * as chalk from 'chalk';\nimport { ToolkitError } from '../../../@aws-cdk/tmp-toolkit-helpers/src/api';\nimport type { NestedStackTemplates } from '../api/cloudformation';\nimport { info, warning } from '../logging';\n\n/*\n * Custom writable stream that collects text into a string buffer.\n * Used on classes that take in and directly write to a stream, but\n * we intend to capture the output rather than print.\n */\nclass StringWriteStream extends Writable {\n  private buffer: string[] = [];\n\n  constructor() {\n    super();\n  }\n\n  _write(chunk: any, _encoding: string, callback: (error?: Error | null) => void): void {\n    this.buffer.push(chunk.toString());\n    callback();\n  }\n\n  toString(): string {\n    return this.buffer.join('');\n  }\n}\n\n/**\n * Output of formatStackDiff\n */\nexport interface FormatStackDiffOutput {\n  /**\n   * Number of stacks with diff changes\n   */\n  readonly numStacksWithChanges: number;\n\n  /**\n   * Complete formatted diff\n   */\n  readonly formattedDiff: string;\n}\n\n/**\n * Formats the differences between two template states and returns it as a string.\n *\n * @param oldTemplate the old/current state of the stack.\n * @param newTemplate the new/target state of the stack.\n * @param strict      do not filter out AWS::CDK::Metadata or Rules\n * @param context     lines of context to use in arbitrary JSON diff\n * @param quiet       silences \\'There were no differences\\' messages\n *\n * @returns the formatted diff, and the number of stacks in this stack tree that have differences, including the top-level root stack\n */\nexport function formatStackDiff(\n  oldTemplate: any,\n  newTemplate: cxapi.CloudFormationStackArtifact,\n  strict: boolean,\n  context: number,\n  quiet: boolean,\n  stackName?: string,\n  changeSet?: DescribeChangeSetOutput,\n  isImport?: boolean,\n  nestedStackTemplates?: { [nestedStackLogicalId: string]: NestedStackTemplates }): FormatStackDiffOutput {\n  let diff = fullDiff(oldTemplate, newTemplate.template, changeSet, isImport);\n\n  // The stack diff is formatted via `Formatter`, which takes in a stream\n  // and sends its output directly to that stream. To faciliate use of the\n  // global CliIoHost, we create our own stream to capture the output of\n  // `Formatter` and return the output as a string for the consumer of\n  // `formatStackDiff` to decide what to do with it.\n  const stream = new StringWriteStream();\n\n  let numStacksWithChanges = 0;\n  let formattedDiff = '';\n  let filteredChangesCount = 0;\n  try {\n    // must output the stack name if there are differences, even if quiet\n    if (stackName && (!quiet || !diff.isEmpty)) {\n      stream.write(format('Stack %s\\n', chalk.bold(stackName)));\n    }\n\n    if (!quiet && isImport) {\n      stream.write('Parameters and rules created during migration do not affect resource configuration.\\n');\n    }\n\n    // detect and filter out mangled characters from the diff\n    if (diff.differenceCount && !strict) {\n      const mangledNewTemplate = JSON.parse(mangleLikeCloudFormation(JSON.stringify(newTemplate.template)));\n      const mangledDiff = fullDiff(oldTemplate, mangledNewTemplate, changeSet);\n      filteredChangesCount = Math.max(0, diff.differenceCount - mangledDiff.differenceCount);\n      if (filteredChangesCount > 0) {\n        diff = mangledDiff;\n      }\n    }\n\n    // filter out 'AWS::CDK::Metadata' resources from the template\n    // filter out 'CheckBootstrapVersion' rules from the template\n    if (!strict) {\n      obscureDiff(diff);\n    }\n\n    if (!diff.isEmpty) {\n      numStacksWithChanges++;\n\n      // formatDifferences updates the stream with the formatted stack diff\n      formatDifferences(stream, diff, {\n        ...logicalIdMapFromTemplate(oldTemplate),\n        ...buildLogicalToPathMap(newTemplate),\n      }, context);\n\n      // store the stream containing a formatted stack diff\n      formattedDiff = stream.toString();\n    } else if (!quiet) {\n      info(chalk.green('There were no differences'));\n    }\n  } finally {\n    stream.end();\n  }\n\n  if (filteredChangesCount > 0) {\n    info(chalk.yellow(`Omitted ${filteredChangesCount} changes because they are likely mangled non-ASCII characters. Use --strict to print them.`));\n  }\n\n  for (const nestedStackLogicalId of Object.keys(nestedStackTemplates ?? {})) {\n    if (!nestedStackTemplates) {\n      break;\n    }\n    const nestedStack = nestedStackTemplates[nestedStackLogicalId];\n\n    (newTemplate as any)._template = nestedStack.generatedTemplate;\n    const nextDiff = formatStackDiff(\n      nestedStack.deployedTemplate,\n      newTemplate,\n      strict,\n      context,\n      quiet,\n      nestedStack.physicalName ?? nestedStackLogicalId,\n      undefined,\n      isImport,\n      nestedStack.nestedStackTemplates,\n    );\n    numStacksWithChanges += nextDiff.numStacksWithChanges;\n    formattedDiff += nextDiff.formattedDiff;\n  }\n\n  return {\n    numStacksWithChanges,\n    formattedDiff,\n  };\n}\n\nexport enum RequireApproval {\n  Never = 'never',\n\n  AnyChange = 'any-change',\n\n  Broadening = 'broadening',\n}\n\n/**\n * Output of formatSecurityDiff\n */\nexport interface FormatSecurityDiffOutput {\n  /**\n   * Complete formatted security diff, if it is prompt-worthy\n   */\n  readonly formattedDiff?: string;\n}\n\n/**\n * Formats the security changes of this diff, if the change is impactful enough according to the approval level\n *\n * Returns the diff if the changes are prompt-worthy, an empty object otherwise.\n */\nexport function formatSecurityDiff(\n  oldTemplate: any,\n  newTemplate: cxapi.CloudFormationStackArtifact,\n  requireApproval: RequireApproval,\n  stackName?: string,\n  changeSet?: DescribeChangeSetOutput,\n): FormatSecurityDiffOutput {\n  const diff = fullDiff(oldTemplate, newTemplate.template, changeSet);\n\n  if (diffRequiresApproval(diff, requireApproval)) {\n    info(format('Stack %s\\n', chalk.bold(stackName)));\n\n    // eslint-disable-next-line max-len\n    warning(`This deployment will make potentially sensitive changes according to your current security approval level (--require-approval ${requireApproval}).`);\n    warning('Please confirm you intend to make the following modifications:\\n');\n\n    // The security diff is formatted via `Formatter`, which takes in a stream\n    // and sends its output directly to that stream. To faciliate use of the\n    // global CliIoHost, we create our own stream to capture the output of\n    // `Formatter` and return the output as a string for the consumer of\n    // `formatSecurityDiff` to decide what to do with it.\n    const stream = new StringWriteStream();\n    try {\n      // formatSecurityChanges updates the stream with the formatted security diff\n      formatSecurityChanges(stream, diff, buildLogicalToPathMap(newTemplate));\n    } finally {\n      stream.end();\n    }\n    // store the stream containing a formatted stack diff\n    const formattedDiff = stream.toString();\n    return { formattedDiff };\n  }\n  return {};\n}\n\n/**\n * Return whether the diff has security-impacting changes that need confirmation\n *\n * TODO: Filter the security impact determination based off of an enum that allows\n * us to pick minimum \"severities\" to alert on.\n */\nfunction diffRequiresApproval(diff: TemplateDiff, requireApproval: RequireApproval) {\n  switch (requireApproval) {\n    case RequireApproval.Never: return false;\n    case RequireApproval.AnyChange: return diff.permissionsAnyChanges;\n    case RequireApproval.Broadening: return diff.permissionsBroadened;\n    default: throw new ToolkitError(`Unrecognized approval level: ${requireApproval}`);\n  }\n}\n\nfunction buildLogicalToPathMap(stack: cxapi.CloudFormationStackArtifact) {\n  const map: { [id: string]: string } = {};\n  for (const md of stack.findMetadataByType(cxschema.ArtifactMetadataEntryType.LOGICAL_ID)) {\n    map[md.data as string] = md.path;\n  }\n  return map;\n}\n\nfunction logicalIdMapFromTemplate(template: any) {\n  const ret: Record<string, string> = {};\n\n  for (const [logicalId, resource] of Object.entries(template.Resources ?? {})) {\n    const path = (resource as any)?.Metadata?.['aws:cdk:path'];\n    if (path) {\n      ret[logicalId] = path;\n    }\n  }\n  return ret;\n}\n\n/**\n * Remove any template elements that we don't want to show users.\n * This is currently:\n * - AWS::CDK::Metadata resource\n * - CheckBootstrapVersion Rule\n */\nfunction obscureDiff(diff: TemplateDiff) {\n  if (diff.unknown) {\n    // see https://github.com/aws/aws-cdk/issues/17942\n    diff.unknown = diff.unknown.filter(change => {\n      if (!change) {\n        return true;\n      }\n      if (change.newValue?.CheckBootstrapVersion) {\n        return false;\n      }\n      if (change.oldValue?.CheckBootstrapVersion) {\n        return false;\n      }\n      return true;\n    });\n  }\n\n  if (diff.resources) {\n    diff.resources = diff.resources.filter(change => {\n      if (!change) {\n        return true;\n      }\n      if (change.newResourceType === 'AWS::CDK::Metadata') {\n        return false;\n      }\n      if (change.oldResourceType === 'AWS::CDK::Metadata') {\n        return false;\n      }\n      return true;\n    });\n  }\n}\n"]}

package/lib/commands/init/index.d.ts

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

package/lib/commands/init/index.js

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

package/lib/commands/init/init-hooks.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.invokeBuiltinHooks = invokeBuiltinHooks;
+const path = require("path");
+const os_1 = require("./os");
+const api_1 = require("../../../../@aws-cdk/tmp-toolkit-helpers/src/api");
+const util_1 = require("../../util");
+/**
+ * Invoke hooks for the given init template
+ *
+ * Sometimes templates need more complex logic than just replacing tokens. A 'hook' can be
+ * used to do additional processing other than copying files.
+ *
+ * Hooks used to be defined externally to the CLI, by running arbitrarily
+ * substituted shell scripts in the target directory.
+ *
+ * In practice, they're all TypeScript files and all the same, and the dynamism
+ * that the original solution allowed wasn't used at all. Worse, since the CLI
+ * is now bundled the hooks can't even reuse code from the CLI libraries at all
+ * anymore, so all shared code would have to be copy/pasted.
+ *
+ * Bundle hooks as built-ins into the CLI, so they get bundled and can take advantage
+ * of all shared code.
+ */
+async function invokeBuiltinHooks(target, context) {
+    switch (target.language) {
+        case 'csharp':
+            if (['app', 'sample-app'].includes(target.templateName)) {
+                return dotnetAddProject(target.targetDirectory, context);
+            }
+            break;
+        case 'fsharp':
+            if (['app', 'sample-app'].includes(target.templateName)) {
+                return dotnetAddProject(target.targetDirectory, context, 'fsproj');
+            }
+            break;
+        case 'python':
+            // We can't call this file 'requirements.template.txt' because Dependabot needs to be able to find it.
+            // Therefore, keep the in-repo name but still substitute placeholders.
+            await context.substitutePlaceholdersIn('requirements.txt');
+            break;
+        case 'java':
+            // We can't call this file 'pom.template.xml'... for the same reason as Python above.
+            await context.substitutePlaceholdersIn('pom.xml');
+            break;
+        case 'javascript':
+        case 'typescript':
+            // See above, but for 'package.json'.
+            await context.substitutePlaceholdersIn('package.json');
+    }
+}
+async function dotnetAddProject(targetDirectory, context, ext = 'csproj') {
+    const pname = context.placeholder('name.PascalCased');
+    const slnPath = path.join(targetDirectory, 'src', `${pname}.sln`);
+    const csprojPath = path.join(targetDirectory, 'src', pname, `${pname}.${ext}`);
+    try {
+        await (0, os_1.shell)(['dotnet', 'sln', slnPath, 'add', csprojPath]);
+    }
+    catch (e) {
+        throw new api_1.ToolkitError(`Could not add project ${pname}.${ext} to solution ${pname}.sln. ${(0, util_1.formatErrorMessage)(e)}`);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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