@composurecdk/sqs 0.8.6 → 0.9.0

package/dist/commonjs/queue-builder.js

@@ -1,23 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createQueueBuilder = createQueueBuilder;
-const aws_cdk_lib_1 = require("aws-cdk-lib");
 const aws_sqs_1 = require("aws-cdk-lib/aws-sqs");
 const core_1 = require("@composurecdk/core");
 const cloudformation_1 = require("@composurecdk/cloudformation");
 const cloudwatch_1 = require("@composurecdk/cloudwatch");
-const queue_alarms_js_1 = require("./queue-alarms.js");
+const queue_role_js_1 = require("./queue-role.js");
 const defaults_js_1 = require("./defaults.js");
-/**
- * AWS-recommended minimum for `maxReceiveCount` on an SQS redrive
- * policy. A consumer needs a few retries before SQS gives up and
- * forwards the message to the dead-letter queue; anything below this
- * tends to surface as a flood of "poison" messages from transient
- * errors that would have succeeded on retry.
- *
- * @see https://docs.aws.amazon.com/lambda/latest/dg/with-sqs.html
- */
-const RECOMMENDED_MIN_MAX_RECEIVE_COUNT = 5;
+const dlq_defaults_js_1 = require("./dlq-defaults.js");
+const queue_alarm_profiles_js_1 = require("./queue-alarm-profiles.js");
+const queue_alarms_js_1 = require("./queue-alarms.js");
+const queue_validation_js_1 = require("./queue-validation.js");
 class QueueBuilder {
     props = {};
     #customAlarms = [];
@@ -30,67 +23,33 @@ class QueueBuilder {
         target.#customAlarms.push(...this.#customAlarms);
     }
     build(scope, id) {
-        const { recommendedAlarms: alarmConfig, ...queueProps } = this.props;
+        const { queueRole: role = "standard", ...configured } = this.props;
+        const fifo = (0, queue_role_js_1.isFifoRole)(role);
+        const dlq = (0, queue_role_js_1.isDlqRole)(role);
         const mergedProps = {
             ...defaults_js_1.QUEUE_DEFAULTS,
-            ...queueProps,
+            ...(dlq ? dlq_defaults_js_1.DLQ_QUEUE_DEFAULTS : {}),
+            ...configured,
+            ...(fifo ? { fifo: true } : {}),
         };
-        warnIfLowMaxReceiveCount(scope, id, mergedProps);
-        const queue = new aws_sqs_1.Queue(scope, id, mergedProps);
-        const alarms = (0, queue_alarms_js_1.createQueueAlarms)(scope, id, queue, alarmConfig, this.#customAlarms);
+        (0, queue_validation_js_1.validateQueueProps)(scope, id, role, mergedProps);
+        const { recommendedAlarms, ...queueProps } = mergedProps;
+        const queue = new aws_sqs_1.Queue(scope, id, queueProps);
+        const profile = dlq
+            ? (0, queue_alarm_profiles_js_1.dlqAlarmProfile)(scope, mergedProps.retentionPeriod)
+            : queue_alarm_profiles_js_1.PRIMARY_ALARM_PROFILE;
+        const alarms = (0, queue_alarms_js_1.createQueueAlarms)(scope, id, queue, recommendedAlarms, this.#customAlarms, profile);
         return { queue, alarms };
     }
 }
-/**
- * Creates a new {@link IQueueBuilder} for configuring an AWS SQS queue.
- *
- * This is the entry point for defining an SQS queue component. The returned
- * builder exposes every {@link QueueBuilderProps} property as a fluent setter/getter
- * and implements {@link Lifecycle} for use with {@link compose}.
- *
- * @returns A fluent builder for an AWS SQS queue.
- *
- * @example
- * ```ts
- * const orders = createQueueBuilder()
- *   .queueName("orders")
- *   .visibilityTimeout(Duration.seconds(60));
- *
- * // Use standalone:
- * const result = orders.build(stack, "Orders");
- *
- * // Or compose into a system:
- * const system = compose(
- *   { orders, alerts: createTopicBuilder() },
- *   { orders: [], alerts: [] },
- * );
- * ```
- */
-function createQueueBuilder() {
-    return (0, cloudformation_1.taggedBuilder)(QueueBuilder);
-}
-/**
- * Annotates `scope` with a non-fatal warning when a redrive policy is
- * configured with `maxReceiveCount` below the AWS-recommended floor
- * of {@link RECOMMENDED_MIN_MAX_RECEIVE_COUNT}.
- *
- * The builder owns the redrive policy directly, so this is a true
- * check rather than a contextual reminder — the actual configured
- * value is compared. Short-circuits on unresolved tokens so stacks
- * that thread `maxReceiveCount` through CFN parameters aren't spammed.
- */
-function warnIfLowMaxReceiveCount(scope, id, props) {
-    const dlq = props.deadLetterQueue;
-    if (!dlq)
-        return;
-    const maxReceiveCount = dlq.maxReceiveCount;
-    if (aws_cdk_lib_1.Token.isUnresolved(maxReceiveCount))
-        return;
-    if (maxReceiveCount >= RECOMMENDED_MIN_MAX_RECEIVE_COUNT)
-        return;
-    aws_cdk_lib_1.Annotations.of(scope).addWarningV2("@composurecdk/sqs:redrive-low-max-receive-count", `QueueBuilder "${id}": redrive policy maxReceiveCount is ${String(maxReceiveCount)}; ` +
-        `AWS recommends >= ${String(RECOMMENDED_MIN_MAX_RECEIVE_COUNT)} so the consumer ` +
-        `has room to retry before messages hit the dead-letter queue. ` +
-        `See https://docs.aws.amazon.com/lambda/latest/dg/with-sqs.html`);
+// Callers only ever see the overloads above, which return the exact
+// per-role `IQueueBuilder<R>`. The `unknown` here types the implementation
+// body alone (the internal builder carries the full prop surface, not the
+// narrowed per-role one) and is never observed at a call site — so it does
+// not weaken the type of a builder passed to `compose`.
+function createQueueBuilder(role = "standard") {
+    const builder = (0, cloudformation_1.taggedBuilder)(QueueBuilder);
+    builder.queueRole(role);
+    return builder;
 }
 //# sourceMappingURL=queue-builder.js.map

package/dist/commonjs/queue-builder.js.map

@@ -1 +1 @@
-{"version":3,"file":"queue-builder.js","sourceRoot":"","sources":["../../src/queue-builder.ts"],"names":[],"mappings":";;AA0JA,gDAEC;AA5JD,6CAAiD;AAEjD,iDAA0E;AAE1E,6CAAgE;AAChE,iEAAkF;AAClF,yDAAkE;AAElE,uDAAsD;AACtD,+CAA+C;AAE/C;;;;;;;;GAQG;AACH,MAAM,iCAAiC,GAAG,CAAC,CAAC;AA0E5C,MAAM,YAAY;IAChB,KAAK,GAA+B,EAAE,CAAC;IAC9B,aAAa,GAAqC,EAAE,CAAC;IAE9D,QAAQ,CACN,GAAW,EACX,SAAoF;QAEpF,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,SAAS,CAAC,IAAI,mCAAsB,CAAS,GAAG,CAAC,CAAC,CAAC,CAAC;QAC5E,OAAO,IAAI,CAAC;IACd,CAAC;IAED,gCAAgC;IAChC,CAAC,iBAAU,CAAC,CAAC,MAAoB;QAC/B,MAAM,CAAC,aAAa,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC,aAAa,CAAC,CAAC;IACnD,CAAC;IAED,KAAK,CAAC,KAAiB,EAAE,EAAU;QACjC,MAAM,EAAE,iBAAiB,EAAE,WAAW,EAAE,GAAG,UAAU,EAAE,GAAG,IAAI,CAAC,KAAK,CAAC;QAErE,MAAM,WAAW,GAAG;YAClB,GAAG,4BAAc;YACjB,GAAG,UAAU;SACO,CAAC;QAEvB,wBAAwB,CAAC,KAAK,EAAE,EAAE,EAAE,WAAW,CAAC,CAAC;QAEjD,MAAM,KAAK,GAAG,IAAI,eAAK,CAAC,KAAK,EAAE,EAAE,EAAE,WAAW,CAAC,CAAC;QAEhD,MAAM,MAAM,GAAG,IAAA,mCAAiB,EAAC,KAAK,EAAE,EAAE,EAAE,KAAK,EAAE,WAAW,EAAE,IAAI,CAAC,aAAa,CAAC,CAAC;QAEpF,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,CAAC;IAC3B,CAAC;CACF;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,SAAgB,kBAAkB;IAChC,OAAO,IAAA,8BAAa,EAAkC,YAAY,CAAC,CAAC;AACtE,CAAC;AAED;;;;;;;;;GASG;AACH,SAAS,wBAAwB,CAC/B,KAAiB,EACjB,EAAU,EACV,KAAiC;IAEjC,MAAM,GAAG,GAAG,KAAK,CAAC,eAAe,CAAC;IAClC,IAAI,CAAC,GAAG;QAAE,OAAO;IACjB,MAAM,eAAe,GAAG,GAAG,CAAC,eAAe,CAAC;IAC5C,IAAI,mBAAK,CAAC,YAAY,CAAC,eAAe,CAAC;QAAE,OAAO;IAChD,IAAI,eAAe,IAAI,iCAAiC;QAAE,OAAO;IACjE,yBAAW,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC,YAAY,CAChC,iDAAiD,EACjD,iBAAiB,EAAE,wCAAwC,MAAM,CAAC,eAAe,CAAC,IAAI;QACpF,qBAAqB,MAAM,CAAC,iCAAiC,CAAC,mBAAmB;QACjF,+DAA+D;QAC/D,gEAAgE,CACnE,CAAC;AACJ,CAAC"}
+{"version":3,"file":"queue-builder.js","sourceRoot":"","sources":["../../src/queue-builder.ts"],"names":[],"mappings":";;AA0LA,gDAIC;AA7LD,iDAA0E;AAE1E,6CAAgE;AAChE,iEAAkF;AAClF,yDAAkE;AAElE,mDAAwE;AACxE,+CAA+C;AAC/C,uDAAuD;AACvD,uEAAmF;AACnF,uDAAsD;AACtD,+DAA2D;AA+E3D,MAAM,YAAY;IAChB,KAAK,GAAuC,EAAE,CAAC;IACtC,aAAa,GAAqC,EAAE,CAAC;IAE9D,QAAQ,CACN,GAAW,EACX,SAAoF;QAEpF,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,SAAS,CAAC,IAAI,mCAAsB,CAAS,GAAG,CAAC,CAAC,CAAC,CAAC;QAC5E,OAAO,IAAI,CAAC;IACd,CAAC;IAED,gCAAgC;IAChC,CAAC,iBAAU,CAAC,CAAC,MAAoB;QAC/B,MAAM,CAAC,aAAa,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC,aAAa,CAAC,CAAC;IACnD,CAAC;IAED,KAAK,CAAC,KAAiB,EAAE,EAAU;QACjC,MAAM,EAAE,SAAS,EAAE,IAAI,GAAG,UAAU,EAAE,GAAG,UAAU,EAAE,GAAG,IAAI,CAAC,KAAK,CAAC;QACnE,MAAM,IAAI,GAAG,IAAA,0BAAU,EAAC,IAAI,CAAC,CAAC;QAC9B,MAAM,GAAG,GAAG,IAAA,yBAAS,EAAC,IAAI,CAAC,CAAC;QAE5B,MAAM,WAAW,GAAG;YAClB,GAAG,4BAAc;YACjB,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC,oCAAkB,CAAC,CAAC,CAAC,EAAE,CAAC;YAClC,GAAG,UAAU;YACb,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;SAChC,CAAC;QAEF,IAAA,wCAAkB,EAAC,KAAK,EAAE,EAAE,EAAE,IAAI,EAAE,WAAW,CAAC,CAAC;QAEjD,MAAM,EAAE,iBAAiB,EAAE,GAAG,UAAU,EAAE,GAAG,WAAW,CAAC;QACzD,MAAM,KAAK,GAAG,IAAI,eAAK,CAAC,KAAK,EAAE,EAAE,EAAE,UAAU,CAAC,CAAC;QAE/C,MAAM,OAAO,GAAG,GAAG;YACjB,CAAC,CAAC,IAAA,yCAAe,EAAC,KAAK,EAAE,WAAW,CAAC,eAAe,CAAC;YACrD,CAAC,CAAC,+CAAqB,CAAC;QAC1B,MAAM,MAAM,GAAG,IAAA,mCAAiB,EAC9B,KAAK,EACL,EAAE,EACF,KAAK,EACL,iBAAiB,EACjB,IAAI,CAAC,aAAa,EAClB,OAAO,CACR,CAAC;QAEF,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,CAAC;IAC3B,CAAC;CACF;AA0CD,oEAAoE;AACpE,2EAA2E;AAC3E,0EAA0E;AAC1E,2EAA2E;AAC3E,wDAAwD;AACxD,SAAgB,kBAAkB,CAAC,OAAkB,UAAU;IAC7D,MAAM,OAAO,GAAG,IAAA,8BAAa,EAA0C,YAAY,CAAC,CAAC;IACpF,OAA8D,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC;IAChF,OAAO,OAAO,CAAC;AACjB,CAAC"}

package/dist/commonjs/queue-props.d.ts

@@ -0,0 +1,93 @@
+import type { QueueProps } from "aws-cdk-lib/aws-sqs";
+import type { QueueAlarmConfig } from "./queue-alarm-config.js";
+/**
+ * A queue name for a FIFO queue. AWS requires the name of a FIFO queue to
+ * end in `.fifo`, so the constraint is expressed in the type — a
+ * non-conforming literal is a compile error at the call site rather than
+ * a synth failure. (Unresolved tokens are not supported as FIFO queue
+ * names by the CDK `Queue` construct itself.)
+ *
+ * @see https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/FIFO-queues.html
+ */
+export type FifoQueueName = `${string}.fifo`;
+/**
+ * The {@link QueueProps} keys that only have meaning on a FIFO queue.
+ * These are omitted from the standard queue builder's prop surface and
+ * guarded at build time, so a queue with FIFO behaviour is always an
+ * explicit choice of the FIFO-aware entry points.
+ */
+export declare const FIFO_ONLY_PROP_KEYS: readonly ["fifo", "contentBasedDeduplication", "deduplicationScope", "fifoThroughputLimit"];
+/** Union of the FIFO-only {@link QueueProps} keys. */
+export type FifoOnlyPropKey = (typeof FIFO_ONLY_PROP_KEYS)[number];
+/**
+ * Builder-only props every queue builder in this package layers on top
+ * of the CDK {@link QueueProps}. Defined once so the builders and the
+ * shared build core agree on what must be stripped before the props
+ * reach the `Queue` construct.
+ */
+export interface QueueBuilderExtensionProps {
+    /**
+     * Configuration for AWS-recommended CloudWatch alarms.
+     *
+     * By default, the builder creates recommended alarms with sensible
+     * thresholds for every applicable metric — which alarms apply depends
+     * on the queue's role (primary vs. dead-letter). Individual alarms can
+     * be customized or disabled. Set to `false` to disable all alarms.
+     *
+     * No alarm actions are configured by default since notification
+     * methods are user-specific. Access alarms from the build result
+     * or use an `afterBuild` hook to apply actions.
+     *
+     * @see https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Best_Practice_Recommended_Alarms_AWS_Services.html#SQS
+     */
+    recommendedAlarms?: QueueAlarmConfig | false;
+}
+/**
+ * Prop surface of `createQueueBuilder()` / `createQueueBuilder("standard")`:
+ * every CDK {@link QueueProps} property except the FIFO-only ones — a
+ * queue with FIFO behaviour is an explicit role choice
+ * (`createQueueBuilder("fifo")`), not a prop.
+ */
+export interface QueueBuilderProps extends Omit<QueueProps, FifoOnlyPropKey>, QueueBuilderExtensionProps {
+}
+/**
+ * Prop surface of `createQueueBuilder("fifo")`. `fifo` itself is not
+ * settable — the role is the switch — and `queueName` is typed as
+ * {@link FifoQueueName}, so a name missing the AWS-required `.fifo`
+ * suffix is a compile error rather than a synth failure.
+ */
+export interface FifoQueueBuilderProps extends Omit<QueueProps, "fifo" | "queueName">, QueueBuilderExtensionProps {
+    /**
+     * Physical name of the FIFO queue. Must end in `.fifo` (AWS
+     * requirement, enforced by the type and validated at build for
+     * untyped callers). Omit to let CloudFormation generate a valid name.
+     */
+    queueName?: FifoQueueName;
+}
+/**
+ * Prop surface of `createQueueBuilder("dlq")`: the standard surface (no
+ * FIFO-only props — a FIFO dead-letter queue is its own role,
+ * `"fifo-dlq"`) minus `deadLetterQueue`, because a dead-letter queue is
+ * the terminal destination for failed messages and must not carry its
+ * own redrive policy.
+ */
+export type DlqQueueBuilderProps = Omit<QueueBuilderProps, "deadLetterQueue">;
+/**
+ * Prop surface of `createQueueBuilder("fifo-dlq")`: the FIFO surface
+ * (suffix-typed `queueName`, no settable `fifo`) minus
+ * `deadLetterQueue`, for the dead-letter queue of a FIFO source — AWS
+ * requires it to itself be FIFO.
+ */
+export type FifoDlqQueueBuilderProps = Omit<FifoQueueBuilderProps, "deadLetterQueue">;
+/**
+ * Maps each {@link QueueRole} to its prop surface. `createQueueBuilder`
+ * uses this to give every role an exact fluent API — props that don't
+ * apply to a role simply don't exist on its builder type.
+ */
+export interface QueueBuilderPropsByRole {
+    standard: QueueBuilderProps;
+    fifo: FifoQueueBuilderProps;
+    dlq: DlqQueueBuilderProps;
+    "fifo-dlq": FifoDlqQueueBuilderProps;
+}
+//# sourceMappingURL=queue-props.d.ts.map

package/dist/commonjs/queue-props.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"queue-props.d.ts","sourceRoot":"","sources":["../../src/queue-props.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AACtD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAEhE;;;;;;;;GAQG;AACH,MAAM,MAAM,aAAa,GAAG,GAAG,MAAM,OAAO,CAAC;AAE7C;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB,6FAKkB,CAAC;AAEnD,sDAAsD;AACtD,MAAM,MAAM,eAAe,GAAG,CAAC,OAAO,mBAAmB,CAAC,CAAC,MAAM,CAAC,CAAC;AAEnE;;;;;GAKG;AACH,MAAM,WAAW,0BAA0B;IACzC;;;;;;;;;;;;;OAaG;IACH,iBAAiB,CAAC,EAAE,gBAAgB,GAAG,KAAK,CAAC;CAC9C;AAED;;;;;GAKG;AACH,MAAM,WAAW,iBACf,SAAQ,IAAI,CAAC,UAAU,EAAE,eAAe,CAAC,EAAE,0BAA0B;CAAG;AAE1E;;;;;GAKG;AACH,MAAM,WAAW,qBACf,SAAQ,IAAI,CAAC,UAAU,EAAE,MAAM,GAAG,WAAW,CAAC,EAAE,0BAA0B;IAC1E;;;;OAIG;IACH,SAAS,CAAC,EAAE,aAAa,CAAC;CAC3B;AAED;;;;;;GAMG;AACH,MAAM,MAAM,oBAAoB,GAAG,IAAI,CAAC,iBAAiB,EAAE,iBAAiB,CAAC,CAAC;AAE9E;;;;;GAKG;AACH,MAAM,MAAM,wBAAwB,GAAG,IAAI,CAAC,qBAAqB,EAAE,iBAAiB,CAAC,CAAC;AAEtF;;;;GAIG;AACH,MAAM,WAAW,uBAAuB;IACtC,QAAQ,EAAE,iBAAiB,CAAC;IAC5B,IAAI,EAAE,qBAAqB,CAAC;IAC5B,GAAG,EAAE,oBAAoB,CAAC;IAC1B,UAAU,EAAE,wBAAwB,CAAC;CACtC"}

package/dist/commonjs/queue-props.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FIFO_ONLY_PROP_KEYS = void 0;
+/**
+ * The {@link QueueProps} keys that only have meaning on a FIFO queue.
+ * These are omitted from the standard queue builder's prop surface and
+ * guarded at build time, so a queue with FIFO behaviour is always an
+ * explicit choice of the FIFO-aware entry points.
+ */
+exports.FIFO_ONLY_PROP_KEYS = [
+    "fifo",
+    "contentBasedDeduplication",
+    "deduplicationScope",
+    "fifoThroughputLimit",
+];
+//# sourceMappingURL=queue-props.js.map

package/dist/commonjs/queue-props.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"queue-props.js","sourceRoot":"","sources":["../../src/queue-props.ts"],"names":[],"mappings":";;;AAcA;;;;;GAKG;AACU,QAAA,mBAAmB,GAAG;IACjC,MAAM;IACN,2BAA2B;IAC3B,oBAAoB;IACpB,qBAAqB;CAC2B,CAAC"}

package/dist/commonjs/queue-role.d.ts

@@ -0,0 +1,28 @@
+/**
+ * The role a queue plays in its system, chosen at the factory:
+ * `createQueueBuilder(role)`. The role selects the builder's prop
+ * surface (each role exposes only the props that apply to it), its
+ * defaults, its recommended-alarm profile, and its validation:
+ *
+ * - `"standard"` — a primary, consumer-fed standard queue (the
+ *   default). FIFO-only props are excluded.
+ * - `"fifo"` — a primary FIFO queue: `fifo: true` always, `queueName`
+ *   typed to require the `.fifo` suffix, high-throughput coherence
+ *   validated.
+ * - `"dlq"` — a standard dead-letter queue: 14-day retention, inverted
+ *   alarm set (any visible message alerts), no `deadLetterQueue` — a
+ *   DLQ is a terminal destination.
+ * - `"fifo-dlq"` — a FIFO dead-letter queue for a FIFO source (AWS
+ *   requires the DLQ of a FIFO queue to be FIFO): combines the FIFO
+ *   surface with the DLQ defaults and alarms.
+ *
+ * Modeled as data rather than separate factories so that roles compose
+ * (`"fifo-dlq"` is a role, not a fourth entry point) and the choice is
+ * copy-safe, inspectable state on the builder.
+ */
+export type QueueRole = "standard" | "fifo" | "dlq" | "fifo-dlq";
+/** Whether the role builds a FIFO queue. */
+export declare function isFifoRole(role: QueueRole): boolean;
+/** Whether the role builds a dead-letter queue. */
+export declare function isDlqRole(role: QueueRole): boolean;
+//# sourceMappingURL=queue-role.d.ts.map

package/dist/commonjs/queue-role.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"queue-role.d.ts","sourceRoot":"","sources":["../../src/queue-role.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,MAAM,SAAS,GAAG,UAAU,GAAG,MAAM,GAAG,KAAK,GAAG,UAAU,CAAC;AAEjE,4CAA4C;AAC5C,wBAAgB,UAAU,CAAC,IAAI,EAAE,SAAS,GAAG,OAAO,CAEnD;AAED,mDAAmD;AACnD,wBAAgB,SAAS,CAAC,IAAI,EAAE,SAAS,GAAG,OAAO,CAElD"}

package/dist/commonjs/queue-role.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isFifoRole = isFifoRole;
+exports.isDlqRole = isDlqRole;
+/** Whether the role builds a FIFO queue. */
+function isFifoRole(role) {
+    return role === "fifo" || role === "fifo-dlq";
+}
+/** Whether the role builds a dead-letter queue. */
+function isDlqRole(role) {
+    return role === "dlq" || role === "fifo-dlq";
+}
+//# sourceMappingURL=queue-role.js.map

package/dist/commonjs/queue-role.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"queue-role.js","sourceRoot":"","sources":["../../src/queue-role.ts"],"names":[],"mappings":";;AAyBA,gCAEC;AAGD,8BAEC;AARD,4CAA4C;AAC5C,SAAgB,UAAU,CAAC,IAAe;IACxC,OAAO,IAAI,KAAK,MAAM,IAAI,IAAI,KAAK,UAAU,CAAC;AAChD,CAAC;AAED,mDAAmD;AACnD,SAAgB,SAAS,CAAC,IAAe;IACvC,OAAO,IAAI,KAAK,KAAK,IAAI,IAAI,KAAK,UAAU,CAAC;AAC/C,CAAC"}

package/dist/commonjs/queue-validation.d.ts

@@ -0,0 +1,12 @@
+import type { QueueProps } from "aws-cdk-lib/aws-sqs";
+import type { IConstruct } from "constructs";
+import { type QueueRole } from "./queue-role.js";
+/**
+ * Runs every build-time check for a queue in the given role against its
+ * merged props. This is the single validation entry point — each guard
+ * owns its own applicability (self-gating on the role or on the props),
+ * so a new role or a new invariant is entirely a change to this module,
+ * never new branching in the builder.
+ */
+export declare function validateQueueProps(scope: IConstruct, id: string, role: QueueRole, props: Partial<QueueProps>): void;
+//# sourceMappingURL=queue-validation.d.ts.map

package/dist/commonjs/queue-validation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"queue-validation.d.ts","sourceRoot":"","sources":["../../src/queue-validation.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAmB,UAAU,EAAE,MAAM,qBAAqB,CAAC;AACvE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAE7C,OAAO,EAAyB,KAAK,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAExE;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,UAAU,EACjB,EAAE,EAAE,MAAM,EACV,IAAI,EAAE,SAAS,EACf,KAAK,EAAE,OAAO,CAAC,UAAU,CAAC,GACzB,IAAI,CASN"}

package/dist/commonjs/queue-validation.js

@@ -0,0 +1,142 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateQueueProps = validateQueueProps;
+const aws_cdk_lib_1 = require("aws-cdk-lib");
+const aws_sqs_1 = require("aws-cdk-lib/aws-sqs");
+const queue_props_js_1 = require("./queue-props.js");
+const queue_role_js_1 = require("./queue-role.js");
+/**
+ * Runs every build-time check for a queue in the given role against its
+ * merged props. This is the single validation entry point — each guard
+ * owns its own applicability (self-gating on the role or on the props),
+ * so a new role or a new invariant is entirely a change to this module,
+ * never new branching in the builder.
+ */
+function validateQueueProps(scope, id, role, props) {
+    if (!(0, queue_role_js_1.isFifoRole)(role))
+        throwIfFifoPropsOnNonFifoRole(id, role, props);
+    validateFifoQueueProps(id, props);
+    if ((0, queue_role_js_1.isDlqRole)(role)) {
+        throwIfRedriveOnDlqRole(id, role, props);
+    }
+    else {
+        throwIfRedriveTargetFifoMismatch(id, (0, queue_role_js_1.isFifoRole)(role), props.deadLetterQueue);
+        warnIfLowMaxReceiveCount(scope, id, props);
+    }
+}
+/**
+ * AWS-recommended minimum for `maxReceiveCount` on an SQS redrive
+ * policy. A consumer needs a few retries before SQS gives up and
+ * forwards the message to the dead-letter queue; anything below this
+ * tends to surface as a flood of "poison" messages from transient
+ * errors that would have succeeded on retry.
+ *
+ * @see https://docs.aws.amazon.com/lambda/latest/dg/with-sqs.html
+ */
+const RECOMMENDED_MIN_MAX_RECEIVE_COUNT = 5;
+/**
+ * Annotates `scope` with a non-fatal warning when a redrive policy is
+ * configured with `maxReceiveCount` below the AWS-recommended floor
+ * of {@link RECOMMENDED_MIN_MAX_RECEIVE_COUNT}.
+ *
+ * The builder owns the redrive policy directly, so this is a true
+ * check rather than a contextual reminder — the actual configured
+ * value is compared. Short-circuits on unresolved tokens so stacks
+ * that thread `maxReceiveCount` through CFN parameters aren't spammed.
+ */
+function warnIfLowMaxReceiveCount(scope, id, props) {
+    const dlq = props.deadLetterQueue;
+    if (!dlq)
+        return;
+    const maxReceiveCount = dlq.maxReceiveCount;
+    if (aws_cdk_lib_1.Token.isUnresolved(maxReceiveCount))
+        return;
+    if (maxReceiveCount >= RECOMMENDED_MIN_MAX_RECEIVE_COUNT)
+        return;
+    aws_cdk_lib_1.Annotations.of(scope).addWarningV2("@composurecdk/sqs:redrive-low-max-receive-count", `QueueBuilder "${id}": redrive policy maxReceiveCount is ${String(maxReceiveCount)}; ` +
+        `AWS recommends >= ${String(RECOMMENDED_MIN_MAX_RECEIVE_COUNT)} so the consumer ` +
+        `has room to retry before messages hit the dead-letter queue. ` +
+        `See https://docs.aws.amazon.com/lambda/latest/dg/with-sqs.html`);
+}
+/**
+ * Throws when a FIFO-only prop reaches a non-FIFO role — the role's
+ * typed surface omits them, so this catches untyped (JavaScript)
+ * callers and points them at the FIFO roles instead of letting the
+ * queue synth with primary-queue alarm defaults that don't fit a FIFO
+ * queue.
+ */
+function throwIfFifoPropsOnNonFifoRole(id, role, props) {
+    for (const key of queue_props_js_1.FIFO_ONLY_PROP_KEYS) {
+        if (props[key] === undefined)
+            continue;
+        throw new Error(`QueueBuilder "${id}": "${key}" is FIFO-specific and not supported on role ` +
+            `"${role}". Create the builder with ` +
+            `createQueueBuilder("${(0, queue_role_js_1.isDlqRole)(role) ? "fifo-dlq" : "fifo"}") instead.`);
+    }
+}
+/**
+ * Validates the FIFO-specific configuration invariants that would
+ * otherwise surface as a synth or deploy failure:
+ *
+ * - A non-token `queueName` must end in `.fifo` (AWS requirement).
+ * - High-throughput mode (`fifoThroughputLimit: PER_MESSAGE_GROUP_ID`)
+ *   requires `deduplicationScope: MESSAGE_GROUP`.
+ *
+ * No-op unless `props.fifo` is set (the FIFO roles merge `fifo: true`
+ * before calling), so every role calls it unconditionally — the
+ * validator owns both the invariants and their applicability.
+ *
+ * These are configuration errors, not advisory best practice, so they
+ * throw (unlike the `maxReceiveCount` warning).
+ *
+ * @see https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/high-throughput-fifo.html
+ */
+function validateFifoQueueProps(id, props) {
+    const { fifo, queueName, fifoThroughputLimit, deduplicationScope } = props;
+    if (!fifo)
+        return;
+    if (queueName !== undefined && !aws_cdk_lib_1.Token.isUnresolved(queueName) && !queueName.endsWith(".fifo")) {
+        throw new Error(`QueueBuilder "${id}": FIFO queues require a queueName ending in ".fifo"; ` +
+            `got "${queueName}". Omit queueName to let CloudFormation generate one.`);
+    }
+    if (fifoThroughputLimit === aws_sqs_1.FifoThroughputLimit.PER_MESSAGE_GROUP_ID &&
+        deduplicationScope !== aws_sqs_1.DeduplicationScope.MESSAGE_GROUP) {
+        throw new Error(`QueueBuilder "${id}": fifoThroughputLimit=PER_MESSAGE_GROUP_ID (high-throughput ` +
+            `FIFO) requires deduplicationScope=MESSAGE_GROUP. ` +
+            `See https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/high-throughput-fifo.html`);
+    }
+}
+/**
+ * Throws when a queue's redrive target does not match its own FIFO-ness.
+ * AWS requires the dead-letter queue of a FIFO queue to be FIFO and the
+ * dead-letter queue of a standard queue to be standard; the mismatch
+ * otherwise fails at deploy time, after a successful synth.
+ *
+ * @see https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-dead-letter-queues.html
+ */
+function throwIfRedriveTargetFifoMismatch(id, fifo, deadLetterQueue) {
+    if (!deadLetterQueue)
+        return;
+    if (deadLetterQueue.queue.fifo === fifo)
+        return;
+    const [queueKind, targetKind] = fifo ? ["FIFO", "standard"] : ["standard", "FIFO"];
+    throw new Error(`QueueBuilder "${id}": a ${queueKind} queue cannot redrive to the ${targetKind} ` +
+        `dead-letter queue "${deadLetterQueue.queue.node.id}" — AWS requires the ` +
+        `dead-letter queue to match the source queue's type. ` +
+        `See https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-dead-letter-queues.html`);
+}
+/**
+ * Throws when a dead-letter-role queue is given its own
+ * `deadLetterQueue` redrive policy — a DLQ is the terminal destination
+ * for failed messages; a queue that redrives elsewhere is a primary
+ * queue and belongs to the `"standard"` or `"fifo"` role.
+ */
+function throwIfRedriveOnDlqRole(id, role, props) {
+    if (!props.deadLetterQueue)
+        return;
+    throw new Error(`QueueBuilder "${id}": deadLetterQueue is not supported on role "${role}" — a ` +
+        `dead-letter queue is the terminal destination for failed messages. If this queue ` +
+        `needs its own redrive policy it is a primary queue: create the builder with ` +
+        `createQueueBuilder("${(0, queue_role_js_1.isFifoRole)(role) ? "fifo" : "standard"}").`);
+}
+//# sourceMappingURL=queue-validation.js.map

package/dist/commonjs/queue-validation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"queue-validation.js","sourceRoot":"","sources":["../../src/queue-validation.ts"],"names":[],"mappings":"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"}

