rds-database-auto-start-preventer 0.2.6 → 0.3.0

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

@@ -0,0 +1,251 @@
+/**
+ * Pure helpers for the RDS auto-start prevent Lambda.
+ * No AWS SDK, Durable context, env, or clock dependencies.
+ */
+/**
+ * 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';
+    /** Resource type that emitted the event. */
+    SourceType: 'DB_INSTANCE' | 'CLUSTER';
+    /** ARN of the DB instance or cluster. */
+    SourceArn: string;
+    /** DB instance or cluster identifier from the event. */
+    SourceIdentifier: string;
+}
+/**
+ * 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': RdsAutoStartDetail;
+}
+/**
+ * Tag-based filter parameters for the handler.
+ */
+export interface AutoStartParams {
+    /** Tag key to match on the resource. */
+    tagKey: string;
+    /** Allowed tag values; the resource is processed only when its tag value is in this list. */
+    tagValues: string[];
+}
+/**
+ * Slack credentials stored in Secrets Manager.
+ */
+export interface SlackSecret {
+    /** Slack bot or user OAuth token. */
+    token: string;
+    /** Channel ID or name to post notifications to. */
+    channel: string;
+}
+/**
+ * Normalized handler input: EventBridge event and tag filter parameters.
+ */
+export interface AutoStartPreventInput {
+    event: RdsAutoStartEvent;
+    params: AutoStartParams;
+}
+/**
+ * Handler result when no stop action was taken.
+ */
+export interface NoOpResult {
+    action: 'no-op';
+    reason: 'tag not matched or not found' | 'already stopped';
+    status: string;
+}
+/**
+ * Handler result when this invocation called StopDB* and the resource reached `stopped`.
+ */
+export interface StoppedResult {
+    action: 'stopped';
+    finalStatus: string;
+    account: string;
+    region: string;
+    identifier: string;
+}
+/**
+ * AWS-style tag (Key/Value).
+ */
+export interface Tag {
+    Key?: string;
+    Value?: string;
+}
+/**
+ * State snapshot while waiting on RDS describe APIs.
+ */
+export interface WaitState {
+    /** Current DB instance or cluster status. */
+    status: string;
+    /** DB instance or cluster identifier. */
+    identifier: string;
+    /** Tags from the describe response; present on the first wait check only. */
+    tags?: Tag[];
+}
+/** Continue waiting with a delay. */
+export interface ContinueWait {
+    shouldContinue: true;
+    delay: {
+        minutes: number;
+    };
+}
+/** Stop waiting. */
+export interface StopWait {
+    shouldContinue: false;
+}
+/** Result of a durable waitStrategy. */
+export type WaitStrategyResult = ContinueWait | StopWait;
+/**
+ * RDS statuses that indicate an in-progress transition.
+ * The handler waits every 5 minutes while the resource remains in one of these states.
+ */
+export declare const TRANSITIONAL_STATUSES: Set<string>;
+/**
+ * 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.
+ */
+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.
+ *
+ * @param value - Value returned from the secret fetcher.
+ * @returns Whether value is a SlackSecret with non-empty token and channel.
+ */
+export declare const isSlackSecret: (value: unknown) => value is SlackSecret;
+/**
+ * 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.
+ */
+export declare const isAutoStartPreventInput: (input: unknown) => input is AutoStartPreventInput;
+/**
+ * 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 }`.
+ */
+export declare const normalizeInput: (input: unknown) => AutoStartPreventInput;
+/**
+ * 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.
+ */
+export declare const matchTag: (params: AutoStartParams, tags?: Tag[]) => boolean;
+/**
+ * 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.
+ */
+export declare const isDbInstanceAutoStart: (detailType: RdsAutoStartEvent["detail-type"], detail: RdsAutoStartDetail) => boolean;
+/**
+ * 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.
+ */
+export declare const isDbClusterAutoStart: (detailType: RdsAutoStartEvent["detail-type"], detail: RdsAutoStartDetail) => boolean;
+/**
+ * Wait strategy while describing until the resource leaves transitional statuses.
+ *
+ * @param state - Latest wait state.
+ * @returns Continue every 5 minutes while transitional; otherwise stop.
+ */
+export declare const waitStrategyUntilStable: (state: WaitState) => WaitStrategyResult;
+/**
+ * Wait strategy after StopDB* until the resource reaches `stopped`.
+ *
+ * @param state - Latest wait state.
+ * @returns Stop when `stopped`; continue while transitional.
+ * @throws When the status is neither stopped nor transitional.
+ */
+export declare const waitStrategyUntilStopped: (state: WaitState) => WaitStrategyResult;
+/**
+ * Decision after the first describe and a successful tag match.
+ */
+export type AfterTagMatchDecision = {
+    kind: 'stop';
+} | {
+    kind: 'no-op';
+    result: NoOpResult;
+} | {
+    kind: 'error';
+    message: string;
+};
+/**
+ * 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.
+ */
+export declare const decideAfterTagMatch: (status: string) => AfterTagMatchDecision;
+/**
+ * Builds the no-op result used when tags do not match.
+ *
+ * @param status - Current resource status.
+ * @returns No-op result with tag mismatch reason.
+ */
+export declare const tagMismatchNoOp: (status: string) => NoOpResult;
+/**
+ * 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.
+ */
+export declare const parseRdsSourceArn: (sourceArn: string) => {
+    region: string;
+    account: string;
+};
+/**
+ * Arguments for the Slack stop-success notification.
+ */
+export interface SlackStopNotificationArgs {
+    channel: string;
+    sourceType: RdsAutoStartDetail['SourceType'];
+    sourceIdentifier: string;
+    account: string;
+    region: string;
+}
+/**
+ * Builds the Slack `chat.postMessage` payload after a successful stop.
+ *
+ * @param args - Channel and resource identity fields.
+ * @returns Arguments suitable for `WebClient.chat.postMessage`.
+ */
+export declare const buildSlackStopNotification: (args: SlackStopNotificationArgs) => {
+    channel: string;
+    attachments: {
+        color: string;
+        pretext: string;
+        fields: {
+            title: string;
+            value: string;
+            short: boolean;
+        }[];
+    }[];
+};
+/**
+ * Builds the success result after StopDB* reached `stopped`.
+ *
+ * @param args - Final status and identity fields.
+ * @returns StoppedResult for the handler return value.
+ */
+export declare const buildStoppedResult: (args: {
+    finalStatus: string;
+    account: string;
+    region: string;
+    identifier: string;
+}) => StoppedResult;

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

