rds-database-auto-start-preventer 0.5.3 → 0.6.0

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

@@ -18,4 +18,5 @@ import { NoOpResult, StoppedResult } from './core/auto-start-prevent.predicates'
  * @throws When the payload is invalid, the event is unsupported, a configured Slack secret is invalid, or stop did not reach `stopped`.
  */
 export declare const processAutoStartPrevent: (input: unknown, context: DurableContext) => Promise<StoppedResult | NoOpResult>;
+/** Lambda entry point: {@link processAutoStartPrevent} wrapped with the failure log and durable execution. */
 export declare const handler: import("@aws/durable-execution-sdk-js").DurableLambdaHandler;

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

@@ -7,8 +7,68 @@ 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("./core/auto-start-prevent.predicates");
+const consts_1 = require("../settings/consts");
 /** Shared RDS client for describe and stop API calls. */
 const rdsClient = new client_rds_1.RDSClient({});
+/**
+ * Per-request timeout for Slack API calls.
+ * The WebClient default is no timeout with ~30 minutes of retries, which exceeds the Lambda invocation timeout.
+ */
+const SLACK_REQUEST_TIMEOUT_MS = 30_000;
+/** Slack retries after the first attempt, kept within the Lambda invocation timeout. */
+const SLACK_RETRIES = 2;
+/** Durable step names for StopDB*; kept per resource kind so existing execution histories still replay. */
+const STOP_STEP_NAMES = {
+    instance: 'stop-db-instance',
+    cluster: 'stop-db-cluster',
+};
+/**
+ * Describes the DB instance or cluster and returns its status, identifier, and tags.
+ * Falls back to `unknown`, the requested identifier, and no tags when the response has no resource.
+ *
+ * @param kind - Resource type to describe.
+ * @param identifier - DB instance or cluster identifier.
+ * @returns Wait state including the resource TagList.
+ */
+const describeResource = async (kind, identifier) => {
+    if (kind === 'instance') {
+        const res = await rdsClient.send(new client_rds_1.DescribeDBInstancesCommand({
+            DBInstanceIdentifier: identifier,
+        }));
+        const db = res.DBInstances?.[0];
+        return {
+            status: db?.DBInstanceStatus ?? auto_start_prevent_predicates_1.DB_STATUS.UNKNOWN,
+            identifier: db?.DBInstanceIdentifier ?? identifier,
+            tags: (db?.TagList ?? []),
+        };
+    }
+    const res = await rdsClient.send(new client_rds_1.DescribeDBClustersCommand({
+        DBClusterIdentifier: identifier,
+    }));
+    const cluster = res.DBClusters?.[0];
+    return {
+        status: cluster?.Status ?? auto_start_prevent_predicates_1.DB_STATUS.UNKNOWN,
+        identifier: cluster?.DBClusterIdentifier ?? identifier,
+        tags: (cluster?.TagList ?? []),
+    };
+};
+/**
+ * Calls StopDBInstance or StopDBCluster.
+ *
+ * @param kind - Resource type to stop.
+ * @param identifier - DB instance or cluster identifier.
+ */
+const stopResource = async (kind, identifier) => {
+    if (kind === 'instance') {
+        await rdsClient.send(new client_rds_1.StopDBInstanceCommand({
+            DBInstanceIdentifier: identifier,
+        }));
+        return;
+    }
+    await rdsClient.send(new client_rds_1.StopDBClusterCommand({
+        DBClusterIdentifier: identifier,
+    }));
+};
 /**
  * Durable Lambda handler for RDS auto-start prevention.
  *
@@ -35,46 +95,21 @@ const processAutoStartPrevent = async (input, context) => {
     });
     // Requires AWS Parameters and Secrets Extension (ParamsAndSecrets layer) and
     // AWS_SESSION_TOKEN from the Lambda runtime (aws-lambda-secret-fetcher ^0.6+).
+    // Fetched outside context.step: step results are persisted in the durable execution history,
+    // so the token and channel must not be returned from a step. Re-fetching on replay is read-only.
     let slackSecret;
     if (slackSecretName.length > 0) {
-        const slackSecretValue = await context.step('fetch-slack-secret', async () => {
-            return aws_lambda_secret_fetcher_1.secretFetcher.getSecretValue(slackSecretName);
-        });
+        const slackSecretValue = await aws_lambda_secret_fetcher_1.secretFetcher.getSecretValue(slackSecretName);
         if (!(0, auto_start_prevent_predicates_1.isSlackSecret)(slackSecretValue)) {
             throw new Error('Slack secret must be JSON with non-empty token and channel.');
         }
         slackSecret = slackSecretValue;
     }
-    const isInstance = (0, auto_start_prevent_predicates_1.isDbInstanceAutoStart)(detailType, detail);
-    const isCluster = (0, auto_start_prevent_predicates_1.isDbClusterAutoStart)(detailType, detail);
-    if (!isInstance && !isCluster) {
-        throw new Error(`Unsupported event: detail-type=${detailType}, SourceType=${detail.SourceType}, EventID=${detail.EventID}`);
-    }
+    const kind = (0, auto_start_prevent_predicates_1.resolveResourceKind)(detailType, detail);
     // Initial delay before the first describe (allows RDS to report a stable status).
-    await context.wait({ minutes: 1 });
+    await context.wait('initial-delay', { minutes: 1 });
     // Wait until the resource is no longer in a transitional status; capture status and TagList.
-    const firstDescribe = await context.waitForCondition(async (_state, _ctx) => {
-        if (isInstance) {
-            const res = await rdsClient.send(new client_rds_1.DescribeDBInstancesCommand({
-                DBInstanceIdentifier: detail.SourceIdentifier,
-            }));
-            const db = res.DBInstances?.[0];
-            return {
-                status: db?.DBInstanceStatus ?? 'unknown',
-                identifier: db?.DBInstanceIdentifier ?? detail.SourceIdentifier,
-                tags: (db?.TagList ?? []),
-            };
-        }
-        const res = await rdsClient.send(new client_rds_1.DescribeDBClustersCommand({
-            DBClusterIdentifier: detail.SourceIdentifier,
-        }));
-        const cluster = res.DBClusters?.[0];
-        return {
-            status: cluster?.Status ?? 'unknown',
-            identifier: cluster?.DBClusterIdentifier ?? detail.SourceIdentifier,
-            tags: (cluster?.TagList ?? []),
-        };
-    }, {
+    const firstDescribe = await context.waitForCondition('wait-until-stable', async (_state, _ctx) => describeResource(kind, detail.SourceIdentifier), {
         initialState: {
             status: 'starting',
             identifier: detail.SourceIdentifier,
@@ -85,73 +120,40 @@ const processAutoStartPrevent = async (input, context) => {
     if (!(0, auto_start_prevent_predicates_1.matchTag)(params, firstDescribe.tags)) {
         return (0, auto_start_prevent_predicates_1.tagMismatchNoOp)(firstDescribe.status);
     }
-    let didStop = false;
-    let finalStatus = firstDescribe.status;
-    // When available, invoke StopDB* and wait until stopped.
-    const afterTagMatch = (0, auto_start_prevent_predicates_1.decideAfterTagMatch)(firstDescribe.status);
-    if (afterTagMatch.kind === 'stop') {
-        if (isInstance) {
-            await context.step('stop-db-instance', async () => {
-                await rdsClient.send(new client_rds_1.StopDBInstanceCommand({
-                    DBInstanceIdentifier: detail.SourceIdentifier,
-                }));
-            });
-        }
-        else {
-            await context.step('stop-db-cluster', async () => {
-                await rdsClient.send(new client_rds_1.StopDBClusterCommand({
-                    DBClusterIdentifier: detail.SourceIdentifier,
-                }));
-            });
-        }
-        const stopped = await context.waitForCondition(async (_state, _ctx) => {
-            if (isInstance) {
-                const res = await rdsClient.send(new client_rds_1.DescribeDBInstancesCommand({
-                    DBInstanceIdentifier: detail.SourceIdentifier,
-                }));
-                const db = res.DBInstances?.[0];
-                return {
-                    status: db?.DBInstanceStatus ?? 'unknown',
-                    identifier: db?.DBInstanceIdentifier ?? detail.SourceIdentifier,
-                };
-            }
-            const res = await rdsClient.send(new client_rds_1.DescribeDBClustersCommand({
-                DBClusterIdentifier: detail.SourceIdentifier,
-            }));
-            const cluster = res.DBClusters?.[0];
-            return {
-                status: cluster?.Status ?? 'unknown',
-                identifier: cluster?.DBClusterIdentifier ?? detail.SourceIdentifier,
-            };
-        }, {
-            initialState: {
-                status: firstDescribe.status,
-                identifier: firstDescribe.identifier,
-            },
-            waitStrategy: auto_start_prevent_predicates_1.waitStrategyUntilStopped,
-        });
-        didStop = true;
-        finalStatus = stopped.status;
-    }
     // Already stopped without calling StopDB* (e.g. stopped by another process) — no Slack notification.
-    if (!didStop) {
-        if (afterTagMatch.kind === 'no-op') {
-            return afterTagMatch.result;
-        }
-        if (afterTagMatch.kind === 'error') {
-            throw new Error(afterTagMatch.message);
-        }
+    const afterTagMatch = (0, auto_start_prevent_predicates_1.decideAfterTagMatch)(firstDescribe);
+    if (afterTagMatch.kind === 'no-op') {
+        return afterTagMatch.result;
     }
-    // Fail when StopDB* was called but the resource did not reach stopped.
-    if (finalStatus !== 'stopped') {
-        throw new Error(`DB status is not stopped after processing: ${finalStatus}`);
+    if (afterTagMatch.kind === 'error') {
+        throw new Error(afterTagMatch.message);
     }
+    // Available: invoke StopDB* and wait until stopped.
+    await context.step(STOP_STEP_NAMES[kind], async () => {
+        await stopResource(kind, detail.SourceIdentifier);
+    });
+    // waitStrategyUntilStopped ends only on `stopped` and throws on any non-transitional status.
+    // Tags are dropped here so they are not persisted again on every check.
+    const stopped = await context.waitForCondition('wait-until-stopped', async (_state, _ctx) => {
+        const { status, identifier } = await describeResource(kind, detail.SourceIdentifier);
+        return { status, identifier };
+    }, {
+        initialState: {
+            status: firstDescribe.status,
+            identifier: firstDescribe.identifier,
+        },
+        waitStrategy: auto_start_prevent_predicates_1.waitStrategyUntilStopped,
+    });
     const { region, account } = (0, auto_start_prevent_predicates_1.parseRdsSourceArn)(detail.SourceArn);
     if (slackSecret !== undefined) {
         const channel = slackSecret.channel;
-        const client = new web_api_1.WebClient(slackSecret.token);
+        const client = new web_api_1.WebClient(slackSecret.token, {
+            timeout: SLACK_REQUEST_TIMEOUT_MS,
+            retryConfig: { retries: SLACK_RETRIES },
+        });
+        // Return nothing so the Slack API response is not persisted in the durable execution history.
         await context.step('post-slack-messages', async () => {
-            return client.chat.postMessage((0, auto_start_prevent_predicates_1.buildSlackStopNotification)({
+            await client.chat.postMessage((0, auto_start_prevent_predicates_1.buildSlackStopNotification)({
                 channel,
                 sourceType: detail.SourceType,
                 sourceIdentifier: detail.SourceIdentifier,
@@ -161,12 +163,48 @@ const processAutoStartPrevent = async (input, context) => {
         });
     }
     return (0, auto_start_prevent_predicates_1.buildStoppedResult)({
-        finalStatus,
+        finalStatus: stopped.status,
         account,
         region,
         identifier: detail.SourceIdentifier,
     });
 };
 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 './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"]}
+/**
+ * Returns the RDS source identifier from the input, or undefined when the input is invalid.
+ *
+ * @param input - Raw handler input.
+ * @returns DB instance or cluster identifier when available.
+ */
+const sourceIdentifierOf = (input) => {
+    try {
+        return (0, auto_start_prevent_predicates_1.normalizeInput)(input).event.detail.SourceIdentifier;
+    }
+    catch {
+        return undefined;
+    }
+};
+/**
+ * Runs {@link processAutoStartPrevent} and logs {@link AUTO_START_PREVENT_FAILED_LOG_TERM} before rethrowing,
+ * because a failed durable execution does not raise the Lambda `Errors` metric.
+ *
+ * @param input - `{ event, params }` from EventBridge InputTransformer.
+ * @param context - Durable execution context for steps and waits.
+ * @returns {@link StoppedResult} or {@link NoOpResult}.
+ * @throws The error from {@link processAutoStartPrevent}.
+ */
+const processAutoStartPreventWithFailureLog = async (input, context) => {
+    try {
+        return await (0, exports.processAutoStartPrevent)(input, context);
+    }
+    catch (error) {
+        console.error(consts_1.AUTO_START_PREVENT_FAILED_LOG_TERM, {
+            identifier: sourceIdentifierOf(input),
+            errorMessage: error instanceof Error ? error.message : String(error),
+        });
+        throw error;
+    }
+};
+/** Lambda entry point: {@link processAutoStartPrevent} wrapped with the failure log and durable execution. */
+exports.handler = (0, durable_execution_sdk_js_1.withDurableExecution)(processAutoStartPreventWithFailureLog);
+//# 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  DB_STATUS,\n  decideAfterTagMatch,\n  isSlackSecret,\n  matchTag,\n  normalizeInput,\n  NoOpResult,\n  parseRdsSourceArn,\n  ResourceKind,\n  resolveResourceKind,\n  WaitState,\n  SlackSecret,\n  StoppedResult,\n  Tag,\n  tagMismatchNoOp,\n  waitStrategyUntilStable,\n  waitStrategyUntilStopped,\n} from './core/auto-start-prevent.predicates';\nimport { AUTO_START_PREVENT_FAILED_LOG_TERM } from '../settings/consts';\n\n/** Shared RDS client for describe and stop API calls. */\nconst rdsClient = new RDSClient({});\n\n/**\n * Per-request timeout for Slack API calls.\n * The WebClient default is no timeout with ~30 minutes of retries, which exceeds the Lambda invocation timeout.\n */\nconst SLACK_REQUEST_TIMEOUT_MS = 30_000;\n\n/** Slack retries after the first attempt, kept within the Lambda invocation timeout. */\nconst SLACK_RETRIES = 2;\n\n/** Durable step names for StopDB*; kept per resource kind so existing execution histories still replay. */\nconst STOP_STEP_NAMES: Record<ResourceKind, string> = {\n  instance: 'stop-db-instance',\n  cluster: 'stop-db-cluster',\n};\n\n/**\n * Describes the DB instance or cluster and returns its status, identifier, and tags.\n * Falls back to `unknown`, the requested identifier, and no tags when the response has no resource.\n *\n * @param kind - Resource type to describe.\n * @param identifier - DB instance or cluster identifier.\n * @returns Wait state including the resource TagList.\n */\nconst describeResource = async (kind: ResourceKind, identifier: string): Promise<Required<WaitState>> => {\n  if (kind === 'instance') {\n    const res = await rdsClient.send(\n      new DescribeDBInstancesCommand({\n        DBInstanceIdentifier: identifier,\n      }),\n    );\n    const db = res.DBInstances?.[0];\n    return {\n      status: db?.DBInstanceStatus ?? DB_STATUS.UNKNOWN,\n      identifier: db?.DBInstanceIdentifier ?? identifier,\n      tags: (db?.TagList ?? []) as Tag[],\n    };\n  }\n\n  const res = await rdsClient.send(\n    new DescribeDBClustersCommand({\n      DBClusterIdentifier: identifier,\n    }),\n  );\n  const cluster = res.DBClusters?.[0];\n  return {\n    status: cluster?.Status ?? DB_STATUS.UNKNOWN,\n    identifier: cluster?.DBClusterIdentifier ?? identifier,\n    tags: (cluster?.TagList ?? []) as Tag[],\n  };\n};\n\n/**\n * Calls StopDBInstance or StopDBCluster.\n *\n * @param kind - Resource type to stop.\n * @param identifier - DB instance or cluster identifier.\n */\nconst stopResource = async (kind: ResourceKind, identifier: string): Promise<void> => {\n  if (kind === 'instance') {\n    await rdsClient.send(\n      new StopDBInstanceCommand({\n        DBInstanceIdentifier: identifier,\n      }),\n    );\n    return;\n  }\n\n  await rdsClient.send(\n    new StopDBClusterCommand({\n      DBClusterIdentifier: identifier,\n    }),\n  );\n};\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  // Fetched outside context.step: step results are persisted in the durable execution history,\n  // so the token and channel must not be returned from a step. Re-fetching on replay is read-only.\n  let slackSecret: SlackSecret | undefined;\n  if (slackSecretName.length > 0) {\n    const slackSecretValue = await secretFetcher.getSecretValue<SlackSecret>(slackSecretName);\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 kind = resolveResourceKind(detailType, detail);\n\n  // Initial delay before the first describe (allows RDS to report a stable status).\n  await context.wait('initial-delay', { 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    'wait-until-stable',\n    async (_state, _ctx) => describeResource(kind, detail.SourceIdentifier),\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  // Already stopped without calling StopDB* (e.g. stopped by another process) — no Slack notification.\n  const afterTagMatch = decideAfterTagMatch(firstDescribe);\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  // Available: invoke StopDB* and wait until stopped.\n  await context.step(STOP_STEP_NAMES[kind], async () => {\n    await stopResource(kind, detail.SourceIdentifier);\n  });\n\n  // waitStrategyUntilStopped ends only on `stopped` and throws on any non-transitional status.\n  // Tags are dropped here so they are not persisted again on every check.\n  const stopped = await context.waitForCondition<WaitState>(\n    'wait-until-stopped',\n    async (_state, _ctx) => {\n      const { status, identifier } = await describeResource(kind, detail.SourceIdentifier);\n      return { status, identifier };\n    },\n    {\n      initialState: {\n        status: firstDescribe.status,\n        identifier: firstDescribe.identifier,\n      },\n      waitStrategy: waitStrategyUntilStopped,\n    },\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      timeout: SLACK_REQUEST_TIMEOUT_MS,\n      retryConfig: { retries: SLACK_RETRIES },\n    });\n    // Return nothing so the Slack API response is not persisted in the durable execution history.\n    await context.step('post-slack-messages', async () => {\n      await 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: stopped.status,\n    account,\n    region,\n    identifier: detail.SourceIdentifier,\n  });\n};\n\n/**\n * Returns the RDS source identifier from the input, or undefined when the input is invalid.\n *\n * @param input - Raw handler input.\n * @returns DB instance or cluster identifier when available.\n */\nconst sourceIdentifierOf = (input: unknown): string | undefined => {\n  try {\n    return normalizeInput(input).event.detail.SourceIdentifier;\n  } catch {\n    return undefined;\n  }\n};\n\n/**\n * Runs {@link processAutoStartPrevent} and logs {@link AUTO_START_PREVENT_FAILED_LOG_TERM} before rethrowing,\n * because a failed durable execution does not raise the Lambda `Errors` metric.\n *\n * @param input - `{ event, params }` from EventBridge InputTransformer.\n * @param context - Durable execution context for steps and waits.\n * @returns {@link StoppedResult} or {@link NoOpResult}.\n * @throws The error from {@link processAutoStartPrevent}.\n */\nconst processAutoStartPreventWithFailureLog = async (\n  input: unknown,\n  context: DurableContext,\n): Promise<StoppedResult | NoOpResult> => {\n  try {\n    return await processAutoStartPrevent(input, context);\n  } catch (error) {\n    console.error(AUTO_START_PREVENT_FAILED_LOG_TERM, {\n      identifier: sourceIdentifierOf(input),\n      errorMessage: error instanceof Error ? error.message : String(error),\n    });\n    throw error;\n  }\n};\n\n/** Lambda entry point: {@link processAutoStartPrevent} wrapped with the failure log and durable execution. */\nexport const handler = withDurableExecution(processAutoStartPreventWithFailureLog);\n"]}