package/dist/esm/dlq-alarm-defaults.d.ts

@@ -0,0 +1,53 @@
+import { TreatMissingData } from "aws-cdk-lib/aws-cloudwatch";
+/**
+ * Fraction of a dead-letter queue's `retentionPeriod` at which the
+ * `approximateAgeOfOldestMessage` alarm fires by default. Messages older
+ * than this have sat unattended for most of their retention window and
+ * are approaching silent deletion by SQS — the alarm is the last call to
+ * investigate and redrive them.
+ */
+export declare const DLQ_AGE_ALARM_RETENTION_RATIO = 0.75;
+/**
+ * AWS-recommended default alarm configuration for dead-letter queues
+ * built in a dead-letter role (`createQueueBuilder("dlq")` /
+ * `createQueueBuilder("fifo-dlq")`).
+ *
+ * The enabled set inverts relative to a primary queue:
+ *
+ * - `approximateNumberOfMessagesVisible` (> 0) is **on** — any message
+ *   on a DLQ indicates a delivery failure that needs investigation.
+ * - `approximateAgeOfOldestMessage` is **on**, re-framed: nothing
+ *   consumes a DLQ, so instead of "consumers falling behind" it fires
+ *   when the oldest message has used {@link DLQ_AGE_ALARM_RETENTION_RATIO}
+ *   of the queue's `retentionPeriod` — the threshold below is derived
+ *   from the default 14-day retention, and the builder scales it to the
+ *   actual retention period at build time.
+ * - `approximateNumberOfMessagesNotVisible` is **off** — nothing is
+ *   normally in flight on a DLQ. The baseline (shared with
+ *   {@link QUEUE_ALARM_DEFAULTS} via spread) applies if explicitly
+ *   re-enabled.
+ *
+ * @see https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Best_Practice_Recommended_Alarms_AWS_Services.html#SQS
+ */
+export declare const DLQ_ALARM_DEFAULTS: {
+    approximateAgeOfOldestMessage: {
+        threshold: number;
+        evaluationPeriods: number;
+        datapointsToAlarm: number;
+        treatMissingData: TreatMissingData.NOT_BREACHING;
+    };
+    /** 0 — any message on a dead-letter queue is itself the alert. */
+    approximateNumberOfMessagesVisible: {
+        threshold: number;
+        evaluationPeriods: number;
+        datapointsToAlarm: number;
+        treatMissingData: TreatMissingData.NOT_BREACHING;
+    };
+    approximateNumberOfMessagesNotVisible: {
+        threshold: number;
+        evaluationPeriods: number;
+        datapointsToAlarm: number;
+        treatMissingData: TreatMissingData.NOT_BREACHING;
+    };
+};
+//# sourceMappingURL=dlq-alarm-defaults.d.ts.map

