cloudformation-stack-drift-detector 0.1.1

package/lib/funcs/detector-function.d.ts

@@ -0,0 +1,13 @@
+import * as lambda from 'aws-cdk-lib/aws-lambda';
+import { Construct } from 'constructs';
+/**
+ * Props for DetectorFunction
+ */
+export interface DetectorFunctionProps extends lambda.FunctionOptions {
+}
+/**
+ * An AWS Lambda function which executes src/funcs/detector.
+ */
+export declare class DetectorFunction extends lambda.Function {
+    constructor(scope: Construct, id: string, props?: DetectorFunctionProps);
+}

package/lib/funcs/detector-function.js

@@ -0,0 +1,56 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DetectorFunction = void 0;
+// ~~ Generated by projen. To modify, edit .projenrc.ts and run "npx projen".
+const path = __importStar(require("path"));
+const lambda = __importStar(require("aws-cdk-lib/aws-lambda"));
+/**
+ * An AWS Lambda function which executes src/funcs/detector.
+ */
+class DetectorFunction extends lambda.Function {
+    constructor(scope, id, props) {
+        super(scope, id, {
+            description: 'src/funcs/detector.lambda.ts',
+            ...props,
+            runtime: new lambda.Runtime('nodejs22.x', lambda.RuntimeFamily.NODEJS),
+            handler: 'index.handler',
+            code: lambda.Code.fromAsset(path.join(__dirname, '../../assets/funcs/detector.lambda')),
+        });
+        this.addEnvironment('AWS_NODEJS_CONNECTION_REUSE_ENABLED', '1', { removeInEdge: true });
+    }
+}
+exports.DetectorFunction = DetectorFunction;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/funcs/detector.lambda.d.ts

@@ -0,0 +1,23 @@
+import { DurableContext } from '@aws/durable-execution-sdk-js';
+/**
+ * EventBridge input that selects stacks for drift detection.
+ * When `tagKey` is omitted, all stable stacks are inspected.
+ */
+export interface DriftDetectionEvent {
+    /** Tag key used to discover CloudFormation stacks. */
+    readonly tagKey?: string;
+    /**
+     * Tag values to match for {@link DriftDetectionEvent.tagKey}.
+     * If omitted, any value for the key is accepted.
+     */
+    readonly tagValues?: string[];
+}
+/**
+ * Discovers target stacks and detects drift sequentially.
+ *
+ * @param event - Optional tag filter used to select stacks.
+ * @param context - Durable execution context for steps and waits.
+ */
+export declare function processDriftDetection(event: DriftDetectionEvent, context: DurableContext): Promise<void>;
+/** Durable Lambda handler wrapping {@link processDriftDetection}. */
+export declare const handler: import("@aws/durable-execution-sdk-js").DurableLambdaHandler;

package/lib/funcs/detector.lambda.js

