add checkDestructiveChanges.ts

Author: anthony-nhs

packages/deploymentUtils/src/changesets/checkDestructiveChanges.ts

@@ -0,0 +1,63 @@
+import {readFileSync} from "node:fs"
+
+export type ChangeRequiringAttention = {
+  logicalId: string;
+  physicalId: string;
+  resourceType: string;
+  reason: string;
+}
+
+type RawChange = {
+  ResourceChange?: {
+    LogicalResourceId?: string;
+    PhysicalResourceId?: string;
+    ResourceType?: string;
+    Replacement?: unknown;
+    Action?: string;
+  } | null;
+}
+
+const requiresReplacement = (replacement: unknown): boolean => {
+  if (replacement === undefined || replacement === null) {
+    return false
+  }
+
+  const normalized = String(replacement)
+  return normalized === "True" || normalized === "Conditional"
+}
+
+export function checkDestructiveChanges(filePath: string): Array<ChangeRequiringAttention> {
+  if (!filePath) {
+    throw new Error("A change set file path must be provided")
+  }
+
+  const raw = readFileSync(filePath, "utf-8")
+  const data = JSON.parse(raw)
+  const changes = Array.isArray(data?.Changes) ? data.Changes : []
+
+  return changes
+    .map((change: RawChange) => {
+      const resourceChange = change?.ResourceChange
+      if (!resourceChange) {
+        return undefined
+      }
+
+      const replacementNeeded = requiresReplacement(resourceChange.Replacement)
+      const action = resourceChange.Action
+      const isRemoval = action === "Remove"
+
+      if (!replacementNeeded && !isRemoval) {
+        return undefined
+      }
+
+      return {
+        logicalId: resourceChange.LogicalResourceId ?? "<unknown logical id>",
+        physicalId: resourceChange.PhysicalResourceId ?? "<unknown physical id>",
+        resourceType: resourceChange.ResourceType ?? "<unknown type>",
+        reason: replacementNeeded
+          ? `Replacement: ${String(resourceChange.Replacement)}`
+          : `Action: ${action ?? "<unknown action>"}`
+      }
+    })
+    .filter((change): change is ChangeRequiringAttention => Boolean(change))
+}

packages/deploymentUtils/src/index.ts

@@ -2,3 +2,4 @@ export * from "./specifications/deployApi"
 export * from "./specifications/writeSchemas"
 export * from "./specifications/deleteProxygenDeployments"
 export * from "./config/index"
+export * from "./changesets/checkDestructiveChanges"

packages/deploymentUtils/tests/changesets/checkDestructiveChanges.test.ts

@@ -0,0 +1,63 @@
+import {mkdtempSync, writeFileSync} from "node:fs"
+import {tmpdir} from "node:os"
+import {dirname, join} from "node:path"
+import {fileURLToPath} from "node:url"
+import {describe, expect, test} from "vitest"
+import {checkDestructiveChanges} from "../../src/changesets/checkDestructiveChanges"
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = dirname(__filename)
+const fixturesDir = join(__dirname, "examples")
+
+const destructiveChangeSet = join(fixturesDir, "destructive_changeset.json")
+const safeChangeSet = join(fixturesDir, "safe_changeset.json")
+
+describe("checkDestructiveChanges", () => {
+  test("returns resources that require replacement", () => {
+    const replacements = checkDestructiveChanges(destructiveChangeSet)
+
+    expect(replacements.length).toBeGreaterThan(0)
+    expect(replacements).toContainEqual({
+      logicalId: "AlarmsAccountLambdaConcurrencyAlarm8AF49AD8",
+      physicalId: "monitoring-Account_Lambda_Concurrency",
+      resourceType: "AWS::CloudWatch::Alarm",
+      reason: "Replacement: True"
+    })
+  })
+
+  test("returns an empty array when no replacements or removals exist", () => {
+    const replacements = checkDestructiveChanges(safeChangeSet)
+
+    expect(replacements).toEqual([])
+  })
+
+  test("includes resources marked for removal", () => {
+    const tempDir = mkdtempSync(join(tmpdir(), "changeset-"))
+    const removalFixture = join(tempDir, "removal.json")
+    const changeSet = {
+      Changes: [
+        {
+          ResourceChange: {
+            LogicalResourceId: "ResourceToRemove",
+            PhysicalResourceId: "physical-id",
+            ResourceType: "AWS::S3::Bucket",
+            Action: "Remove",
+            Replacement: "False"
+          }
+        }
+      ]
+    }
+    writeFileSync(removalFixture, JSON.stringify(changeSet), "utf-8")
+
+    const replacements = checkDestructiveChanges(removalFixture)
+
+    expect(replacements).toEqual([
+      {
+        logicalId: "ResourceToRemove",
+        physicalId: "physical-id",
+        resourceType: "AWS::S3::Bucket",
+        reason: "Action: Remove"
+      }
+    ])
+  })
+})