package/dist/esm/dlq-alarm-defaults.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dlq-alarm-defaults.d.ts","sourceRoot":"","sources":["../../src/dlq-alarm-defaults.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,4BAA4B,CAAC;AAK9D;;;;;;GAMG;AACH,eAAO,MAAM,6BAA6B,OAAO,CAAC;AAElD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,kBAAkB;;;;;;;IAU7B,kEAAkE;;;;;;;;;;;;;CAOtC,CAAC"}

package/dist/esm/dlq-alarm-defaults.js

@@ -0,0 +1,50 @@
+import { TreatMissingData } from "aws-cdk-lib/aws-cloudwatch";
+import { QUEUE_ALARM_DEFAULTS } from "./queue-alarm-defaults.js";
+import { DLQ_QUEUE_DEFAULTS } from "./dlq-defaults.js";
+/**
+ * Fraction of a dead-letter queue's `retentionPeriod` at which the
+ * `approximateAgeOfOldestMessage` alarm fires by default. Messages older
+ * than this have sat unattended for most of their retention window and
+ * are approaching silent deletion by SQS — the alarm is the last call to
+ * investigate and redrive them.
+ */
+export const DLQ_AGE_ALARM_RETENTION_RATIO = 0.75;
+/**
+ * AWS-recommended default alarm configuration for dead-letter queues
+ * built in a dead-letter role (`createQueueBuilder("dlq")` /
+ * `createQueueBuilder("fifo-dlq")`).
+ *
+ * The enabled set inverts relative to a primary queue:
+ *
+ * - `approximateNumberOfMessagesVisible` (> 0) is **on** — any message
+ *   on a DLQ indicates a delivery failure that needs investigation.
+ * - `approximateAgeOfOldestMessage` is **on**, re-framed: nothing
+ *   consumes a DLQ, so instead of "consumers falling behind" it fires
+ *   when the oldest message has used {@link DLQ_AGE_ALARM_RETENTION_RATIO}
+ *   of the queue's `retentionPeriod` — the threshold below is derived
+ *   from the default 14-day retention, and the builder scales it to the
+ *   actual retention period at build time.
+ * - `approximateNumberOfMessagesNotVisible` is **off** — nothing is
+ *   normally in flight on a DLQ. The baseline (shared with
+ *   {@link QUEUE_ALARM_DEFAULTS} via spread) applies if explicitly
+ *   re-enabled.
+ *
+ * @see https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Best_Practice_Recommended_Alarms_AWS_Services.html#SQS
+ */
+export const DLQ_ALARM_DEFAULTS = {
+    ...QUEUE_ALARM_DEFAULTS,
+    approximateAgeOfOldestMessage: {
+        threshold: DLQ_QUEUE_DEFAULTS.retentionPeriod.toSeconds() * DLQ_AGE_ALARM_RETENTION_RATIO,
+        evaluationPeriods: 1,
+        datapointsToAlarm: 1,
+        treatMissingData: TreatMissingData.NOT_BREACHING,
+    },
+    /** 0 — any message on a dead-letter queue is itself the alert. */
+    approximateNumberOfMessagesVisible: {
+        threshold: 0,
+        evaluationPeriods: 1,
+        datapointsToAlarm: 1,
+        treatMissingData: TreatMissingData.NOT_BREACHING,
+    },
+};
+//# sourceMappingURL=dlq-alarm-defaults.js.map