@@ -0,0 +1,226 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handler = void 0;
+exports.processDriftDetection = processDriftDetection;
+const durable_execution_sdk_js_1 = require("@aws/durable-execution-sdk-js");
+const client_cloudformation_1 = require("@aws-sdk/client-cloudformation");
+const client_resource_groups_tagging_api_1 = require("@aws-sdk/client-resource-groups-tagging-api");
+const client_sns_1 = require("@aws-sdk/client-sns");
+/** Interval between DescribeStackDriftDetectionStatus polls. */
+const DETECTION_POLL_INTERVAL_SECONDS = 30;
+/** Environment variable that holds the SNS topic ARN for drift notifications. */
+const NOTIFICATION_TOPIC_ARN_ENV = 'NOTIFICATION_TOPIC_ARN';
+/** Resource Groups Tagging API type used to discover CloudFormation stacks. */
+const CLOUDFORMATION_STACK_RESOURCE_TYPE = 'cloudformation:stack';
+/** Stack statuses that are eligible for drift detection. */
+const STABLE_STACK_STATUSES = [
+    client_cloudformation_1.StackStatus.CREATE_COMPLETE,
+    client_cloudformation_1.StackStatus.UPDATE_COMPLETE,
+    client_cloudformation_1.StackStatus.UPDATE_ROLLBACK_COMPLETE,
+    client_cloudformation_1.StackStatus.IMPORT_COMPLETE,
+    client_cloudformation_1.StackStatus.IMPORT_ROLLBACK_COMPLETE,
+];
+/** Shared CloudFormation client for drift detection APIs. */
+const cloudFormation = new client_cloudformation_1.CloudFormationClient({});
+/** Shared tagging client used to resolve stacks by tag. */
+const resourceGroupsTagging = new client_resource_groups_tagging_api_1.ResourceGroupsTaggingAPIClient({});
+/** Shared SNS client used to publish drift notifications. */
+const sns = new client_sns_1.SNSClient({});
+/**
+ * Reads the SNS topic ARN from the Lambda environment.
+ *
+ * @returns The notification topic ARN.
+ * @throws When {@link NOTIFICATION_TOPIC_ARN_ENV} is not set.
+ */
+function getNotificationTopicArn() {
+    const topicArn = process.env[NOTIFICATION_TOPIC_ARN_ENV];
+    if (!topicArn) {
+        throw new Error(`${NOTIFICATION_TOPIC_ARN_ENV} environment variable is not set`);
+    }
+    return topicArn;
+}
+/**
+ * Extracts a CloudFormation stack name from a stack ARN.
+ *
+ * @param resourceArn - Stack ARN in `arn:...:stack/{name}/{id}` form.
+ * @returns The stack name.
+ * @throws When the ARN does not contain a stack name.
+ */
+function getStackNameFromArn(resourceArn) {
+    const resource = resourceArn.split(':').pop();
+    const stackName = resource?.split('/')[1];
+    if (!stackName) {
+        throw new Error(`Unable to get stack name from ARN: ${resourceArn}`);
+    }
+    return stackName;
+}
+/**
+ * Lists CloudFormation stacks that match the given tag filter.
+ *
+ * @param tagKey - Tag key to match.
+ * @param tagValues - Optional values for `tagKey`. An empty or omitted list matches any value.
+ * @returns Stack names discovered by the Resource Groups Tagging API.
+ */
+async function getTaggedStackNames(tagKey, tagValues) {
+    const stackNames = [];
+    let paginationToken;
+    do {
+        const response = await resourceGroupsTagging.send(new client_resource_groups_tagging_api_1.GetResourcesCommand({
+            ResourceTypeFilters: [CLOUDFORMATION_STACK_RESOURCE_TYPE],
+            TagFilters: [
+                {
+                    Key: tagKey,
+                    Values: tagValues && tagValues.length > 0 ? tagValues : undefined,
+                },
+            ],
+            PaginationToken: paginationToken,
+        }));
+        for (const mapping of response.ResourceTagMappingList ?? []) {
+            if (mapping.ResourceARN) {
+                stackNames.push(getStackNameFromArn(mapping.ResourceARN));
+            }
+        }
+        paginationToken = response.PaginationToken;
+    } while (paginationToken);
+    return stackNames;
+}
+/**
+ * Lists all stable CloudFormation stacks in the current account and region.
+ *
+ * @returns Stack names in a complete, non-transitional status.
+ */
+async function getAllStackNames() {
+    const stackNames = [];
+    let nextToken;
+    do {
+        const response = await cloudFormation.send(new client_cloudformation_1.ListStacksCommand({
+            StackStatusFilter: STABLE_STACK_STATUSES,
+            NextToken: nextToken,
+        }));
+        for (const summary of response.StackSummaries ?? []) {
+            if (summary.StackName) {
+                stackNames.push(summary.StackName);
+            }
+        }
+        nextToken = response.NextToken;
+    } while (nextToken);
+    return stackNames;
+}
+/**
+ * Resolves target stack names from the detector event.
+ *
+ * @param event - Tag filter from EventBridge, or an empty object for all stacks.
+ * @returns Stack names to inspect for drift.
+ */
+async function getTargetStackNames(event) {
+    if (event.tagKey) {
+        return getTaggedStackNames(event.tagKey, event.tagValues);
+    }
+    return getAllStackNames();
+}
+/**
+ * Returns modified or deleted resource drifts for a stack.
+ *
+ * @param stackName - Stack to describe.
+ * @returns Resource drift records filtered to `MODIFIED` and `DELETED`.
+ */
+async function getResourceDrifts(stackName) {
+    const resourceDrifts = [];
+    let nextToken;
+    do {
+        const response = await cloudFormation.send(new client_cloudformation_1.DescribeStackResourceDriftsCommand({
+            StackName: stackName,
+            StackResourceDriftStatusFilters: ['MODIFIED', 'DELETED'],
+            NextToken: nextToken,
+        }));
+        resourceDrifts.push(...(response.StackResourceDrifts ?? []));
+        nextToken = response.NextToken;
+    } while (nextToken);
+    return resourceDrifts;
+}
+/**
+ * Polls DescribeStackDriftDetectionStatus until detection is no longer in progress.
+ *
+ * @param stackName - Stack used in durable step and wait names.
+ * @param detectionId - ID returned by DetectStackDrift.
+ * @param context - Durable execution context.
+ * @returns The completed detection status.
+ */
+async function getDriftDetectionStatus(stackName, detectionId, context) {
+    let attempt = 0;
+    let status;
+    do {
+        await context.wait(`wait-drift-detection-${stackName}-${attempt}`, {
+            seconds: DETECTION_POLL_INTERVAL_SECONDS,
+        });
+        status = await context.step(`describe-drift-detection-status-${stackName}-${attempt}`, async () => {
+            const response = await cloudFormation.send(new client_cloudformation_1.DescribeStackDriftDetectionStatusCommand({
+                StackDriftDetectionId: detectionId,
+            }));
+            return {
+                detectionStatus: response.DetectionStatus,
+                stackDriftStatus: response.StackDriftStatus,
+                detectionStatusReason: response.DetectionStatusReason,
+            };
+        });
+        attempt += 1;
+    } while (status.detectionStatus === 'DETECTION_IN_PROGRESS');
+    return status;
+}
+/**
+ * Detects drift for one stack and publishes an SNS notification when the stack has drifted.
+ *
+ * @param stackName - Stack to inspect.
+ * @param topicArn - SNS topic that receives drift notifications.
+ * @param context - Durable execution context.
+ * @throws When DetectStackDrift returns no ID, or detection finishes with `DETECTION_FAILED`.
+ */
+async function processStackDrift(stackName, topicArn, context) {
+    const detectionId = await context.step(`detect-stack-drift-${stackName}`, async () => {
+        const response = await cloudFormation.send(new client_cloudformation_1.DetectStackDriftCommand({
+            StackName: stackName,
+        }));
+        if (!response.StackDriftDetectionId) {
+            throw new Error(`DetectStackDrift did not return a detection ID for stack ${stackName}`);
+        }
+        return response.StackDriftDetectionId;
+    });
+    const status = await getDriftDetectionStatus(stackName, detectionId, context);
+    if (status.detectionStatus === 'DETECTION_FAILED') {
+        throw new Error(`Drift detection failed for stack ${stackName}: ${status.detectionStatusReason ?? 'unknown reason'}`);
+    }
+    if (status.stackDriftStatus !== 'DRIFTED') {
+        return;
+    }
+    const resourceDrifts = await context.step(`describe-resource-drifts-${stackName}`, async () => getResourceDrifts(stackName));
+    await context.step(`publish-notification-${stackName}`, async () => {
+        const subject = `Stack drift detected: ${stackName}`.slice(0, 100);
+        await sns.send(new client_sns_1.PublishCommand({
+            TopicArn: topicArn,
+            Subject: subject,
+            Message: JSON.stringify({
+                stackName,
+                stackDriftStatus: status.stackDriftStatus,
+                driftedResources: resourceDrifts,
+            }),
+        }));
+    });
+}
+/**
+ * Discovers target stacks and detects drift sequentially.
+ *
+ * @param event - Optional tag filter used to select stacks.
+ * @param context - Durable execution context for steps and waits.
+ */
+async function processDriftDetection(event, context) {
+    const topicArn = getNotificationTopicArn();
+    const stackNames = await context.step('get-target-stack-names', async () => {
+        return getTargetStackNames(event ?? {});
+    });
+    for (const stackName of stackNames) {
+        await processStackDrift(stackName, topicArn, context);
+    }
+}
+/** Durable Lambda handler wrapping {@link processDriftDetection}. */
+exports.handler = (0, durable_execution_sdk_js_1.withDurableExecution)(processDriftDetection);
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"detector.lambda.js","sourceRoot":"","sources":["../../src/funcs/detector.lambda.ts"],"names":[],"mappings":"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","sourcesContent":["import { DurableContext, withDurableExecution } from '@aws/durable-execution-sdk-js';\nimport {\n  CloudFormationClient,\n  DescribeStackDriftDetectionStatusCommand,\n  DescribeStackResourceDriftsCommand,\n  DetectStackDriftCommand,\n  ListStacksCommand,\n  StackResourceDrift,\n  StackStatus,\n} from '@aws-sdk/client-cloudformation';\nimport {\n  GetResourcesCommand,\n  ResourceGroupsTaggingAPIClient,\n} from '@aws-sdk/client-resource-groups-tagging-api';\nimport { PublishCommand, SNSClient } from '@aws-sdk/client-sns';\n\n/** Interval between DescribeStackDriftDetectionStatus polls. */\nconst DETECTION_POLL_INTERVAL_SECONDS = 30;\n/** Environment variable that holds the SNS topic ARN for drift notifications. */\nconst NOTIFICATION_TOPIC_ARN_ENV = 'NOTIFICATION_TOPIC_ARN';\n/** Resource Groups Tagging API type used to discover CloudFormation stacks. */\nconst CLOUDFORMATION_STACK_RESOURCE_TYPE = 'cloudformation:stack';\n/** Stack statuses that are eligible for drift detection. */\nconst STABLE_STACK_STATUSES = [\n  StackStatus.CREATE_COMPLETE,\n  StackStatus.UPDATE_COMPLETE,\n  StackStatus.UPDATE_ROLLBACK_COMPLETE,\n  StackStatus.IMPORT_COMPLETE,\n  StackStatus.IMPORT_ROLLBACK_COMPLETE,\n];\n\n/** Shared CloudFormation client for drift detection APIs. */\nconst cloudFormation = new CloudFormationClient({});\n/** Shared tagging client used to resolve stacks by tag. */\nconst resourceGroupsTagging = new ResourceGroupsTaggingAPIClient({});\n/** Shared SNS client used to publish drift notifications. */\nconst sns = new SNSClient({});\n\n/**\n * EventBridge input that selects stacks for drift detection.\n * When `tagKey` is omitted, all stable stacks are inspected.\n */\nexport interface DriftDetectionEvent {\n  /** Tag key used to discover CloudFormation stacks. */\n  readonly tagKey?: string;\n  /**\n   * Tag values to match for {@link DriftDetectionEvent.tagKey}.\n   * If omitted, any value for the key is accepted.\n   */\n  readonly tagValues?: string[];\n}\n\n/** Checkpointed result of DescribeStackDriftDetectionStatus. */\ninterface DriftDetectionStatus {\n  /** Status of the drift detection operation. */\n  readonly detectionStatus: string | undefined;\n  /** Drift status of the stack after detection completes. */\n  readonly stackDriftStatus: string | undefined;\n  /** Reason returned when detection fails. */\n  readonly detectionStatusReason: string | undefined;\n}\n\n/**\n * Reads the SNS topic ARN from the Lambda environment.\n *\n * @returns The notification topic ARN.\n * @throws When {@link NOTIFICATION_TOPIC_ARN_ENV} is not set.\n */\nfunction getNotificationTopicArn(): string {\n  const topicArn = process.env[NOTIFICATION_TOPIC_ARN_ENV];\n  if (!topicArn) {\n    throw new Error(`${NOTIFICATION_TOPIC_ARN_ENV} environment variable is not set`);\n  }\n  return topicArn;\n}\n\n/**\n * Extracts a CloudFormation stack name from a stack ARN.\n *\n * @param resourceArn - Stack ARN in `arn:...:stack/{name}/{id}` form.\n * @returns The stack name.\n * @throws When the ARN does not contain a stack name.\n */\nfunction getStackNameFromArn(resourceArn: string): string {\n  const resource = resourceArn.split(':').pop();\n  const stackName = resource?.split('/')[1];\n  if (!stackName) {\n    throw new Error(`Unable to get stack name from ARN: ${resourceArn}`);\n  }\n  return stackName;\n}\n\n/**\n * Lists CloudFormation stacks that match the given tag filter.\n *\n * @param tagKey - Tag key to match.\n * @param tagValues - Optional values for `tagKey`. An empty or omitted list matches any value.\n * @returns Stack names discovered by the Resource Groups Tagging API.\n */\nasync function getTaggedStackNames(tagKey: string, tagValues?: string[]): Promise<string[]> {\n  const stackNames: string[] = [];\n  let paginationToken: string | undefined;\n\n  do {\n    const response = await resourceGroupsTagging.send(new GetResourcesCommand({\n      ResourceTypeFilters: [CLOUDFORMATION_STACK_RESOURCE_TYPE],\n      TagFilters: [\n        {\n          Key: tagKey,\n          Values: tagValues && tagValues.length > 0 ? tagValues : undefined,\n        },\n      ],\n      PaginationToken: paginationToken,\n    }));\n\n    for (const mapping of response.ResourceTagMappingList ?? []) {\n      if (mapping.ResourceARN) {\n        stackNames.push(getStackNameFromArn(mapping.ResourceARN));\n      }\n    }\n\n    paginationToken = response.PaginationToken;\n  } while (paginationToken);\n\n  return stackNames;\n}\n\n/**\n * Lists all stable CloudFormation stacks in the current account and region.\n *\n * @returns Stack names in a complete, non-transitional status.\n */\nasync function getAllStackNames(): Promise<string[]> {\n  const stackNames: string[] = [];\n  let nextToken: string | undefined;\n\n  do {\n    const response = await cloudFormation.send(new ListStacksCommand({\n      StackStatusFilter: STABLE_STACK_STATUSES,\n      NextToken: nextToken,\n    }));\n\n    for (const summary of response.StackSummaries ?? []) {\n      if (summary.StackName) {\n        stackNames.push(summary.StackName);\n      }\n    }\n\n    nextToken = response.NextToken;\n  } while (nextToken);\n\n  return stackNames;\n}\n\n/**\n * Resolves target stack names from the detector event.\n *\n * @param event - Tag filter from EventBridge, or an empty object for all stacks.\n * @returns Stack names to inspect for drift.\n */\nasync function getTargetStackNames(event: DriftDetectionEvent): Promise<string[]> {\n  if (event.tagKey) {\n    return getTaggedStackNames(event.tagKey, event.tagValues);\n  }\n  return getAllStackNames();\n}\n\n/**\n * Returns modified or deleted resource drifts for a stack.\n *\n * @param stackName - Stack to describe.\n * @returns Resource drift records filtered to `MODIFIED` and `DELETED`.\n */\nasync function getResourceDrifts(stackName: string): Promise<StackResourceDrift[]> {\n  const resourceDrifts: StackResourceDrift[] = [];\n  let nextToken: string | undefined;\n\n  do {\n    const response = await cloudFormation.send(new DescribeStackResourceDriftsCommand({\n      StackName: stackName,\n      StackResourceDriftStatusFilters: ['MODIFIED', 'DELETED'],\n      NextToken: nextToken,\n    }));\n    resourceDrifts.push(...(response.StackResourceDrifts ?? []));\n    nextToken = response.NextToken;\n  } while (nextToken);\n\n  return resourceDrifts;\n}\n\n/**\n * Polls DescribeStackDriftDetectionStatus until detection is no longer in progress.\n *\n * @param stackName - Stack used in durable step and wait names.\n * @param detectionId - ID returned by DetectStackDrift.\n * @param context - Durable execution context.\n * @returns The completed detection status.\n */\nasync function getDriftDetectionStatus(\n  stackName: string,\n  detectionId: string,\n  context: DurableContext,\n): Promise<DriftDetectionStatus> {\n  let attempt = 0;\n  let status: DriftDetectionStatus;\n\n  do {\n    await context.wait(`wait-drift-detection-${stackName}-${attempt}`, {\n      seconds: DETECTION_POLL_INTERVAL_SECONDS,\n    });\n\n    status = await context.step(\n      `describe-drift-detection-status-${stackName}-${attempt}`,\n      async () => {\n        const response = await cloudFormation.send(new DescribeStackDriftDetectionStatusCommand({\n          StackDriftDetectionId: detectionId,\n        }));\n        return {\n          detectionStatus: response.DetectionStatus,\n          stackDriftStatus: response.StackDriftStatus,\n          detectionStatusReason: response.DetectionStatusReason,\n        };\n      },\n    );\n\n    attempt += 1;\n  } while (status.detectionStatus === 'DETECTION_IN_PROGRESS');\n\n  return status;\n}\n\n/**\n * Detects drift for one stack and publishes an SNS notification when the stack has drifted.\n *\n * @param stackName - Stack to inspect.\n * @param topicArn - SNS topic that receives drift notifications.\n * @param context - Durable execution context.\n * @throws When DetectStackDrift returns no ID, or detection finishes with `DETECTION_FAILED`.\n */\nasync function processStackDrift(\n  stackName: string,\n  topicArn: string,\n  context: DurableContext,\n): Promise<void> {\n  const detectionId = await context.step(`detect-stack-drift-${stackName}`, async () => {\n    const response = await cloudFormation.send(new DetectStackDriftCommand({\n      StackName: stackName,\n    }));\n    if (!response.StackDriftDetectionId) {\n      throw new Error(`DetectStackDrift did not return a detection ID for stack ${stackName}`);\n    }\n    return response.StackDriftDetectionId;\n  });\n\n  const status = await getDriftDetectionStatus(stackName, detectionId, context);\n\n  if (status.detectionStatus === 'DETECTION_FAILED') {\n    throw new Error(\n      `Drift detection failed for stack ${stackName}: ${status.detectionStatusReason ?? 'unknown reason'}`,\n    );\n  }\n\n  if (status.stackDriftStatus !== 'DRIFTED') {\n    return;\n  }\n\n  const resourceDrifts = await context.step(\n    `describe-resource-drifts-${stackName}`,\n    async () => getResourceDrifts(stackName),\n  );\n\n  await context.step(`publish-notification-${stackName}`, async () => {\n    const subject = `Stack drift detected: ${stackName}`.slice(0, 100);\n    await sns.send(new PublishCommand({\n      TopicArn: topicArn,\n      Subject: subject,\n      Message: JSON.stringify({\n        stackName,\n        stackDriftStatus: status.stackDriftStatus,\n        driftedResources: resourceDrifts,\n      }),\n    }));\n  });\n}\n\n/**\n * Discovers target stacks and detects drift sequentially.\n *\n * @param event - Optional tag filter used to select stacks.\n * @param context - Durable execution context for steps and waits.\n */\nexport async function processDriftDetection(\n  event: DriftDetectionEvent,\n  context: DurableContext,\n): Promise<void> {\n  const topicArn = getNotificationTopicArn();\n  const stackNames = await context.step('get-target-stack-names', async () => {\n    return getTargetStackNames(event ?? {});\n  });\n\n  for (const stackName of stackNames) {\n    await processStackDrift(stackName, topicArn, context);\n  }\n}\n\n/** Durable Lambda handler wrapping {@link processDriftDetection}. */\nexport const handler = withDurableExecution(processDriftDetection);\n"]}