package/lib/funcs/core/auto-start-prevent.predicates.d.ts

@@ -2,14 +2,15 @@
  * Pure helpers for the RDS auto-start prevent Lambda.
  * No AWS SDK, Durable context, env, or clock dependencies.
  */
+import { DB_CLUSTER_AUTO_START_EVENT, DB_INSTANCE_AUTO_START_EVENT, RDS_EVENT_SOURCE } from '../../settings/consts';
 /**
  * Detail payload of an RDS auto-start event from EventBridge.
  */
 export interface RdsAutoStartDetail {
     /** Event ID: RDS-EVENT-0154 (DB instance) or RDS-EVENT-0153 (DB cluster). */
-    EventID: 'RDS-EVENT-0154' | 'RDS-EVENT-0153';
+    EventID: typeof DB_INSTANCE_AUTO_START_EVENT.eventId | typeof DB_CLUSTER_AUTO_START_EVENT.eventId;
     /** Resource type that emitted the event. */
-    SourceType: 'DB_INSTANCE' | 'CLUSTER';
+    SourceType: typeof DB_INSTANCE_AUTO_START_EVENT.sourceType | typeof DB_CLUSTER_AUTO_START_EVENT.sourceType;
     /** ARN of the DB instance or cluster. */
     SourceArn: string;
     /** DB instance or cluster identifier from the event. */
@@ -19,8 +20,8 @@ export interface RdsAutoStartDetail {
  * RDS auto-start event as received from EventBridge.
  */
 export interface RdsAutoStartEvent {
-    'detail-type': 'RDS DB Instance Event' | 'RDS DB Cluster Event';
-    'source': 'aws.rds';
+    'detail-type': typeof DB_INSTANCE_AUTO_START_EVENT.detailType | typeof DB_CLUSTER_AUTO_START_EVENT.detailType;
+    'source': typeof RDS_EVENT_SOURCE;
     'detail': RdsAutoStartDetail;
 }
 /**
@@ -97,6 +98,12 @@ export interface StopWait {
 }
 /** Result of a durable waitStrategy. */
 export type WaitStrategyResult = ContinueWait | StopWait;
+/** RDS statuses the handler branches on, plus the fallback when a describe returns no resource. */
+export declare const DB_STATUS: {
+    readonly AVAILABLE: "available";
+    readonly STOPPED: "stopped";
+    readonly UNKNOWN: "unknown";
+};
 /** Minutes between describe calls while a status is transitional or stopping. */
 export declare const WAIT_INTERVAL_MINUTES = 5;
 /**
@@ -114,8 +121,8 @@ export declare const isTransitionalStatus: (status: string) => boolean;
 /**
  * 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.
+ * aws-lambda-secret-fetcher ^0.10 parses a string SecretString as JSON (already parsed values are
+ * returned as-is) 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.
@@ -160,6 +167,17 @@ export declare const isDbInstanceAutoStart: (detailType: RdsAutoStartEvent["deta
  * @returns True for RDS-EVENT-0153 on a cluster.
  */
 export declare const isDbClusterAutoStart: (detailType: RdsAutoStartEvent["detail-type"], detail: RdsAutoStartDetail) => boolean;
+/** RDS resource type targeted by a supported auto-start event. */
+export type ResourceKind = 'instance' | 'cluster';
+/**
+ * Resolves which RDS resource type a supported auto-start event targets.
+ *
+ * @param detailType - EventBridge detail-type.
+ * @param detail - RDS event detail.
+ * @returns `instance` for RDS-EVENT-0154 on a DB instance; `cluster` for RDS-EVENT-0153 on a cluster.
+ * @throws When the detail-type, SourceType, and EventID do not form a supported auto-start event.
+ */
+export declare const resolveResourceKind: (detailType: RdsAutoStartEvent["detail-type"], detail: RdsAutoStartDetail) => ResourceKind;
 /**
  * Wait strategy while describing until the resource leaves transitional statuses.
  *
@@ -190,10 +208,11 @@ export type AfterTagMatchDecision = {
 /**
  * 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.
+ * @param state - Status and identifier from the first describe after leaving transitional states.
+ * @returns Stop when `available`; no-op when already `stopped`; otherwise an error naming the
+ * identifier and status, because StopDB* cannot be called from any other status.
  */
-export declare const decideAfterTagMatch: (status: string) => AfterTagMatchDecision;
+export declare const decideAfterTagMatch: (state: WaitState) => AfterTagMatchDecision;
 /**
  * Builds the no-op result used when tags do not match.
  *