package/dist/esm/dlq-alarm-defaults.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"dlq-alarm-defaults.js","sourceRoot":"","sources":["../../src/dlq-alarm-defaults.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,4BAA4B,CAAC;AAE9D,OAAO,EAAE,oBAAoB,EAAE,MAAM,2BAA2B,CAAC;AACjE,OAAO,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AAEvD;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,6BAA6B,GAAG,IAAI,CAAC;AAElD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG;IAChC,GAAG,oBAAoB;IAEvB,6BAA6B,EAAE;QAC7B,SAAS,EAAE,kBAAkB,CAAC,eAAe,CAAC,SAAS,EAAE,GAAG,6BAA6B;QACzF,iBAAiB,EAAE,CAAC;QACpB,iBAAiB,EAAE,CAAC;QACpB,gBAAgB,EAAE,gBAAgB,CAAC,aAAa;KACjD;IAED,kEAAkE;IAClE,kCAAkC,EAAE;QAClC,SAAS,EAAE,CAAC;QACZ,iBAAiB,EAAE,CAAC;QACpB,iBAAiB,EAAE,CAAC;QACpB,gBAAgB,EAAE,gBAAgB,CAAC,aAAa;KACjD;CAC2B,CAAC"}

package/dist/esm/dlq-defaults.d.ts