@@ -0,0 +1,253 @@
+"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 = void 0;
+/**
+ * RDS statuses that indicate an in-progress transition.
+ * The handler waits every 5 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 every 5 minutes while transitional; otherwise stop.
+ */
+const waitStrategyUntilStable = (state) => {
+    if ((0, exports.isTransitionalStatus)(state.status)) {
+        return { shouldContinue: true, delay: { minutes: 5 } };
+    }
+    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 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: 5 } };
+    }
+    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/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/**\n * RDS statuses that indicate an in-progress transition.\n * The handler waits every 5 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 every 5 minutes while transitional; otherwise stop.\n */\nexport const waitStrategyUntilStable = (state: WaitState): WaitStrategyResult => {\n  if (isTransitionalStatus(state.status)) {\n    return { shouldContinue: true, delay: { minutes: 5 } };\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 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: 5 } };\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/stacks/rds-database-auto-start-prevent-stack.js

@@ -8,7 +8,7 @@ const rds_database_auto_start_preventer_1 = require("../constructs/rds-database-
  * 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.2.6" };
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "rds-database-auto-start-preventer.RDSDatabaseAutoStartPreventStack", version: "0.3.0" };
     /**
      * Creates the stack and the RDSDatabaseAutoStartPreventer construct.
      *

package/package.json

@@ -51,7 +51,7 @@
     "@typescript-eslint/eslint-plugin": "^8",
     "@typescript-eslint/parser": "^8",
     "aws-cdk-lib": "2.232.0",
-    "aws-lambda-secret-fetcher": "^0.5.1",
+    "aws-lambda-secret-fetcher": "^0.7.1",
     "aws-sdk-client-mock": "^4.1.0",
     "aws-sdk-client-mock-jest": "^4.1.0",
     "commit-and-tag-version": "^12",
@@ -62,15 +62,16 @@
     "eslint-plugin-import": "^2.32.0",
     "jest": "^30.4.2",
     "jest-junit": "^17",
-    "jsii": "~5.9.0",
+    "jsii": "6.0.x",
     "jsii-diff": "^1.139.0",
     "jsii-docgen": "^10.5.0",
     "jsii-pacmak": "^1.139.0",
-    "jsii-rosetta": "~5.9.0",
+    "jsii-rosetta": "6.0.x",
     "projen": "^0.101.31",
+    "strict-env-resolver": "^0.6.1",
     "ts-jest": "^29.4.12",
     "ts-node": "^10.9.2",
-    "typescript": "5.9.x"
+    "typescript": "6.0.x"
   },
   "peerDependencies": {
     "aws-cdk-lib": "^2.232.0",
@@ -87,8 +88,7 @@
   },
   "devEngines": {
     "packageManager": {
-      "name": "yarn",
-      "version": "1.22.22",
+      "name": "npm",
       "onFail": "ignore"
     }
   },
@@ -98,7 +98,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "0.2.6",
+  "version": "0.3.0",
   "jest": {
     "coverageProvider": "v8",
     "testMatch": [