@aws-cdk/toolkit-lib 0.2.0 → 0.3.1

package/lib/api/shared-private.js

@@ -41,6 +41,7 @@ __export(shared_private_exports, {
   AccountAccessKeyCache: () => AccountAccessKeyCache,
   ActiveAssetCache: () => ActiveAssetCache,
   ActivityPrinterBase: () => ActivityPrinterBase,
+  AmbiguityError: () => AmbiguityError,
   AssemblyError: () => AssemblyError,
   AssetManifestBuilder: () => AssetManifestBuilder,
   AuthenticationError: () => AuthenticationError,
@@ -100,6 +101,8 @@ __export(shared_private_exports, {
   RWLock: () => RWLock,
   RequireApproval: () => RequireApproval,
   ResourceImporter: () => ResourceImporter,
+  ResourceLocation: () => ResourceLocation,
+  ResourceMapping: () => ResourceMapping,
   ResourceMigrator: () => ResourceMigrator,
   RollbackChoice: () => RollbackChoice,
   S3_ISOLATED_TAG: () => S3_ISOLATED_TAG,
@@ -123,6 +126,7 @@ __export(shared_private_exports, {
   WorkGraph: () => WorkGraph,
   WorkGraphBuilder: () => WorkGraphBuilder,
   addMetadataAssetsToManifest: () => addMetadataAssetsToManifest,
+  ambiguousMovements: () => ambiguousMovements,
   asIoHelper: () => asIoHelper,
   assertIsSuccessfulDeployStackResult: () => assertIsSuccessfulDeployStackResult,
   cached: () => cached,
@@ -136,7 +140,10 @@ __export(shared_private_exports, {
   determineAllowCrossAccountAssetPublishing: () => determineAllowCrossAccountAssetPublishing,
   error: () => error,
   findCloudWatchLogGroups: () => findCloudWatchLogGroups,
+  findResourceMovements: () => findResourceMovements,
+  formatAmbiguousMappings: () => formatAmbiguousMappings,
   formatSdkLoggerContent: () => formatSdkLoggerContent,
+  formatTypedMappings: () => formatTypedMappings,
   getBootstrapStackInfo: () => getBootstrapStackInfo,
   guessExecutable: () => guessExecutable,
   info: () => info,
@@ -157,6 +164,8 @@ __export(shared_private_exports, {
   refreshStacks: () => refreshStacks,
   removeNonImportResources: () => removeNonImportResources,
   replaceEnvPlaceholders: () => replaceEnvPlaceholders,
+  resourceMappings: () => resourceMappings,
+  resourceMovements: () => resourceMovements,
   result: () => result,
   setSdkTracing: () => setSdkTracing,
   some: () => some,
@@ -1186,6 +1195,16 @@ var IO = {
     description: "Stack deletion failed",
     interface: "ErrorPayload"
   }),
+  // 8. Refactor (8xxx)
+  CDK_TOOLKIT_I8900: result({
+    code: "CDK_TOOLKIT_I8900",
+    description: "Refactor result",
+    interface: "RefactorResult"
+  }),
+  CDK_TOOLKIT_W8010: warn({
+    code: "CDK_TOOLKIT_W8010",
+    description: "Refactor execution not yet supported"
+  }),
   // 9: Bootstrap (9xxx)
   CDK_TOOLKIT_I9000: info({
     code: "CDK_TOOLKIT_I9000",
@@ -2180,6 +2199,14 @@ var SDK = class {
           stackResources.push(...page?.StackResourceSummaries || []);
         }
         return stackResources;
+      },
+      paginatedListStacks: async (input) => {
+        const stackResources = Array();
+        const paginator = (0, import_client_cloudformation.paginateListStacks)({ client }, input);
+        for await (const page of paginator) {
+          stackResources.push(...page?.StackSummaries || []);
+        }
+        return stackResources;
       }
     };
   }
@@ -4650,11 +4677,14 @@ async function uploadBodyParameterAndCreateChangeSet(ioHelper, options) {
       role: executionRoleArn
     });
   } catch (e) {
-    await ioHelper.notify(IO.DEFAULT_TOOLKIT_DEBUG.msg(String(e)));
-    await ioHelper.notify(IO.DEFAULT_TOOLKIT_INFO.msg(
-      "Could not create a change set, will base the diff on template differences (run again with -v to see the reason)\n"
-    ));
-    return void 0;
+    if (!options.failOnError) {
+      await ioHelper.notify(IO.DEFAULT_TOOLKIT_DEBUG.msg(String(e)));
+      await ioHelper.notify(IO.DEFAULT_TOOLKIT_INFO.msg(
+        "Could not create a change set, will base the diff on template differences (run again with -v to see the reason)\n"
+      ));
+      return void 0;
+    }
+    throw new ToolkitError("Could not create a change set and failOnError is set. (run again with failOnError off to base the diff on template differences)\n", e);
   }
 }
 async function uploadStackTemplateAssets(stack, deployments) {
@@ -8901,7 +8931,6 @@ var Context = class {
 
 // ../tmp-toolkit-helpers/src/api/diff/diff-formatter.ts
 var import_node_util2 = require("node:util");
-var import_stream2 = require("stream");
 var cxschema3 = __toESM(require("@aws-cdk/cloud-assembly-schema"));
 var import_cloudformation_diff = require("@aws-cdk/cloudformation-diff");
 var chalk10 = __toESM(require("chalk"));
@@ -8914,8 +8943,9 @@ var RequireApproval = /* @__PURE__ */ ((RequireApproval2) => {
   return RequireApproval2;
 })(RequireApproval || {});
 
-// ../tmp-toolkit-helpers/src/api/diff/diff-formatter.ts
-var StringWriteStream = class extends import_stream2.Writable {
+// ../tmp-toolkit-helpers/src/api/streams.ts
+var import_node_stream = require("node:stream");
+var StringWriteStream = class extends import_node_stream.Writable {
   buffer = [];
   constructor() {
     super();
@@ -8928,6 +8958,8 @@ var StringWriteStream = class extends import_stream2.Writable {
     return this.buffer.join("");
   }
 };
+
+// ../tmp-toolkit-helpers/src/api/diff/diff-formatter.ts
 var DiffFormatter = class {
   ioHelper;
   oldTemplate;
@@ -8936,15 +8968,23 @@ var DiffFormatter = class {
   changeSet;
   nestedStacks;
   isImport;
+  /**
+   * Stores the TemplateDiffs that get calculated in this DiffFormatter,
+   * indexed by the stack name.
+   */
+  _diffs = {};
   constructor(props) {
     this.ioHelper = props.ioHelper;
     this.oldTemplate = props.templateInfo.oldTemplate;
     this.newTemplate = props.templateInfo.newTemplate;
-    this.stackName = props.templateInfo.stackName;
+    this.stackName = props.templateInfo.newTemplate.stackName;
     this.changeSet = props.templateInfo.changeSet;
     this.nestedStacks = props.templateInfo.nestedStacks;
     this.isImport = props.templateInfo.isImport ?? false;
   }
+  get diffs() {
+    return this._diffs;
+  }
   /**
    * Format the stack diff
    */
@@ -8962,6 +9002,7 @@ var DiffFormatter = class {
   }
   formatStackDiffHelper(oldTemplate, stackName, nestedStackTemplates, options) {
     let diff = (0, import_cloudformation_diff.fullDiff)(oldTemplate, this.newTemplate.template, this.changeSet, this.isImport);
+    this._diffs[stackName] = diff;
     const stream = new StringWriteStream();
     let numStacksWithChanges = 0;
     let formattedDiff = "";
@@ -9028,6 +9069,7 @@ var DiffFormatter = class {
   formatSecurityDiff(options) {
     const ioDefaultHelper = new IoDefaultMessages(this.ioHelper);
     const diff = (0, import_cloudformation_diff.fullDiff)(this.oldTemplate, this.newTemplate.template, this.changeSet);
+    this._diffs[this.stackName] = diff;
     if (diffRequiresApproval(diff, options.requireApproval)) {
       const stream = new StringWriteStream();
       stream.write((0, import_node_util2.format)(`Stack ${chalk10.bold(this.stackName)}
@@ -10098,8 +10140,294 @@ function findAllLogGroupNames(stackResources, evaluateCfnTemplate) {
   return logGroupNames;
 }
 
+// ../tmp-toolkit-helpers/src/api/refactoring/index.ts
+var import_cloudformation_diff2 = require("@aws-cdk/cloudformation-diff");
+
+// ../tmp-toolkit-helpers/src/api/refactoring/digest.ts
+var crypto2 = __toESM(require("node:crypto"));
+var import_util40 = require("@aws-cdk/cloudformation-diff/lib/diff/util");
+function computeResourceDigests(template) {
+  const resources = template.Resources || {};
+  const graph = {};
+  const reverseGraph = {};
+  for (const id of Object.keys(resources)) {
+    graph[id] = /* @__PURE__ */ new Set();
+    reverseGraph[id] = /* @__PURE__ */ new Set();
+  }
+  const findDependencies = (value) => {
+    if (!value || typeof value !== "object") return [];
+    if (Array.isArray(value)) {
+      return value.flatMap(findDependencies);
+    }
+    if ("Ref" in value) {
+      return [value.Ref];
+    }
+    if ("Fn::GetAtt" in value) {
+      const refTarget = Array.isArray(value["Fn::GetAtt"]) ? value["Fn::GetAtt"][0] : value["Fn::GetAtt"].split(".")[0];
+      return [refTarget];
+    }
+    if ("DependsOn" in value) {
+      return [value.DependsOn];
+    }
+    return Object.values(value).flatMap(findDependencies);
+  };
+  for (const [id, res] of Object.entries(resources)) {
+    const deps = findDependencies(res || {});
+    for (const dep of deps) {
+      if (dep in resources && dep !== id) {
+        graph[id].add(dep);
+        reverseGraph[dep].add(id);
+      }
+    }
+  }
+  const outDegree = Object.keys(graph).reduce((acc, k) => {
+    acc[k] = graph[k].size;
+    return acc;
+  }, {});
+  const queue = Object.keys(outDegree).filter((k) => outDegree[k] === 0);
+  const order = [];
+  while (queue.length > 0) {
+    const node = queue.shift();
+    order.push(node);
+    for (const nxt of reverseGraph[node]) {
+      outDegree[nxt]--;
+      if (outDegree[nxt] === 0) {
+        queue.push(nxt);
+      }
+    }
+  }
+  const result2 = {};
+  for (const id of order) {
+    const resource = resources[id];
+    const resourceProperties = resource.Properties ?? {};
+    const model = (0, import_util40.loadResourceModel)(resource.Type);
+    const identifier = intersection2(Object.keys(resourceProperties), model?.primaryIdentifier ?? []);
+    let toHash;
+    if (identifier.length === model?.primaryIdentifier?.length) {
+      toHash = resource.Type + identifier.sort().map((attr) => JSON.stringify(resourceProperties[attr])).join("");
+    } else {
+      const depDigests = Array.from(graph[id]).map((d) => result2[d]);
+      const propertiesHash = hashObject(stripReferences(stripConstructPath(resource)));
+      toHash = resource.Type + propertiesHash + depDigests.join("");
+    }
+    result2[id] = crypto2.createHash("sha256").update(toHash).digest("hex");
+  }
+  return result2;
+}
+function hashObject(obj) {
+  const hash = crypto2.createHash("sha256");
+  function addToHash(value) {
+    if (value == null) {
+      addToHash("null");
+    } else if (typeof value === "object") {
+      if (Array.isArray(value)) {
+        value.forEach(addToHash);
+      } else {
+        Object.keys(value).sort().forEach((key) => {
+          hash.update(key);
+          addToHash(value[key]);
+        });
+      }
+    } else {
+      hash.update(typeof value + value.toString());
+    }
+  }
+  addToHash(obj);
+  return hash.digest("hex");
+}
+function stripReferences(value) {
+  if (!value || typeof value !== "object") return value;
+  if (Array.isArray(value)) {
+    return value.map(stripReferences);
+  }
+  if ("Ref" in value) {
+    return { __cloud_ref__: "Ref" };
+  }
+  if ("Fn::GetAtt" in value) {
+    return { __cloud_ref__: "Fn::GetAtt" };
+  }
+  if ("DependsOn" in value) {
+    return { __cloud_ref__: "DependsOn" };
+  }
+  const result2 = {};
+  for (const [k, v] of Object.entries(value)) {
+    result2[k] = stripReferences(v);
+  }
+  return result2;
+}
+function stripConstructPath(resource) {
+  if (resource?.Metadata?.["aws:cdk:path"] == null) {
+    return resource;
+  }
+  const copy = JSON.parse(JSON.stringify(resource));
+  delete copy.Metadata["aws:cdk:path"];
+  return copy;
+}
+function intersection2(a, b) {
+  return a.filter((value) => b.includes(value));
+}
+
+// ../tmp-toolkit-helpers/src/api/refactoring/index.ts
+var AmbiguityError = class extends Error {
+  constructor(movements) {
+    super("Ambiguous resource mappings");
+    this.movements = movements;
+  }
+  paths() {
+    return this.movements.map(([a, b]) => [convert(a), convert(b)]);
+    function convert(locations) {
+      return locations.map((l) => l.toPath());
+    }
+  }
+};
+var ResourceLocation = class {
+  constructor(stack, logicalResourceId) {
+    this.stack = stack;
+    this.logicalResourceId = logicalResourceId;
+  }
+  toPath() {
+    const stack = this.stack;
+    const resource = stack.template.Resources?.[this.logicalResourceId];
+    const result2 = resource?.Metadata?.["aws:cdk:path"];
+    if (result2 != null) {
+      return result2;
+    }
+    return `${stack.stackName}.${this.logicalResourceId}`;
+  }
+  getType() {
+    const resource = this.stack.template.Resources?.[this.logicalResourceId ?? ""];
+    return resource?.Type ?? "Unknown";
+  }
+  equalTo(other) {
+    return this.logicalResourceId === other.logicalResourceId && this.stack.stackName === other.stack.stackName;
+  }
+};
+var ResourceMapping = class {
+  constructor(source, destination) {
+    this.source = source;
+    this.destination = destination;
+  }
+  toTypedMapping() {
+    return {
+      // the type is the same in both source and destination,
+      // so we can use either one
+      type: this.source.getType(),
+      sourcePath: this.source.toPath(),
+      destinationPath: this.destination.toPath()
+    };
+  }
+};
+function groupByKey(entries) {
+  const result2 = {};
+  for (const [hash, location] of entries) {
+    if (hash in result2) {
+      result2[hash].push(location);
+    } else {
+      result2[hash] = [location];
+    }
+  }
+  return result2;
+}
+function resourceMovements(before, after) {
+  return Object.values(
+    removeUnmovedResources(
+      zip(groupByKey(before.flatMap(resourceDigests)), groupByKey(after.flatMap(resourceDigests)))
+    )
+  );
+}
+function ambiguousMovements(movements) {
+  return movements.filter(([pre, post]) => pre.length > 0 && post.length > 0).filter(([pre, post]) => pre.length > 1 || post.length > 1);
+}
+function resourceMappings(movements) {
+  return movements.filter(([pre, post]) => pre.length === 1 && post.length === 1 && !pre[0].equalTo(post[0])).map(([pre, post]) => new ResourceMapping(pre[0], post[0]));
+}
+function removeUnmovedResources(m) {
+  const result2 = {};
+  for (const [hash, [before, after]] of Object.entries(m)) {
+    const common = before.filter((b) => after.some((a) => a.equalTo(b)));
+    result2[hash] = [
+      before.filter((b) => !common.some((c) => b.equalTo(c))),
+      after.filter((a) => !common.some((c) => a.equalTo(c)))
+    ];
+  }
+  return result2;
+}
+function zip(m1, m2) {
+  const result2 = {};
+  for (const [hash, locations] of Object.entries(m1)) {
+    if (hash in m2) {
+      result2[hash] = [locations, m2[hash]];
+    } else {
+      result2[hash] = [locations, []];
+    }
+  }
+  for (const [hash, locations] of Object.entries(m2)) {
+    if (!(hash in m1)) {
+      result2[hash] = [[], locations];
+    }
+  }
+  return result2;
+}
+function resourceDigests(stack) {
+  const digests = computeResourceDigests(stack.template);
+  return Object.entries(digests).map(([logicalId, digest]) => {
+    const location = new ResourceLocation(stack, logicalId);
+    return [digest, location];
+  });
+}
+async function findResourceMovements(stacks, sdkProvider) {
+  const stackGroups = /* @__PURE__ */ new Map();
+  for (const stack of stacks) {
+    const environment = stack.environment;
+    const key = hashObject(environment);
+    if (stackGroups.has(key)) {
+      stackGroups.get(key)[1].push(stack);
+    } else {
+      const before = await getDeployedStacks(sdkProvider, environment);
+      stackGroups.set(key, [before, [stack]]);
+    }
+  }
+  const result2 = [];
+  for (const [_, [before, after]] of stackGroups) {
+    result2.push(...resourceMovements(before, after));
+  }
+  return result2;
+}
+async function getDeployedStacks(sdkProvider, environment) {
+  const cfn = (await sdkProvider.forEnvironment(environment, 0 /* ForReading */)).sdk.cloudFormation();
+  const summaries = await cfn.paginatedListStacks({
+    StackStatusFilter: [
+      "CREATE_COMPLETE",
+      "UPDATE_COMPLETE",
+      "UPDATE_ROLLBACK_COMPLETE",
+      "IMPORT_COMPLETE",
+      "ROLLBACK_COMPLETE"
+    ]
+  });
+  const normalize = async (summary) => {
+    const templateCommandOutput = await cfn.getTemplate({ StackName: summary.StackName });
+    const template = deserializeStructure(templateCommandOutput.TemplateBody ?? "{}");
+    return {
+      environment,
+      stackName: summary.StackName,
+      template
+    };
+  };
+  return Promise.all(summaries.map(normalize));
+}
+function formatTypedMappings(mappings) {
+  const stream = new StringWriteStream();
+  (0, import_cloudformation_diff2.formatTypedMappings)(stream, mappings);
+  return stream.toString();
+}
+function formatAmbiguousMappings(paths) {
+  const stream = new StringWriteStream();
+  (0, import_cloudformation_diff2.formatAmbiguousMappings)(stream, paths);
+  return stream.toString();
+}
+
 // ../tmp-toolkit-helpers/src/api/resource-import/importer.ts
-var import_util40 = require("util");
+var import_util42 = require("util");
 var cfnDiff = __toESM(require("@aws-cdk/cloudformation-diff"));
 var chalk14 = __toESM(require("chalk"));
 var fs13 = __toESM(require("fs-extra"));
@@ -10140,12 +10468,12 @@ var ResourceImporter = class {
       const descr = this.describeResource(resource.logicalId);
       const idProps = contents[resource.logicalId];
       if (idProps) {
-        await this.ioHelper.notify(IO.DEFAULT_TOOLKIT_INFO.msg((0, import_util40.format)("%s: importing using %s", chalk14.blue(descr), chalk14.blue(fmtdict(idProps)))));
+        await this.ioHelper.notify(IO.DEFAULT_TOOLKIT_INFO.msg((0, import_util42.format)("%s: importing using %s", chalk14.blue(descr), chalk14.blue(fmtdict(idProps)))));
         ret.importResources.push(resource);
         ret.resourceMap[resource.logicalId] = idProps;
         delete contents[resource.logicalId];
       } else {
-        await this.ioHelper.notify(IO.DEFAULT_TOOLKIT_INFO.msg((0, import_util40.format)("%s: skipping", chalk14.blue(descr))));
+        await this.ioHelper.notify(IO.DEFAULT_TOOLKIT_INFO.msg((0, import_util42.format)("%s: skipping", chalk14.blue(descr))));
       }
     }
     const unknown = Object.keys(contents);
@@ -10189,9 +10517,9 @@ var ResourceImporter = class {
       });
       assertIsSuccessfulDeployStackResult(result2);
       const message2 = result2.noOp ? " \u2705  %s (no changes)" : " \u2705  %s";
-      await this.ioHelper.notify(IO.DEFAULT_TOOLKIT_INFO.msg("\n" + chalk14.green((0, import_util40.format)(message2, this.stack.displayName))));
+      await this.ioHelper.notify(IO.DEFAULT_TOOLKIT_INFO.msg("\n" + chalk14.green((0, import_util42.format)(message2, this.stack.displayName))));
     } catch (e) {
-      await this.ioHelper.notify(IO.CDK_TOOLKIT_E3900.msg((0, import_util40.format)("\n \u274C  %s failed: %s", chalk14.bold(this.stack.displayName), e), { error: e }));
+      await this.ioHelper.notify(IO.CDK_TOOLKIT_E3900.msg((0, import_util42.format)("\n \u274C  %s failed: %s", chalk14.bold(this.stack.displayName), e), { error: e }));
       throw e;
     }
   }
@@ -10470,14 +10798,18 @@ var RWLock = class {
    */
   async acquireWrite() {
     await this.assertNoOtherWriters();
-    const readers = await this.currentReaders();
+    const readers = await this._currentReaders();
     if (readers.length > 0) {
       throw new ToolkitError(`Other CLIs (PID=${readers}) are currently reading from ${this.directory}. Invoke the CLI in sequence, or use '--output' to synth into different directories.`);
     }
     await writeFileAtomic(this.writerFile, this.pidString);
+    let released = false;
     return {
       release: async () => {
-        await deleteFile(this.writerFile);
+        if (!released) {
+          await deleteFile(this.writerFile);
+          released = true;
+        }
       },
       convertToReaderLock: async () => {
         const ret = await this.doAcquireRead();
@@ -10511,22 +10843,30 @@ var RWLock = class {
   async doAcquireRead() {
     const readerFile = this.readerFile();
     await writeFileAtomic(readerFile, this.pidString);
+    let released = false;
     return {
       release: async () => {
-        await deleteFile(readerFile);
+        if (!released) {
+          await deleteFile(readerFile);
+          released = true;
+        }
       }
     };
   }
   async assertNoOtherWriters() {
-    const writer = await this.currentWriter();
+    const writer = await this._currentWriter();
     if (writer) {
       throw new ToolkitError(`Another CLI (PID=${writer}) is currently synthing to ${this.directory}. Invoke the CLI in sequence, or use '--output' to synth into different directories.`);
     }
   }
   /**
    * Check the current writer (if any)
+   *
+   * Publicly accessible for testing purposes. Do not use.
+   *
+   * @internal
    */
-  async currentWriter() {
+  async _currentWriter() {
     const contents = await readFileIfExists(this.writerFile);
     if (!contents) {
       return void 0;
@@ -10540,8 +10880,12 @@ var RWLock = class {
   }
   /**
    * Check the current readers (if any)
+   *
+   * Publicly accessible for testing purposes. Do not use.
+   *
+   * @internal
    */
-  async currentReaders() {
+  async _currentReaders() {
     const re = /^read\.([^.]+)\.[^.]+\.lock$/;
     const ret = new Array();
     let children;
@@ -12031,6 +12375,7 @@ var availableContextProviders = {
   AccountAccessKeyCache,
   ActiveAssetCache,
   ActivityPrinterBase,
+  AmbiguityError,
   AssemblyError,
   AssetManifestBuilder,
   AuthenticationError,
@@ -12090,6 +12435,8 @@ var availableContextProviders = {
   RWLock,
   RequireApproval,
   ResourceImporter,
+  ResourceLocation,
+  ResourceMapping,
   ResourceMigrator,
   RollbackChoice,
   S3_ISOLATED_TAG,
@@ -12113,6 +12460,7 @@ var availableContextProviders = {
   WorkGraph,
   WorkGraphBuilder,
   addMetadataAssetsToManifest,
+  ambiguousMovements,
   asIoHelper,
   assertIsSuccessfulDeployStackResult,
   cached,
@@ -12126,7 +12474,10 @@ var availableContextProviders = {
   determineAllowCrossAccountAssetPublishing,
   error,
   findCloudWatchLogGroups,
+  findResourceMovements,
+  formatAmbiguousMappings,
   formatSdkLoggerContent,
+  formatTypedMappings,
   getBootstrapStackInfo,
   guessExecutable,
   info,
@@ -12147,6 +12498,8 @@ var availableContextProviders = {
   refreshStacks,
   removeNonImportResources,
   replaceEnvPlaceholders,
+  resourceMappings,
+  resourceMovements,
   result,
   setSdkTracing,
   some,