@@ -0,0 +1,19 @@
+import { Duration } from "aws-cdk-lib";
+/**
+ * AWS-recommended defaults layered on top of {@link QUEUE_DEFAULTS} for
+ * queues built in a dead-letter role (`createQueueBuilder("dlq")` /
+ * `createQueueBuilder("fifo-dlq")`).
+ */
+export declare const DLQ_QUEUE_DEFAULTS: {
+    /**
+     * 14 days — the SQS maximum. A dead-letter queue exists to give
+     * operators a window to investigate and redrive failed messages, so
+     * maximizing that window is the point; the 4-day CDK default would let
+     * messages expire before anyone notices them. The Well-Architected
+     * Reliability Pillar calls for retaining failed messages long enough
+     * to analyse and reprocess them.
+     * @see https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-dead-letter-queues.html
+     */
+    retentionPeriod: Duration;
+};
+//# sourceMappingURL=dlq-defaults.d.ts.map

package/dist/esm/dlq-defaults.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dlq-defaults.d.ts","sourceRoot":"","sources":["../../src/dlq-defaults.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAGvC;;;;GAIG;AACH,eAAO,MAAM,kBAAkB;IAC7B;;;;;;;;OAQG;;CAE0B,CAAC"}

package/dist/esm/dlq-defaults.js

