rds-database-auto-start-preventer 0.4.4 → 0.5.1

package/lib/funcs/auto-start-prevent.lambda.d.ts

@@ -1,5 +1,5 @@
 import { DurableContext } from '@aws/durable-execution-sdk-js';
-import { NoOpResult, StoppedResult } from './auto-start-prevent.predicates';
+import { NoOpResult, StoppedResult } from './core/auto-start-prevent.predicates';
 /**
  * Durable Lambda handler for RDS auto-start prevention.
  *

package/lib/funcs/auto-start-prevent.lambda.js

@@ -6,7 +6,7 @@ const client_rds_1 = require("@aws-sdk/client-rds");
 const web_api_1 = require("@slack/web-api");
 const aws_lambda_secret_fetcher_1 = require("aws-lambda-secret-fetcher");
 const strict_env_resolver_1 = require("strict-env-resolver");
-const auto_start_prevent_predicates_1 = require("./auto-start-prevent.predicates");
+const auto_start_prevent_predicates_1 = require("./core/auto-start-prevent.predicates");
 /** Shared RDS client for describe and stop API calls. */
 const rdsClient = new client_rds_1.RDSClient({});
 /**
@@ -169,4 +169,4 @@ const processAutoStartPrevent = async (input, context) => {
 };
 exports.processAutoStartPrevent = processAutoStartPrevent;
 exports.handler = (0, durable_execution_sdk_js_1.withDurableExecution)(exports.processAutoStartPrevent);
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"auto-start-prevent.lambda.js","sourceRoot":"","sources":["../../src/funcs/auto-start-prevent.lambda.ts"],"names":[],"mappings":"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","sourcesContent":["import { withDurableExecution, DurableContext } from '@aws/durable-execution-sdk-js';\nimport {\n  RDSClient,\n  DescribeDBInstancesCommand,\n  DescribeDBClustersCommand,\n  StopDBInstanceCommand,\n  StopDBClusterCommand,\n} from '@aws-sdk/client-rds';\nimport { WebClient } from '@slack/web-api';\nimport { secretFetcher } from 'aws-lambda-secret-fetcher';\nimport { StrictEnvResolver, StrictEnvType } from 'strict-env-resolver';\nimport {\n  buildSlackStopNotification,\n  buildStoppedResult,\n  decideAfterTagMatch,\n  isDbClusterAutoStart,\n  isDbInstanceAutoStart,\n  isSlackSecret,\n  matchTag,\n  normalizeInput,\n  NoOpResult,\n  parseRdsSourceArn,\n  WaitState,\n  SlackSecret,\n  StoppedResult,\n  Tag,\n  tagMismatchNoOp,\n  waitStrategyUntilStable,\n  waitStrategyUntilStopped,\n} from './auto-start-prevent.predicates';\n\n/** Shared RDS client for describe and stop API calls. */\nconst rdsClient = new RDSClient({});\n\n/**\n * Durable Lambda handler for RDS auto-start prevention.\n *\n * Workflow:\n * 1. Wait 1 minute, then wait on DescribeDB* until the resource leaves transitional statuses.\n * 2. Read tags from the describe response `TagList`; skip when {@link matchTag} returns false.\n * 3. If status is `available`, call StopDB* and wait until `stopped`.\n * 4. If already `stopped` without calling StopDB*, return {@link NoOpResult} (no Slack notification).\n * 5. When `SLACK_SECRET_NAME` is set, post to Slack only after StopDB* was invoked and the resource reached `stopped`. When it is unset, skip Slack.\n *\n * Tag matching uses RDS Describe APIs only; Resource Groups Tagging API is not used.\n *\n * @param input - `{ event, params }` from EventBridge InputTransformer (same shape required for direct Invoke).\n * @param context - Durable execution context for steps and waits.\n * @returns {@link StoppedResult} or {@link NoOpResult}.\n * @throws When the payload is invalid, the event is unsupported, a configured Slack secret is invalid, or stop did not reach `stopped`.\n */\nexport const processAutoStartPrevent = async (\n  input: unknown,\n  context: DurableContext,\n): Promise<StoppedResult | NoOpResult> => {\n  const { event, params } = normalizeInput(input);\n  const { detail, 'detail-type': detailType } = event;\n\n  const slackSecretName = StrictEnvResolver.resolve('SLACK_SECRET_NAME', StrictEnvType.String, {\n    trim: true,\n    default: '',\n  });\n  // Requires AWS Parameters and Secrets Extension (ParamsAndSecrets layer) and\n  // AWS_SESSION_TOKEN from the Lambda runtime (aws-lambda-secret-fetcher ^0.6+).\n  let slackSecret: SlackSecret | undefined;\n  if (slackSecretName.length > 0) {\n    const slackSecretValue = await context.step('fetch-slack-secret', async () => {\n      return secretFetcher.getSecretValue<SlackSecret>(slackSecretName);\n    });\n    if (!isSlackSecret(slackSecretValue)) {\n      throw new Error('Slack secret must be JSON with non-empty token and channel.');\n    }\n    slackSecret = slackSecretValue;\n  }\n\n  const isInstance = isDbInstanceAutoStart(detailType, detail);\n  const isCluster = isDbClusterAutoStart(detailType, detail);\n\n  if (!isInstance && !isCluster) {\n    throw new Error(\n      `Unsupported event: detail-type=${detailType}, SourceType=${detail.SourceType}, EventID=${detail.EventID}`,\n    );\n  }\n\n  // Initial delay before the first describe (allows RDS to report a stable status).\n  await context.wait({ minutes: 1 });\n\n  // Wait until the resource is no longer in a transitional status; capture status and TagList.\n  const firstDescribe = await context.waitForCondition<WaitState>(\n    async (_state, _ctx) => {\n      if (isInstance) {\n        const res = await rdsClient.send(\n          new DescribeDBInstancesCommand({\n            DBInstanceIdentifier: detail.SourceIdentifier,\n          }),\n        );\n        const db = res.DBInstances?.[0];\n        return {\n          status: db?.DBInstanceStatus ?? 'unknown',\n          identifier: db?.DBInstanceIdentifier ?? detail.SourceIdentifier,\n          tags: (db?.TagList ?? []) as Tag[],\n        };\n      }\n\n      const res = await rdsClient.send(\n        new DescribeDBClustersCommand({\n          DBClusterIdentifier: detail.SourceIdentifier,\n        }),\n      );\n      const cluster = res.DBClusters?.[0];\n      return {\n        status: cluster?.Status ?? 'unknown',\n        identifier: cluster?.DBClusterIdentifier ?? detail.SourceIdentifier,\n        tags: (cluster?.TagList ?? []) as Tag[],\n      };\n    },\n    {\n      initialState: {\n        status: 'starting',\n        identifier: detail.SourceIdentifier,\n      },\n      waitStrategy: waitStrategyUntilStable,\n    },\n  );\n\n  // Skip when TagList is missing or does not match tagKey / tagValues.\n  if (!matchTag(params, firstDescribe.tags)) {\n    return tagMismatchNoOp(firstDescribe.status);\n  }\n\n  let didStop = false;\n  let finalStatus = firstDescribe.status;\n\n  // When available, invoke StopDB* and wait until stopped.\n  const afterTagMatch = decideAfterTagMatch(firstDescribe.status);\n  if (afterTagMatch.kind === 'stop') {\n    if (isInstance) {\n      await context.step('stop-db-instance', async () => {\n        await rdsClient.send(\n          new StopDBInstanceCommand({\n            DBInstanceIdentifier: detail.SourceIdentifier,\n          }),\n        );\n      });\n    } else {\n      await context.step('stop-db-cluster', async () => {\n        await rdsClient.send(\n          new StopDBClusterCommand({\n            DBClusterIdentifier: detail.SourceIdentifier,\n          }),\n        );\n      });\n    }\n\n    const stopped = await context.waitForCondition<WaitState>(\n      async (_state, _ctx) => {\n        if (isInstance) {\n          const res = await rdsClient.send(\n            new DescribeDBInstancesCommand({\n              DBInstanceIdentifier: detail.SourceIdentifier,\n            }),\n          );\n          const db = res.DBInstances?.[0];\n          return {\n            status: db?.DBInstanceStatus ?? 'unknown',\n            identifier: db?.DBInstanceIdentifier ?? detail.SourceIdentifier,\n          };\n        }\n\n        const res = await rdsClient.send(\n          new DescribeDBClustersCommand({\n            DBClusterIdentifier: detail.SourceIdentifier,\n          }),\n        );\n        const cluster = res.DBClusters?.[0];\n        return {\n          status: cluster?.Status ?? 'unknown',\n          identifier: cluster?.DBClusterIdentifier ?? detail.SourceIdentifier,\n        };\n      },\n      {\n        initialState: {\n          status: firstDescribe.status,\n          identifier: firstDescribe.identifier,\n        },\n        waitStrategy: waitStrategyUntilStopped,\n      },\n    );\n\n    didStop = true;\n    finalStatus = stopped.status;\n  }\n\n  // Already stopped without calling StopDB* (e.g. stopped by another process) — no Slack notification.\n  if (!didStop) {\n    if (afterTagMatch.kind === 'no-op') {\n      return afterTagMatch.result;\n    }\n    if (afterTagMatch.kind === 'error') {\n      throw new Error(afterTagMatch.message);\n    }\n  }\n\n  // Fail when StopDB* was called but the resource did not reach stopped.\n  if (finalStatus !== 'stopped') {\n    throw new Error(`DB status is not stopped after processing: ${finalStatus}`);\n  }\n\n  const { region, account } = parseRdsSourceArn(detail.SourceArn);\n\n  if (slackSecret !== undefined) {\n    const channel = slackSecret.channel;\n    const client = new WebClient(slackSecret.token);\n    await context.step('post-slack-messages', async () => {\n      return client.chat.postMessage(\n        buildSlackStopNotification({\n          channel,\n          sourceType: detail.SourceType,\n          sourceIdentifier: detail.SourceIdentifier,\n          account,\n          region,\n        }),\n      );\n    });\n  }\n\n  return buildStoppedResult({\n    finalStatus,\n    account,\n    region,\n    identifier: detail.SourceIdentifier,\n  });\n};\n\nexport const handler = withDurableExecution(processAutoStartPrevent);\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"auto-start-prevent.lambda.js","sourceRoot":"","sources":["../../src/funcs/auto-start-prevent.lambda.ts"],"names":[],"mappings":"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","sourcesContent":["import { withDurableExecution, DurableContext } from '@aws/durable-execution-sdk-js';\nimport {\n  RDSClient,\n  DescribeDBInstancesCommand,\n  DescribeDBClustersCommand,\n  StopDBInstanceCommand,\n  StopDBClusterCommand,\n} from '@aws-sdk/client-rds';\nimport { WebClient } from '@slack/web-api';\nimport { secretFetcher } from 'aws-lambda-secret-fetcher';\nimport { StrictEnvResolver, StrictEnvType } from 'strict-env-resolver';\nimport {\n  buildSlackStopNotification,\n  buildStoppedResult,\n  decideAfterTagMatch,\n  isDbClusterAutoStart,\n  isDbInstanceAutoStart,\n  isSlackSecret,\n  matchTag,\n  normalizeInput,\n  NoOpResult,\n  parseRdsSourceArn,\n  WaitState,\n  SlackSecret,\n  StoppedResult,\n  Tag,\n  tagMismatchNoOp,\n  waitStrategyUntilStable,\n  waitStrategyUntilStopped,\n} from './core/auto-start-prevent.predicates';\n\n/** Shared RDS client for describe and stop API calls. */\nconst rdsClient = new RDSClient({});\n\n/**\n * Durable Lambda handler for RDS auto-start prevention.\n *\n * Workflow:\n * 1. Wait 1 minute, then wait on DescribeDB* until the resource leaves transitional statuses.\n * 2. Read tags from the describe response `TagList`; skip when {@link matchTag} returns false.\n * 3. If status is `available`, call StopDB* and wait until `stopped`.\n * 4. If already `stopped` without calling StopDB*, return {@link NoOpResult} (no Slack notification).\n * 5. When `SLACK_SECRET_NAME` is set, post to Slack only after StopDB* was invoked and the resource reached `stopped`. When it is unset, skip Slack.\n *\n * Tag matching uses RDS Describe APIs only; Resource Groups Tagging API is not used.\n *\n * @param input - `{ event, params }` from EventBridge InputTransformer (same shape required for direct Invoke).\n * @param context - Durable execution context for steps and waits.\n * @returns {@link StoppedResult} or {@link NoOpResult}.\n * @throws When the payload is invalid, the event is unsupported, a configured Slack secret is invalid, or stop did not reach `stopped`.\n */\nexport const processAutoStartPrevent = async (\n  input: unknown,\n  context: DurableContext,\n): Promise<StoppedResult | NoOpResult> => {\n  const { event, params } = normalizeInput(input);\n  const { detail, 'detail-type': detailType } = event;\n\n  const slackSecretName = StrictEnvResolver.resolve('SLACK_SECRET_NAME', StrictEnvType.String, {\n    trim: true,\n    default: '',\n  });\n  // Requires AWS Parameters and Secrets Extension (ParamsAndSecrets layer) and\n  // AWS_SESSION_TOKEN from the Lambda runtime (aws-lambda-secret-fetcher ^0.6+).\n  let slackSecret: SlackSecret | undefined;\n  if (slackSecretName.length > 0) {\n    const slackSecretValue = await context.step('fetch-slack-secret', async () => {\n      return secretFetcher.getSecretValue<SlackSecret>(slackSecretName);\n    });\n    if (!isSlackSecret(slackSecretValue)) {\n      throw new Error('Slack secret must be JSON with non-empty token and channel.');\n    }\n    slackSecret = slackSecretValue;\n  }\n\n  const isInstance = isDbInstanceAutoStart(detailType, detail);\n  const isCluster = isDbClusterAutoStart(detailType, detail);\n\n  if (!isInstance && !isCluster) {\n    throw new Error(\n      `Unsupported event: detail-type=${detailType}, SourceType=${detail.SourceType}, EventID=${detail.EventID}`,\n    );\n  }\n\n  // Initial delay before the first describe (allows RDS to report a stable status).\n  await context.wait({ minutes: 1 });\n\n  // Wait until the resource is no longer in a transitional status; capture status and TagList.\n  const firstDescribe = await context.waitForCondition<WaitState>(\n    async (_state, _ctx) => {\n      if (isInstance) {\n        const res = await rdsClient.send(\n          new DescribeDBInstancesCommand({\n            DBInstanceIdentifier: detail.SourceIdentifier,\n          }),\n        );\n        const db = res.DBInstances?.[0];\n        return {\n          status: db?.DBInstanceStatus ?? 'unknown',\n          identifier: db?.DBInstanceIdentifier ?? detail.SourceIdentifier,\n          tags: (db?.TagList ?? []) as Tag[],\n        };\n      }\n\n      const res = await rdsClient.send(\n        new DescribeDBClustersCommand({\n          DBClusterIdentifier: detail.SourceIdentifier,\n        }),\n      );\n      const cluster = res.DBClusters?.[0];\n      return {\n        status: cluster?.Status ?? 'unknown',\n        identifier: cluster?.DBClusterIdentifier ?? detail.SourceIdentifier,\n        tags: (cluster?.TagList ?? []) as Tag[],\n      };\n    },\n    {\n      initialState: {\n        status: 'starting',\n        identifier: detail.SourceIdentifier,\n      },\n      waitStrategy: waitStrategyUntilStable,\n    },\n  );\n\n  // Skip when TagList is missing or does not match tagKey / tagValues.\n  if (!matchTag(params, firstDescribe.tags)) {\n    return tagMismatchNoOp(firstDescribe.status);\n  }\n\n  let didStop = false;\n  let finalStatus = firstDescribe.status;\n\n  // When available, invoke StopDB* and wait until stopped.\n  const afterTagMatch = decideAfterTagMatch(firstDescribe.status);\n  if (afterTagMatch.kind === 'stop') {\n    if (isInstance) {\n      await context.step('stop-db-instance', async () => {\n        await rdsClient.send(\n          new StopDBInstanceCommand({\n            DBInstanceIdentifier: detail.SourceIdentifier,\n          }),\n        );\n      });\n    } else {\n      await context.step('stop-db-cluster', async () => {\n        await rdsClient.send(\n          new StopDBClusterCommand({\n            DBClusterIdentifier: detail.SourceIdentifier,\n          }),\n        );\n      });\n    }\n\n    const stopped = await context.waitForCondition<WaitState>(\n      async (_state, _ctx) => {\n        if (isInstance) {\n          const res = await rdsClient.send(\n            new DescribeDBInstancesCommand({\n              DBInstanceIdentifier: detail.SourceIdentifier,\n            }),\n          );\n          const db = res.DBInstances?.[0];\n          return {\n            status: db?.DBInstanceStatus ?? 'unknown',\n            identifier: db?.DBInstanceIdentifier ?? detail.SourceIdentifier,\n          };\n        }\n\n        const res = await rdsClient.send(\n          new DescribeDBClustersCommand({\n            DBClusterIdentifier: detail.SourceIdentifier,\n          }),\n        );\n        const cluster = res.DBClusters?.[0];\n        return {\n          status: cluster?.Status ?? 'unknown',\n          identifier: cluster?.DBClusterIdentifier ?? detail.SourceIdentifier,\n        };\n      },\n      {\n        initialState: {\n          status: firstDescribe.status,\n          identifier: firstDescribe.identifier,\n        },\n        waitStrategy: waitStrategyUntilStopped,\n      },\n    );\n\n    didStop = true;\n    finalStatus = stopped.status;\n  }\n\n  // Already stopped without calling StopDB* (e.g. stopped by another process) — no Slack notification.\n  if (!didStop) {\n    if (afterTagMatch.kind === 'no-op') {\n      return afterTagMatch.result;\n    }\n    if (afterTagMatch.kind === 'error') {\n      throw new Error(afterTagMatch.message);\n    }\n  }\n\n  // Fail when StopDB* was called but the resource did not reach stopped.\n  if (finalStatus !== 'stopped') {\n    throw new Error(`DB status is not stopped after processing: ${finalStatus}`);\n  }\n\n  const { region, account } = parseRdsSourceArn(detail.SourceArn);\n\n  if (slackSecret !== undefined) {\n    const channel = slackSecret.channel;\n    const client = new WebClient(slackSecret.token);\n    await context.step('post-slack-messages', async () => {\n      return client.chat.postMessage(\n        buildSlackStopNotification({\n          channel,\n          sourceType: detail.SourceType,\n          sourceIdentifier: detail.SourceIdentifier,\n          account,\n          region,\n        }),\n      );\n    });\n  }\n\n  return buildStoppedResult({\n    finalStatus,\n    account,\n    region,\n    identifier: detail.SourceIdentifier,\n  });\n};\n\nexport const handler = withDurableExecution(processAutoStartPrevent);\n"]}

package/lib/funcs/core/auto-start-prevent.predicates.js

@@ -0,0 +1,255 @@
+"use strict";
+/**
+ * Pure helpers for the RDS auto-start prevent Lambda.
+ * No AWS SDK, Durable context, env, or clock dependencies.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildStoppedResult = exports.buildSlackStopNotification = exports.parseRdsSourceArn = exports.tagMismatchNoOp = exports.decideAfterTagMatch = exports.waitStrategyUntilStopped = exports.waitStrategyUntilStable = exports.isDbClusterAutoStart = exports.isDbInstanceAutoStart = exports.matchTag = exports.normalizeInput = exports.isAutoStartPreventInput = exports.isSlackSecret = exports.isTransitionalStatus = exports.TRANSITIONAL_STATUSES = exports.WAIT_INTERVAL_MINUTES = void 0;
+/** Minutes between describe calls while a status is transitional or stopping. */
+exports.WAIT_INTERVAL_MINUTES = 5;
+/**
+ * RDS statuses that indicate an in-progress transition.
+ * The handler waits {@link WAIT_INTERVAL_MINUTES} minutes while the resource remains in one of these states.
+ */
+exports.TRANSITIONAL_STATUSES = new Set([
+    'starting',
+    'configuring-enhanced-monitoring',
+    'backing-up',
+    'modifying',
+    'stopping',
+]);
+/**
+ * Returns true when the status is transitional and waiting should continue.
+ *
+ * @param status - Current DB instance or cluster status.
+ * @returns Whether the status is transitional.
+ */
+const isTransitionalStatus = (status) => exports.TRANSITIONAL_STATUSES.has(status);
+exports.isTransitionalStatus = isTransitionalStatus;
+/**
+ * Type guard for Slack credentials returned by `secretFetcher.getSecretValue`.
+ *
+ * aws-lambda-secret-fetcher ^0.7 parses SecretString with quiet-json-parser and
+ * falls back to the raw string on invalid JSON, so callers must validate shape.
+ *
+ * @param value - Value returned from the secret fetcher.
+ * @returns Whether value is a SlackSecret with non-empty token and channel.
+ */
+const isSlackSecret = (value) => {
+    if (typeof value !== 'object' || value == null) {
+        return false;
+    }
+    if (!('token' in value) || !('channel' in value)) {
+        return false;
+    }
+    return typeof value.token === 'string' &&
+        value.token.length > 0 &&
+        typeof value.channel === 'string' &&
+        value.channel.length > 0;
+};
+exports.isSlackSecret = isSlackSecret;
+/**
+ * Type guard: input is `{ event, params }` as produced by the EventBridge target.
+ *
+ * @param input - Raw Lambda invocation payload.
+ * @returns Whether input has non-null event and params.
+ */
+const isAutoStartPreventInput = (input) => {
+    if (typeof input !== 'object' || input == null) {
+        return false;
+    }
+    if (!('event' in input) || !('params' in input)) {
+        return false;
+    }
+    return input.event != null && input.params != null;
+};
+exports.isAutoStartPreventInput = isAutoStartPreventInput;
+/**
+ * Normalizes invocation input to {@link AutoStartPreventInput}.
+ *
+ * @param input - `{ event, params }` from EventBridge InputTransformer (or the same shape on direct Invoke).
+ * @returns Event plus tag filter parameters.
+ * @throws When the payload is not `{ event, params }`.
+ */
+const normalizeInput = (input) => {
+    if ((0, exports.isAutoStartPreventInput)(input)) {
+        return input;
+    }
+    throw new Error('Invalid input: expected { event, params }.');
+};
+exports.normalizeInput = normalizeInput;
+/**
+ * Returns true if the resource has a tag with the given key and a value in the allowed list.
+ *
+ * @param params - Tag key and allowed values.
+ * @param tags - Resource tag list (e.g. from DescribeDBInstances / DescribeDBClusters).
+ * @returns Whether the tag matches.
+ */
+const matchTag = (params, tags) => {
+    if (!tags || tags.length === 0) {
+        return false;
+    }
+    const value = tags.find(t => t.Key === params.tagKey)?.Value;
+    if (!value) {
+        return false;
+    }
+    return params.tagValues.includes(value);
+};
+exports.matchTag = matchTag;
+/**
+ * Whether the EventBridge detail identifies a supported DB instance auto-start event.
+ *
+ * @param detailType - EventBridge detail-type.
+ * @param detail - RDS event detail.
+ * @returns True for RDS-EVENT-0154 on a DB instance.
+ */
+const isDbInstanceAutoStart = (detailType, detail) => detailType === 'RDS DB Instance Event' &&
+    detail.SourceType === 'DB_INSTANCE' &&
+    detail.EventID === 'RDS-EVENT-0154';
+exports.isDbInstanceAutoStart = isDbInstanceAutoStart;
+/**
+ * Whether the EventBridge detail identifies a supported DB cluster auto-start event.
+ *
+ * @param detailType - EventBridge detail-type.
+ * @param detail - RDS event detail.
+ * @returns True for RDS-EVENT-0153 on a cluster.
+ */
+const isDbClusterAutoStart = (detailType, detail) => detailType === 'RDS DB Cluster Event' &&
+    detail.SourceType === 'CLUSTER' &&
+    detail.EventID === 'RDS-EVENT-0153';
+exports.isDbClusterAutoStart = isDbClusterAutoStart;
+/**
+ * Wait strategy while describing until the resource leaves transitional statuses.
+ *
+ * @param state - Latest wait state.
+ * @returns Continue at {@link WAIT_INTERVAL_MINUTES} while transitional; otherwise stop.
+ */
+const waitStrategyUntilStable = (state) => {
+    if ((0, exports.isTransitionalStatus)(state.status)) {
+        return { shouldContinue: true, delay: { minutes: exports.WAIT_INTERVAL_MINUTES } };
+    }
+    return { shouldContinue: false };
+};
+exports.waitStrategyUntilStable = waitStrategyUntilStable;
+/**
+ * Wait strategy after StopDB* until the resource reaches `stopped`.
+ *
+ * @param state - Latest wait state.
+ * @returns Stop when `stopped`; continue at {@link WAIT_INTERVAL_MINUTES} while transitional.
+ * @throws When the status is neither stopped nor transitional.
+ */
+const waitStrategyUntilStopped = (state) => {
+    if (state.status === 'stopped') {
+        return { shouldContinue: false };
+    }
+    if ((0, exports.isTransitionalStatus)(state.status)) {
+        return { shouldContinue: true, delay: { minutes: exports.WAIT_INTERVAL_MINUTES } };
+    }
+    throw new Error(`Unexpected status while waiting for stop: ${state.status}`);
+};
+exports.waitStrategyUntilStopped = waitStrategyUntilStopped;
+/**
+ * Decides the next action when tags matched and StopDB* has not been called yet.
+ *
+ * @param status - Status from the first describe after leaving transitional states.
+ * @returns Stop when `available`; no-op when already `stopped`; otherwise error.
+ */
+const decideAfterTagMatch = (status) => {
+    if (status === 'available') {
+        return { kind: 'stop' };
+    }
+    if (status === 'stopped') {
+        return {
+            kind: 'no-op',
+            result: {
+                action: 'no-op',
+                reason: 'already stopped',
+                status,
+            },
+        };
+    }
+    return {
+        kind: 'error',
+        message: `DB status is not stopped after processing: ${status}`,
+    };
+};
+exports.decideAfterTagMatch = decideAfterTagMatch;
+/**
+ * Builds the no-op result used when tags do not match.
+ *
+ * @param status - Current resource status.
+ * @returns No-op result with tag mismatch reason.
+ */
+const tagMismatchNoOp = (status) => ({
+    action: 'no-op',
+    reason: 'tag not matched or not found',
+    status,
+});
+exports.tagMismatchNoOp = tagMismatchNoOp;
+/**
+ * Parses region and account from an RDS resource ARN (`arn:aws:rds:region:account:...`).
+ *
+ * @param sourceArn - SourceArn from the RDS event detail.
+ * @returns Region and account id segments.
+ */
+const parseRdsSourceArn = (sourceArn) => {
+    const parts = sourceArn.split(':');
+    return {
+        region: parts[3] ?? '',
+        account: parts[4] ?? '',
+    };
+};
+exports.parseRdsSourceArn = parseRdsSourceArn;
+/**
+ * Builds the Slack `chat.postMessage` payload after a successful stop.
+ *
+ * @param args - Channel and resource identity fields.
+ * @returns Arguments suitable for `WebClient.chat.postMessage`.
+ */
+const buildSlackStopNotification = (args) => ({
+    channel: args.channel,
+    attachments: [
+        {
+            color: '#36a64f',
+            pretext: `😴 Successfully stopped the automatically running RDS ${args.sourceType} ${args.sourceIdentifier}.`,
+            fields: [
+                {
+                    title: 'Account',
+                    value: args.account,
+                    short: true,
+                },
+                {
+                    title: 'Region',
+                    value: args.region,
+                    short: true,
+                },
+                {
+                    title: 'Type',
+                    value: args.sourceType,
+                    short: true,
+                },
+                {
+                    title: 'Identifier',
+                    value: args.sourceIdentifier,
+                    short: true,
+                },
+            ],
+        },
+    ],
+});
+exports.buildSlackStopNotification = buildSlackStopNotification;
+/**
+ * Builds the success result after StopDB* reached `stopped`.
+ *
+ * @param args - Final status and identity fields.
+ * @returns StoppedResult for the handler return value.
+ */
+const buildStoppedResult = (args) => ({
+    action: 'stopped',
+    finalStatus: args.finalStatus,
+    account: args.account,
+    region: args.region,
+    identifier: args.identifier,
+});
+exports.buildStoppedResult = buildStoppedResult;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"auto-start-prevent.predicates.js","sourceRoot":"","sources":["../../../src/funcs/core/auto-start-prevent.predicates.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Pure helpers for the RDS auto-start prevent Lambda.\n * No AWS SDK, Durable context, env, or clock dependencies.\n */\n\n/**\n * Detail payload of an RDS auto-start event from EventBridge.\n */\nexport interface RdsAutoStartDetail {\n  /** Event ID: RDS-EVENT-0154 (DB instance) or RDS-EVENT-0153 (DB cluster). */\n  EventID: 'RDS-EVENT-0154' | 'RDS-EVENT-0153';\n  /** Resource type that emitted the event. */\n  SourceType: 'DB_INSTANCE' | 'CLUSTER';\n  /** ARN of the DB instance or cluster. */\n  SourceArn: string;\n  /** DB instance or cluster identifier from the event. */\n  SourceIdentifier: string;\n}\n\n/**\n * RDS auto-start event as received from EventBridge.\n */\nexport interface RdsAutoStartEvent {\n  'detail-type': 'RDS DB Instance Event' | 'RDS DB Cluster Event';\n  'source': 'aws.rds';\n  'detail': RdsAutoStartDetail;\n}\n\n/**\n * Tag-based filter parameters for the handler.\n */\nexport interface AutoStartParams {\n  /** Tag key to match on the resource. */\n  tagKey: string;\n  /** Allowed tag values; the resource is processed only when its tag value is in this list. */\n  tagValues: string[];\n}\n\n/**\n * Slack credentials stored in Secrets Manager.\n */\nexport interface SlackSecret {\n  /** Slack bot or user OAuth token. */\n  token: string;\n  /** Channel ID or name to post notifications to. */\n  channel: string;\n}\n\n/**\n * Normalized handler input: EventBridge event and tag filter parameters.\n */\nexport interface AutoStartPreventInput {\n  event: RdsAutoStartEvent;\n  params: AutoStartParams;\n}\n\n/**\n * Handler result when no stop action was taken.\n */\nexport interface NoOpResult {\n  action: 'no-op';\n  reason: 'tag not matched or not found' | 'already stopped';\n  status: string;\n}\n\n/**\n * Handler result when this invocation called StopDB* and the resource reached `stopped`.\n */\nexport interface StoppedResult {\n  action: 'stopped';\n  finalStatus: string;\n  account: string;\n  region: string;\n  identifier: string;\n}\n\n/**\n * AWS-style tag (Key/Value).\n */\nexport interface Tag {\n  Key?: string;\n  Value?: string;\n}\n\n/**\n * State snapshot while waiting on RDS describe APIs.\n */\nexport interface WaitState {\n  /** Current DB instance or cluster status. */\n  status: string;\n  /** DB instance or cluster identifier. */\n  identifier: string;\n  /** Tags from the describe response; present on the first wait check only. */\n  tags?: Tag[];\n}\n\n/** Continue waiting with a delay. */\nexport interface ContinueWait {\n  shouldContinue: true;\n  delay: { minutes: number };\n}\n\n/** Stop waiting. */\nexport interface StopWait {\n  shouldContinue: false;\n}\n\n/** Result of a durable waitStrategy. */\nexport type WaitStrategyResult = ContinueWait | StopWait;\n\n/** Minutes between describe calls while a status is transitional or stopping. */\nexport const WAIT_INTERVAL_MINUTES = 5;\n\n/**\n * RDS statuses that indicate an in-progress transition.\n * The handler waits {@link WAIT_INTERVAL_MINUTES} minutes while the resource remains in one of these states.\n */\nexport const TRANSITIONAL_STATUSES = new Set([\n  'starting',\n  'configuring-enhanced-monitoring',\n  'backing-up',\n  'modifying',\n  'stopping',\n]);\n\n/**\n * Returns true when the status is transitional and waiting should continue.\n *\n * @param status - Current DB instance or cluster status.\n * @returns Whether the status is transitional.\n */\nexport const isTransitionalStatus = (status: string): boolean =>\n  TRANSITIONAL_STATUSES.has(status);\n\n/**\n * Type guard for Slack credentials returned by `secretFetcher.getSecretValue`.\n *\n * aws-lambda-secret-fetcher ^0.7 parses SecretString with quiet-json-parser and\n * falls back to the raw string on invalid JSON, so callers must validate shape.\n *\n * @param value - Value returned from the secret fetcher.\n * @returns Whether value is a SlackSecret with non-empty token and channel.\n */\nexport const isSlackSecret = (value: unknown): value is SlackSecret => {\n  if (typeof value !== 'object' || value == null) {\n    return false;\n  }\n  if (!('token' in value) || !('channel' in value)) {\n    return false;\n  }\n  return typeof value.token === 'string' &&\n    value.token.length > 0 &&\n    typeof value.channel === 'string' &&\n    value.channel.length > 0;\n};\n\n/**\n * Type guard: input is `{ event, params }` as produced by the EventBridge target.\n *\n * @param input - Raw Lambda invocation payload.\n * @returns Whether input has non-null event and params.\n */\nexport const isAutoStartPreventInput = (input: unknown): input is AutoStartPreventInput => {\n  if (typeof input !== 'object' || input == null) {\n    return false;\n  }\n  if (!('event' in input) || !('params' in input)) {\n    return false;\n  }\n  return input.event != null && input.params != null;\n};\n\n/**\n * Normalizes invocation input to {@link AutoStartPreventInput}.\n *\n * @param input - `{ event, params }` from EventBridge InputTransformer (or the same shape on direct Invoke).\n * @returns Event plus tag filter parameters.\n * @throws When the payload is not `{ event, params }`.\n */\nexport const normalizeInput = (input: unknown): AutoStartPreventInput => {\n  if (isAutoStartPreventInput(input)) {\n    return input;\n  }\n  throw new Error('Invalid input: expected { event, params }.');\n};\n\n/**\n * Returns true if the resource has a tag with the given key and a value in the allowed list.\n *\n * @param params - Tag key and allowed values.\n * @param tags - Resource tag list (e.g. from DescribeDBInstances / DescribeDBClusters).\n * @returns Whether the tag matches.\n */\nexport const matchTag = (params: AutoStartParams, tags?: Tag[]): boolean => {\n  if (!tags || tags.length === 0) {\n    return false;\n  }\n  const value = tags.find(t => t.Key === params.tagKey)?.Value;\n  if (!value) {\n    return false;\n  }\n  return params.tagValues.includes(value);\n};\n\n/**\n * Whether the EventBridge detail identifies a supported DB instance auto-start event.\n *\n * @param detailType - EventBridge detail-type.\n * @param detail - RDS event detail.\n * @returns True for RDS-EVENT-0154 on a DB instance.\n */\nexport const isDbInstanceAutoStart = (\n  detailType: RdsAutoStartEvent['detail-type'],\n  detail: RdsAutoStartDetail,\n): boolean =>\n  detailType === 'RDS DB Instance Event' &&\n  detail.SourceType === 'DB_INSTANCE' &&\n  detail.EventID === 'RDS-EVENT-0154';\n\n/**\n * Whether the EventBridge detail identifies a supported DB cluster auto-start event.\n *\n * @param detailType - EventBridge detail-type.\n * @param detail - RDS event detail.\n * @returns True for RDS-EVENT-0153 on a cluster.\n */\nexport const isDbClusterAutoStart = (\n  detailType: RdsAutoStartEvent['detail-type'],\n  detail: RdsAutoStartDetail,\n): boolean =>\n  detailType === 'RDS DB Cluster Event' &&\n  detail.SourceType === 'CLUSTER' &&\n  detail.EventID === 'RDS-EVENT-0153';\n\n/**\n * Wait strategy while describing until the resource leaves transitional statuses.\n *\n * @param state - Latest wait state.\n * @returns Continue at {@link WAIT_INTERVAL_MINUTES} while transitional; otherwise stop.\n */\nexport const waitStrategyUntilStable = (state: WaitState): WaitStrategyResult => {\n  if (isTransitionalStatus(state.status)) {\n    return { shouldContinue: true, delay: { minutes: WAIT_INTERVAL_MINUTES } };\n  }\n  return { shouldContinue: false };\n};\n\n/**\n * Wait strategy after StopDB* until the resource reaches `stopped`.\n *\n * @param state - Latest wait state.\n * @returns Stop when `stopped`; continue at {@link WAIT_INTERVAL_MINUTES} while transitional.\n * @throws When the status is neither stopped nor transitional.\n */\nexport const waitStrategyUntilStopped = (state: WaitState): WaitStrategyResult => {\n  if (state.status === 'stopped') {\n    return { shouldContinue: false };\n  }\n  if (isTransitionalStatus(state.status)) {\n    return { shouldContinue: true, delay: { minutes: WAIT_INTERVAL_MINUTES } };\n  }\n  throw new Error(`Unexpected status while waiting for stop: ${state.status}`);\n};\n\n/**\n * Decision after the first describe and a successful tag match.\n */\nexport type AfterTagMatchDecision =\n  | { kind: 'stop' }\n  | { kind: 'no-op'; result: NoOpResult }\n  | { kind: 'error'; message: string };\n\n/**\n * Decides the next action when tags matched and StopDB* has not been called yet.\n *\n * @param status - Status from the first describe after leaving transitional states.\n * @returns Stop when `available`; no-op when already `stopped`; otherwise error.\n */\nexport const decideAfterTagMatch = (status: string): AfterTagMatchDecision => {\n  if (status === 'available') {\n    return { kind: 'stop' };\n  }\n  if (status === 'stopped') {\n    return {\n      kind: 'no-op',\n      result: {\n        action: 'no-op',\n        reason: 'already stopped',\n        status,\n      },\n    };\n  }\n  return {\n    kind: 'error',\n    message: `DB status is not stopped after processing: ${status}`,\n  };\n};\n\n/**\n * Builds the no-op result used when tags do not match.\n *\n * @param status - Current resource status.\n * @returns No-op result with tag mismatch reason.\n */\nexport const tagMismatchNoOp = (status: string): NoOpResult => ({\n  action: 'no-op',\n  reason: 'tag not matched or not found',\n  status,\n});\n\n/**\n * Parses region and account from an RDS resource ARN (`arn:aws:rds:region:account:...`).\n *\n * @param sourceArn - SourceArn from the RDS event detail.\n * @returns Region and account id segments.\n */\nexport const parseRdsSourceArn = (sourceArn: string): { region: string; account: string } => {\n  const parts = sourceArn.split(':');\n  return {\n    region: parts[3] ?? '',\n    account: parts[4] ?? '',\n  };\n};\n\n/**\n * Arguments for the Slack stop-success notification.\n */\nexport interface SlackStopNotificationArgs {\n  channel: string;\n  sourceType: RdsAutoStartDetail['SourceType'];\n  sourceIdentifier: string;\n  account: string;\n  region: string;\n}\n\n/**\n * Builds the Slack `chat.postMessage` payload after a successful stop.\n *\n * @param args - Channel and resource identity fields.\n * @returns Arguments suitable for `WebClient.chat.postMessage`.\n */\nexport const buildSlackStopNotification = (args: SlackStopNotificationArgs) => ({\n  channel: args.channel,\n  attachments: [\n    {\n      color: '#36a64f',\n      pretext: `😴 Successfully stopped the automatically running RDS ${args.sourceType} ${args.sourceIdentifier}.`,\n      fields: [\n        {\n          title: 'Account',\n          value: args.account,\n          short: true,\n        },\n        {\n          title: 'Region',\n          value: args.region,\n          short: true,\n        },\n        {\n          title: 'Type',\n          value: args.sourceType,\n          short: true,\n        },\n        {\n          title: 'Identifier',\n          value: args.sourceIdentifier,\n          short: true,\n        },\n      ],\n    },\n  ],\n});\n\n/**\n * Builds the success result after StopDB* reached `stopped`.\n *\n * @param args - Final status and identity fields.\n * @returns StoppedResult for the handler return value.\n */\nexport const buildStoppedResult = (args: {\n  finalStatus: string;\n  account: string;\n  region: string;\n  identifier: string;\n}): StoppedResult => ({\n  action: 'stopped',\n  finalStatus: args.finalStatus,\n  account: args.account,\n  region: args.region,\n  identifier: args.identifier,\n});\n"]}