package/lib/index.d.ts

@@ -0,0 +1,77 @@
+import { Duration } from 'aws-cdk-lib';
+import * as sns from 'aws-cdk-lib/aws-sns';
+import { Construct } from 'constructs';
+/**
+ * Tag filter used to select CloudFormation stacks for drift detection.
+ * When `tagValues` is omitted, all stacks that have `tagKey` are selected.
+ */
+export interface TargetResource {
+    /**
+     * Tag key used for stack discovery.
+     */
+    readonly tagKey: string;
+    /**
+     * Tag values to match. If omitted, any value for {@link TargetResource.tagKey} is accepted.
+     */
+    readonly tagValues?: string[];
+}
+/**
+ * Properties for {@link CloudformationStackDriftDetector}.
+ */
+export interface CloudformationStackDriftDetectorProps {
+    /**
+     * SNS topic used to notify when a stack has drifted.
+     */
+    readonly notificationTopic: sns.ITopic;
+    /**
+     * Tag filter used to select target stacks.
+     * If omitted, all stacks in the account and region are inspected.
+     */
+    readonly targetResource?: TargetResource;
+    /**
+     * Maximum duration of a durable execution.
+     *
+     * @default Duration.hours(1)
+     */
+    readonly executionTimeout?: Duration;
+    /**
+     * How long durable execution history is retained after completion.
+     *
+     * @default Duration.days(30)
+     */
+    readonly retentionPeriod?: Duration;
+}
+/**
+ * CDK construct that runs CloudFormation stack drift detection daily and publishes
+ * drifted stacks to SNS.
+ *
+ * Target stacks are selected by {@link TargetResource} when provided. When omitted,
+ * every stable stack in the account and region is inspected.
+ */
+export declare class CloudformationStackDriftDetector extends Construct {
+    /**
+     * SNS topic that receives drift notifications.
+     */
+    readonly notificationTopic: sns.ITopic;
+    /**
+     * Creates the durable detector Lambda, IAM policies, and daily EventBridge rule.
+     *
+     * @param scope - Parent construct.
+     * @param id - Construct id.
+     * @param props - Notification topic, optional tag filter, and durable execution settings.
+     */
+    constructor(scope: Construct, id: string, props: CloudformationStackDriftDetectorProps);
+    /**
+     * Returns the CloudFormation stack ARN pattern used for drift-detection IAM grants.
+     *
+     * @returns A single ARN that matches all stacks in the current account and region.
+     */
+    private getStackArns;
+    /**
+     * Builds the EventBridge target payload passed to the detector Lambda.
+     *
+     * @param targetResource - Optional tag filter. When omitted, an empty payload selects all stacks.
+     * @returns Tag key and values for the Lambda event, or an empty object.
+     */
+    private getEventInput;
+}