@@ -0,0 +1,19 @@
+import { Duration } from "aws-cdk-lib";
+/**
+ * AWS-recommended defaults layered on top of {@link QUEUE_DEFAULTS} for
+ * queues built in a dead-letter role (`createQueueBuilder("dlq")` /
+ * `createQueueBuilder("fifo-dlq")`).
+ */
+export const DLQ_QUEUE_DEFAULTS = {
+    /**
+     * 14 days — the SQS maximum. A dead-letter queue exists to give
+     * operators a window to investigate and redrive failed messages, so
+     * maximizing that window is the point; the 4-day CDK default would let
+     * messages expire before anyone notices them. The Well-Architected
+     * Reliability Pillar calls for retaining failed messages long enough
+     * to analyse and reprocess them.
+     * @see https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-dead-letter-queues.html
+     */
+    retentionPeriod: Duration.days(14),
+};
+//# sourceMappingURL=dlq-defaults.js.map

package/dist/esm/dlq-defaults.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"dlq-defaults.js","sourceRoot":"","sources":["../../src/dlq-defaults.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAGvC;;;;GAIG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG;IAChC;;;;;;;;OAQG;IACH,eAAe,EAAE,QAAQ,CAAC,IAAI,CAAC,EAAE,CAAC;CACL,CAAC"}