package/lib/index.d.ts

@@ -7,5 +7,5 @@
  *
  * @module rds-database-auto-start-preventer
  */
-export * from './constructs/rds-database-auto-start-preventer';
-export * from './stacks/rds-database-auto-start-prevent-stack';
+export * from './rds-database-auto-start-preventer';
+export * from './rds-database-auto-start-prevent-stack';

package/lib/index.js

@@ -23,6 +23,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
  *
  * @module rds-database-auto-start-preventer
  */
-__exportStar(require("./constructs/rds-database-auto-start-preventer"), exports);
-__exportStar(require("./stacks/rds-database-auto-start-prevent-stack"), exports);
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7OztBQUFBOzs7Ozs7OztHQVFHO0FBQ0gsaUZBQStEO0FBQy9ELGlGQUErRCIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogUkRTIERhdGFiYXNlIEF1dG8gU3RhcnQgUHJldmVudGVyIOKAlCBDREsgY29uc3RydWN0IGxpYnJhcnkuXG4gKlxuICogU3RvcHMgUkRTIERCIGluc3RhbmNlcyBhbmQgY2x1c3RlcnMgYWZ0ZXIgQVdTIGF1dG8tc3RhcnQgZXZlbnRzLiBUaGUgaGFuZGxlclxuICogZmlsdGVycyBieSB0YWdzIGFuZCwgd2hlbiBhIFNsYWNrIHNlY3JldCBuYW1lIGlzIHNldCwgcG9zdHMgdG8gU2xhY2sgYWZ0ZXIgYVxuICogc3VjY2Vzc2Z1bCBzdG9wLlxuICpcbiAqIEBtb2R1bGUgcmRzLWRhdGFiYXNlLWF1dG8tc3RhcnQtcHJldmVudGVyXG4gKi9cbmV4cG9ydCAqIGZyb20gJy4vY29uc3RydWN0cy9yZHMtZGF0YWJhc2UtYXV0by1zdGFydC1wcmV2ZW50ZXInO1xuZXhwb3J0ICogZnJvbSAnLi9zdGFja3MvcmRzLWRhdGFiYXNlLWF1dG8tc3RhcnQtcHJldmVudC1zdGFjayc7XG4iXX0=
+__exportStar(require("./rds-database-auto-start-preventer"), exports);
+__exportStar(require("./rds-database-auto-start-prevent-stack"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7OztBQUFBOzs7Ozs7OztHQVFHO0FBQ0gsc0VBQW9EO0FBQ3BELDBFQUF3RCIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogUkRTIERhdGFiYXNlIEF1dG8gU3RhcnQgUHJldmVudGVyIOKAlCBDREsgY29uc3RydWN0IGxpYnJhcnkuXG4gKlxuICogU3RvcHMgUkRTIERCIGluc3RhbmNlcyBhbmQgY2x1c3RlcnMgYWZ0ZXIgQVdTIGF1dG8tc3RhcnQgZXZlbnRzLiBUaGUgaGFuZGxlclxuICogZmlsdGVycyBieSB0YWdzIGFuZCwgd2hlbiBhIFNsYWNrIHNlY3JldCBuYW1lIGlzIHNldCwgcG9zdHMgdG8gU2xhY2sgYWZ0ZXIgYVxuICogc3VjY2Vzc2Z1bCBzdG9wLlxuICpcbiAqIEBtb2R1bGUgcmRzLWRhdGFiYXNlLWF1dG8tc3RhcnQtcHJldmVudGVyXG4gKi9cbmV4cG9ydCAqIGZyb20gJy4vcmRzLWRhdGFiYXNlLWF1dG8tc3RhcnQtcHJldmVudGVyJztcbmV4cG9ydCAqIGZyb20gJy4vcmRzLWRhdGFiYXNlLWF1dG8tc3RhcnQtcHJldmVudC1zdGFjayc7XG4iXX0=

package/lib/{stacks/rds-database-auto-start-prevent-stack.d.ts → rds-database-auto-start-prevent-stack.d.ts}

@@ -1,16 +1,10 @@
 import { Stack, StackProps } from 'aws-cdk-lib';
 import { Construct } from 'constructs';
-import { TargetResource, Secrets } from '../constructs/rds-database-auto-start-preventer';
+import { RDSDatabaseAutoStartPreventerProps } from './rds-database-auto-start-preventer';
 /**
  * Props for the RDS database auto start prevent CDK stack.
  */
-export interface RDSDatabaseAutoStartPreventStackProps extends StackProps {
-    /** Tag-based target resource criteria for RDS instances/clusters to protect. */
-    readonly targetResource: TargetResource;
-    /** Whether the EventBridge rules are enabled. Defaults to true if omitted. */
-    readonly enableRule?: boolean;
-    /** Secrets for notifications. Omit slackSecretName to skip Slack. */
-    readonly secrets: Secrets;
+export interface RDSDatabaseAutoStartPreventStackProps extends RDSDatabaseAutoStartPreventerProps, StackProps {
 }
 /**
  * CDK stack that deploys {@link RDSDatabaseAutoStartPreventer}.

package/lib/rds-database-auto-start-prevent-stack.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RDSDatabaseAutoStartPreventStack = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const aws_cdk_lib_1 = require("aws-cdk-lib");
+const rds_database_auto_start_preventer_1 = require("./rds-database-auto-start-preventer");
+/**
+ * CDK stack that deploys {@link RDSDatabaseAutoStartPreventer}.
+ */
+class RDSDatabaseAutoStartPreventStack extends aws_cdk_lib_1.Stack {
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "rds-database-auto-start-preventer.RDSDatabaseAutoStartPreventStack", version: "0.5.1" };
+    /**
+     * Creates the stack and the RDSDatabaseAutoStartPreventer construct.
+     *
+     * @param scope - Parent construct.
+     * @param id - Stack id.
+     * @param props - Stack props (target resource, enable rule, secrets).
+     */
+    constructor(scope, id, props) {
+        super(scope, id, props);
+        new rds_database_auto_start_preventer_1.RDSDatabaseAutoStartPreventer(this, 'RDSDatabaseAutoStartPreventer', {
+            targetResource: props.targetResource,
+            enableRule: props.enableRule,
+            secrets: props.secrets,
+        });
+    }
+}
+exports.RDSDatabaseAutoStartPreventStack = RDSDatabaseAutoStartPreventStack;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/{constructs/rds-database-auto-start-preventer.d.ts → rds-database-auto-start-preventer.d.ts}

@@ -38,7 +38,8 @@ export interface RDSDatabaseAutoStartPreventerProps {
  *
  * EventBridge rules match all auto-start events; tag filtering runs in the handler
  * using `TagList` from `rds:DescribeDBInstances` / `rds:DescribeDBClusters`.
- * IAM grants RDS describe and stop actions only (no Resource Groups Tagging API).
+ * IAM grants account/region-scoped describe on `db` / `cluster` ARNs, and stop only
+ * when `aws:ResourceTag` matches {@link TargetResource} (no Resource Groups Tagging API).
  */
 export declare class RDSDatabaseAutoStartPreventer extends Construct {
     /**