package/lib/index.js

@@ -0,0 +1,151 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CloudformationStackDriftDetector = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const aws_cdk_lib_1 = require("aws-cdk-lib");
+const events = __importStar(require("aws-cdk-lib/aws-events"));
+const targets = __importStar(require("aws-cdk-lib/aws-events-targets"));
+const iam = __importStar(require("aws-cdk-lib/aws-iam"));
+const lambda = __importStar(require("aws-cdk-lib/aws-lambda"));
+const constructs_1 = require("constructs");
+const detector_function_1 = require("./funcs/detector-function");
+/**
+ * CDK construct that runs CloudFormation stack drift detection daily and publishes
+ * drifted stacks to SNS.
+ *
+ * Target stacks are selected by {@link TargetResource} when provided. When omitted,
+ * every stable stack in the account and region is inspected.
+ */
+class CloudformationStackDriftDetector extends constructs_1.Construct {
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "cloudformation-stack-drift-detector.CloudformationStackDriftDetector", version: "0.1.1" };
+    /**
+     * SNS topic that receives drift notifications.
+     */
+    notificationTopic;
+    /**
+     * Creates the durable detector Lambda, IAM policies, and daily EventBridge rule.
+     *
+     * @param scope - Parent construct.
+     * @param id - Construct id.
+     * @param props - Notification topic, optional tag filter, and durable execution settings.
+     */
+    constructor(scope, id, props) {
+        super(scope, id);
+        this.notificationTopic = props.notificationTopic;
+        const durableFunction = new detector_function_1.DetectorFunction(this, 'Function', {
+            environment: {
+                NOTIFICATION_TOPIC_ARN: this.notificationTopic.topicArn,
+            },
+            durableConfig: {
+                executionTimeout: props.executionTimeout ?? aws_cdk_lib_1.Duration.hours(1),
+                retentionPeriod: props.retentionPeriod ?? aws_cdk_lib_1.Duration.days(30),
+            },
+            timeout: aws_cdk_lib_1.Duration.minutes(15),
+        });
+        durableFunction.role?.addManagedPolicy(iam.ManagedPolicy.fromAwsManagedPolicyName('service-role/AWSLambdaBasicDurableExecutionRolePolicy'));
+        durableFunction.addToRolePolicy(new iam.PolicyStatement({
+            actions: [
+                'cloudformation:DetectStackDrift',
+                'cloudformation:DescribeStackResourceDrifts',
+            ],
+            resources: this.getStackArns(),
+        }));
+        durableFunction.addToRolePolicy(new iam.PolicyStatement({
+            actions: [
+                'cloudformation:DescribeStackDriftDetectionStatus',
+                'cloudformation:ListStacks',
+            ],
+            resources: ['*'],
+        }));
+        durableFunction.addToRolePolicy(new iam.PolicyStatement({
+            actions: [
+                'tag:GetResources',
+            ],
+            resources: ['*'],
+        }));
+        this.notificationTopic.grantPublish(durableFunction);
+        const alias = new lambda.Alias(this, 'Live', {
+            aliasName: 'live',
+            version: durableFunction.currentVersion,
+        });
+        new events.Rule(this, 'Schedule', {
+            schedule: events.Schedule.rate(aws_cdk_lib_1.Duration.days(1)),
+            targets: [
+                new targets.LambdaFunction(alias, {
+                    event: events.RuleTargetInput.fromObject(this.getEventInput(props.targetResource)),
+                }),
+            ],
+        });
+    }
+    /**
+     * Returns the CloudFormation stack ARN pattern used for drift-detection IAM grants.
+     *
+     * @returns A single ARN that matches all stacks in the current account and region.
+     */
+    getStackArns() {
+        const stack = aws_cdk_lib_1.Stack.of(this);
+        return [
+            stack.formatArn({
+                service: 'cloudformation',
+                resource: 'stack',
+                resourceName: '*/*',
+                arnFormat: aws_cdk_lib_1.ArnFormat.SLASH_RESOURCE_NAME,
+            }),
+        ];
+    }
+    /**
+     * Builds the EventBridge target payload passed to the detector Lambda.
+     *
+     * @param targetResource - Optional tag filter. When omitted, an empty payload selects all stacks.
+     * @returns Tag key and values for the Lambda event, or an empty object.
+     */
+    getEventInput(targetResource) {
+        if (!targetResource) {
+            return {};
+        }
+        if (targetResource.tagValues && targetResource.tagValues.length > 0) {
+            return {
+                tagKey: targetResource.tagKey,
+                tagValues: targetResource.tagValues,
+            };
+        }
+        return {
+            tagKey: targetResource.tagKey,
+        };
+    }
+}
+exports.CloudformationStackDriftDetector = CloudformationStackDriftDetector;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,6CAAyD;AACzD,+DAAiD;AACjD,wEAA0D;AAC1D,yDAA2C;AAC3C,+DAAiD;AAEjD,2CAAuC;AACvC,iEAA6D;AA4C7D;;;;;;GAMG;AACH,MAAa,gCAAiC,SAAQ,sBAAS;;IAC7D;;OAEG;IACM,iBAAiB,CAAa;IAEvC;;;;;;OAMG;IACH,YAAY,KAAgB,EAAE,EAAU,EAAE,KAA4C;QACpF,KAAK,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;QAEjB,IAAI,CAAC,iBAAiB,GAAG,KAAK,CAAC,iBAAiB,CAAC;QAEjD,MAAM,eAAe,GAAG,IAAI,oCAAgB,CAAC,IAAI,EAAE,UAAU,EAAE;YAC7D,WAAW,EAAE;gBACX,sBAAsB,EAAE,IAAI,CAAC,iBAAiB,CAAC,QAAQ;aACxD;YACD,aAAa,EAAE;gBACb,gBAAgB,EAAE,KAAK,CAAC,gBAAgB,IAAI,sBAAQ,CAAC,KAAK,CAAC,CAAC,CAAC;gBAC7D,eAAe,EAAE,KAAK,CAAC,eAAe,IAAI,sBAAQ,CAAC,IAAI,CAAC,EAAE,CAAC;aAC5D;YACD,OAAO,EAAE,sBAAQ,CAAC,OAAO,CAAC,EAAE,CAAC;SAC9B,CAAC,CAAC;QAEH,eAAe,CAAC,IAAI,EAAE,gBAAgB,CACpC,GAAG,CAAC,aAAa,CAAC,wBAAwB,CAAC,uDAAuD,CAAC,CACpG,CAAC;QAEF,eAAe,CAAC,eAAe,CAAC,IAAI,GAAG,CAAC,eAAe,CAAC;YACtD,OAAO,EAAE;gBACP,iCAAiC;gBACjC,4CAA4C;aAC7C;YACD,SAAS,EAAE,IAAI,CAAC,YAAY,EAAE;SAC/B,CAAC,CAAC,CAAC;QAEJ,eAAe,CAAC,eAAe,CAAC,IAAI,GAAG,CAAC,eAAe,CAAC;YACtD,OAAO,EAAE;gBACP,kDAAkD;gBAClD,2BAA2B;aAC5B;YACD,SAAS,EAAE,CAAC,GAAG,CAAC;SACjB,CAAC,CAAC,CAAC;QAEJ,eAAe,CAAC,eAAe,CAAC,IAAI,GAAG,CAAC,eAAe,CAAC;YACtD,OAAO,EAAE;gBACP,kBAAkB;aACnB;YACD,SAAS,EAAE,CAAC,GAAG,CAAC;SACjB,CAAC,CAAC,CAAC;QAEJ,IAAI,CAAC,iBAAiB,CAAC,YAAY,CAAC,eAAe,CAAC,CAAC;QAErD,MAAM,KAAK,GAAG,IAAI,MAAM,CAAC,KAAK,CAAC,IAAI,EAAE,MAAM,EAAE;YAC3C,SAAS,EAAE,MAAM;YACjB,OAAO,EAAE,eAAe,CAAC,cAAc;SACxC,CAAC,CAAC;QAEH,IAAI,MAAM,CAAC,IAAI,CAAC,IAAI,EAAE,UAAU,EAAE;YAChC,QAAQ,EAAE,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC,sBAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;YAChD,OAAO,EAAE;gBACP,IAAI,OAAO,CAAC,cAAc,CAAC,KAAK,EAAE;oBAChC,KAAK,EAAE,MAAM,CAAC,eAAe,CAAC,UAAU,CAAC,IAAI,CAAC,aAAa,CAAC,KAAK,CAAC,cAAc,CAAC,CAAC;iBACnF,CAAC;aACH;SACF,CAAC,CAAC;IACL,CAAC;IAED;;;;OAIG;IACK,YAAY;QAClB,MAAM,KAAK,GAAG,mBAAK,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC;QAC7B,OAAO;YACL,KAAK,CAAC,SAAS,CAAC;gBACd,OAAO,EAAE,gBAAgB;gBACzB,QAAQ,EAAE,OAAO;gBACjB,YAAY,EAAE,KAAK;gBACnB,SAAS,EAAE,uBAAS,CAAC,mBAAmB;aACzC,CAAC;SACH,CAAC;IACJ,CAAC;IAED;;;;;OAKG;IACK,aAAa,CAAC,cAA+B;QACnD,IAAI,CAAC,cAAc,EAAE,CAAC;YACpB,OAAO,EAAE,CAAC;QACZ,CAAC;QACD,IAAI,cAAc,CAAC,SAAS,IAAI,cAAc,CAAC,SAAS,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YACpE,OAAO;gBACL,MAAM,EAAE,cAAc,CAAC,MAAM;gBAC7B,SAAS,EAAE,cAAc,CAAC,SAAS;aACpC,CAAC;QACJ,CAAC;QACD,OAAO;YACL,MAAM,EAAE,cAAc,CAAC,MAAM;SAC9B,CAAC;IACJ,CAAC;;AA7GH,4EA8GC","sourcesContent":["import { ArnFormat, Duration, Stack } from 'aws-cdk-lib';\nimport * as events from 'aws-cdk-lib/aws-events';\nimport * as targets from 'aws-cdk-lib/aws-events-targets';\nimport * as iam from 'aws-cdk-lib/aws-iam';\nimport * as lambda from 'aws-cdk-lib/aws-lambda';\nimport * as sns from 'aws-cdk-lib/aws-sns';\nimport { Construct } from 'constructs';\nimport { DetectorFunction } from './funcs/detector-function';\n\n/**\n * Tag filter used to select CloudFormation stacks for drift detection.\n * When `tagValues` is omitted, all stacks that have `tagKey` are selected.\n */\nexport interface TargetResource {\n  /**\n   * Tag key used for stack discovery.\n   */\n  readonly tagKey: string;\n  /**\n   * Tag values to match. If omitted, any value for {@link TargetResource.tagKey} is accepted.\n   */\n  readonly tagValues?: string[];\n}\n\n/**\n * Properties for {@link CloudformationStackDriftDetector}.\n */\nexport interface CloudformationStackDriftDetectorProps {\n  /**\n   * SNS topic used to notify when a stack has drifted.\n   */\n  readonly notificationTopic: sns.ITopic;\n  /**\n   * Tag filter used to select target stacks.\n   * If omitted, all stacks in the account and region are inspected.\n   */\n  readonly targetResource?: TargetResource;\n  /**\n   * Maximum duration of a durable execution.\n   *\n   * @default Duration.hours(1)\n   */\n  readonly executionTimeout?: Duration;\n  /**\n   * How long durable execution history is retained after completion.\n   *\n   * @default Duration.days(30)\n   */\n  readonly retentionPeriod?: Duration;\n}\n\n/**\n * CDK construct that runs CloudFormation stack drift detection daily and publishes\n * drifted stacks to SNS.\n *\n * Target stacks are selected by {@link TargetResource} when provided. When omitted,\n * every stable stack in the account and region is inspected.\n */\nexport class CloudformationStackDriftDetector extends Construct {\n  /**\n   * SNS topic that receives drift notifications.\n   */\n  readonly notificationTopic: sns.ITopic;\n\n  /**\n   * Creates the durable detector Lambda, IAM policies, and daily EventBridge rule.\n   *\n   * @param scope - Parent construct.\n   * @param id - Construct id.\n   * @param props - Notification topic, optional tag filter, and durable execution settings.\n   */\n  constructor(scope: Construct, id: string, props: CloudformationStackDriftDetectorProps) {\n    super(scope, id);\n\n    this.notificationTopic = props.notificationTopic;\n\n    const durableFunction = new DetectorFunction(this, 'Function', {\n      environment: {\n        NOTIFICATION_TOPIC_ARN: this.notificationTopic.topicArn,\n      },\n      durableConfig: {\n        executionTimeout: props.executionTimeout ?? Duration.hours(1),\n        retentionPeriod: props.retentionPeriod ?? Duration.days(30),\n      },\n      timeout: Duration.minutes(15),\n    });\n\n    durableFunction.role?.addManagedPolicy(\n      iam.ManagedPolicy.fromAwsManagedPolicyName('service-role/AWSLambdaBasicDurableExecutionRolePolicy'),\n    );\n\n    durableFunction.addToRolePolicy(new iam.PolicyStatement({\n      actions: [\n        'cloudformation:DetectStackDrift',\n        'cloudformation:DescribeStackResourceDrifts',\n      ],\n      resources: this.getStackArns(),\n    }));\n\n    durableFunction.addToRolePolicy(new iam.PolicyStatement({\n      actions: [\n        'cloudformation:DescribeStackDriftDetectionStatus',\n        'cloudformation:ListStacks',\n      ],\n      resources: ['*'],\n    }));\n\n    durableFunction.addToRolePolicy(new iam.PolicyStatement({\n      actions: [\n        'tag:GetResources',\n      ],\n      resources: ['*'],\n    }));\n\n    this.notificationTopic.grantPublish(durableFunction);\n\n    const alias = new lambda.Alias(this, 'Live', {\n      aliasName: 'live',\n      version: durableFunction.currentVersion,\n    });\n\n    new events.Rule(this, 'Schedule', {\n      schedule: events.Schedule.rate(Duration.days(1)),\n      targets: [\n        new targets.LambdaFunction(alias, {\n          event: events.RuleTargetInput.fromObject(this.getEventInput(props.targetResource)),\n        }),\n      ],\n    });\n  }\n\n  /**\n   * Returns the CloudFormation stack ARN pattern used for drift-detection IAM grants.\n   *\n   * @returns A single ARN that matches all stacks in the current account and region.\n   */\n  private getStackArns(): string[] {\n    const stack = Stack.of(this);\n    return [\n      stack.formatArn({\n        service: 'cloudformation',\n        resource: 'stack',\n        resourceName: '*/*',\n        arnFormat: ArnFormat.SLASH_RESOURCE_NAME,\n      }),\n    ];\n  }\n\n  /**\n   * Builds the EventBridge target payload passed to the detector Lambda.\n   *\n   * @param targetResource - Optional tag filter. When omitted, an empty payload selects all stacks.\n   * @returns Tag key and values for the Lambda event, or an empty object.\n   */\n  private getEventInput(targetResource?: TargetResource): { tagKey?: string; tagValues?: string[] } {\n    if (!targetResource) {\n      return {};\n    }\n    if (targetResource.tagValues && targetResource.tagValues.length > 0) {\n      return {\n        tagKey: targetResource.tagKey,\n        tagValues: targetResource.tagValues,\n      };\n    }\n    return {\n      tagKey: targetResource.tagKey,\n    };\n  }\n}\n"]}