@composurecdk/sqs 0.8.7 → 0.9.0

package/dist/esm/queue-builder.d.ts

@@ -4,31 +4,12 @@ import { type IConstruct } from "constructs";
 import { COPY_STATE, type Lifecycle } from "@composurecdk/core";
 import { type ITaggedBuilder } from "@composurecdk/cloudformation";
 import { AlarmDefinitionBuilder } from "@composurecdk/cloudwatch";
-import type { QueueAlarmConfig } from "./queue-alarm-config.js";
+import type { QueueBuilderExtensionProps, QueueBuilderPropsByRole } from "./queue-props.js";
+import { type QueueRole } from "./queue-role.js";
 /**
- * Configuration properties for the SQS queue builder.
- *
- * Extends the CDK {@link QueueProps} with additional builder-specific options.
- */
-export interface QueueBuilderProps extends QueueProps {
-    /**
-     * Configuration for AWS-recommended CloudWatch alarms.
-     *
-     * By default, the builder creates recommended alarms with sensible
-     * thresholds for every applicable metric. 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;
-}
-/**
- * The build output of an {@link IQueueBuilder}. Contains the CDK constructs
- * created during {@link Lifecycle.build}, keyed by role.
+ * The build output of {@link createQueueBuilder}, identical across every
+ * {@link QueueRole}. Contains the CDK constructs created during
+ * {@link Lifecycle.build}, keyed by role.
  */
 export interface QueueBuilderResult {
     /** The SQS queue construct created by the builder. */
@@ -37,8 +18,8 @@ export interface QueueBuilderResult {
      * CloudWatch alarms created for the queue, keyed by alarm name.
      *
      * Includes both AWS-recommended alarms and any custom alarms added
-     * via {@link IQueueBuilder.addAlarm}. Access individual alarms
-     * by key (e.g., `result.alarms.approximateAgeOfOldestMessage`).
+     * via `addAlarm`. Access individual alarms by key (e.g.,
+     * `result.alarms.approximateAgeOfOldestMessage`).
      *
      * No alarm actions are configured — apply them via the result or an
      * `afterBuild` hook.
@@ -48,21 +29,37 @@ export interface QueueBuilderResult {
     alarms: Record<string, Alarm>;
 }
 /**
- * A fluent builder for configuring and creating an AWS SQS queue.
+ * The builder's full internal prop store: the CDK {@link QueueProps},
+ * the builder-only extensions, and the queue's role. The public surface
+ * per role is the narrowed view in {@link QueueBuilderPropsByRole} —
+ * this type exists so one `QueueBuilder` implementation can back every
+ * role.
+ */
+interface InternalQueueBuilderProps extends QueueProps, QueueBuilderExtensionProps {
+    /**
+     * The queue's role, set by `createQueueBuilder(role)`. Stored as a
+     * prop (not a private field) so it is data: `.copy()` preserves it
+     * for free and it is inspectable on the builder.
+     */
+    queueRole?: QueueRole;
+}
+/**
+ * A fluent builder for configuring and creating an AWS SQS queue in a
+ * given {@link QueueRole}.
  *
- * Each configuration property from the CDK {@link QueueProps} is exposed
- * as an overloaded method: call with a value to set it (returns the builder
+ * Each configuration property applicable to the role is exposed as an
+ * overloaded method: call with a value to set it (returns the builder
  * for chaining), or call with no arguments to read the current value.
+ * The prop surface is exact per role — FIFO-only props exist only on
+ * the FIFO roles, and `deadLetterQueue` does not exist on the
+ * dead-letter roles.
  *
- * The builder implements {@link Lifecycle}, so it can be used directly as a
- * component in a {@link compose | composed system}. When built, it creates
- * an SQS queue with the configured properties and returns a
+ * The builder implements {@link Lifecycle}, so it can be used directly as
+ * a component in a {@link compose | composed system}. When built, it
+ * creates an SQS queue with the configured properties, the role's
+ * defaults, and the role's recommended CloudWatch alarms, returning a
  * {@link QueueBuilderResult}.
  *
- * The builder also creates AWS-recommended CloudWatch alarms by default.
- * Alarms can be customized or disabled via the `recommendedAlarms` property.
- * Custom alarms can be added via the {@link addAlarm} method.
- *
  * @see https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_sqs.Queue.html
  *
  * @example
@@ -70,42 +67,62 @@ export interface QueueBuilderResult {
  * const orders = createQueueBuilder()
  *   .queueName("orders")
  *   .visibilityTimeout(Duration.seconds(60));
+ *
+ * const orderEvents = createQueueBuilder("fifo")
+ *   .queueName("order-events.fifo")
+ *   .contentBasedDeduplication(true);
+ *
+ * const ordersDlq = createQueueBuilder("dlq").queueName("orders-dlq");
  * ```
  */
-export type IQueueBuilder = ITaggedBuilder<QueueBuilderProps, QueueBuilder>;
+export type IQueueBuilder<R extends QueueRole = "standard"> = ITaggedBuilder<QueueBuilderPropsByRole[R], QueueBuilder>;
 declare class QueueBuilder implements Lifecycle<QueueBuilderResult> {
     #private;
-    props: Partial<QueueBuilderProps>;
+    props: Partial<InternalQueueBuilderProps>;
     addAlarm(key: string, configure: (alarm: AlarmDefinitionBuilder<IQueue>) => AlarmDefinitionBuilder<IQueue>): this;
     /** @internal — see ADR-0005. */
     [COPY_STATE](target: QueueBuilder): void;
     build(scope: IConstruct, id: string): QueueBuilderResult;
 }
 /**
- * Creates a new {@link IQueueBuilder} for configuring an AWS SQS queue.
+ * Creates a new {@link IQueueBuilder} for configuring an AWS SQS queue
+ * in the given role.
  *
- * 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}.
+ * This is the single entry point for every queue type. The role — see
+ * {@link QueueRole} for the full catalogue — selects the builder's
+ * typed prop surface, its Well-Architected defaults, its
+ * recommended-alarm profile, and its build-time validation:
  *
- * @returns A fluent builder for an AWS SQS queue.
+ * - `createQueueBuilder()` / `createQueueBuilder("standard")` — primary
+ *   standard queue.
+ * - `createQueueBuilder("fifo")` — primary FIFO queue.
+ * - `createQueueBuilder("dlq")` — standard dead-letter queue.
+ * - `createQueueBuilder("fifo-dlq")` — FIFO dead-letter queue (the DLQ
+ *   for a FIFO source must itself be FIFO).
  *
- * @example
- * ```ts
- * const orders = createQueueBuilder()
- *   .queueName("orders")
- *   .visibilityTimeout(Duration.seconds(60));
+ * The returned builder exposes every prop applicable to the role as a
+ * fluent setter/getter and implements {@link Lifecycle} for use with
+ * {@link compose}.
  *
- * // Use standalone:
- * const result = orders.build(stack, "Orders");
+ * @param role - The queue's role. Defaults to `"standard"`.
+ * @returns A fluent builder for an AWS SQS queue in that role.
  *
- * // Or compose into a system:
+ * @example
+ * ```ts
+ * // A FIFO primary queue redriving to a FIFO dead-letter queue:
  * const system = compose(
- *   { orders, alerts: createTopicBuilder() },
- *   { orders: [], alerts: [] },
+ *   {
+ *     orderEventsDlq: createQueueBuilder("fifo-dlq").queueName("order-events-dlq.fifo"),
+ *     orderEvents: createQueueBuilder("fifo")
+ *       .queueName("order-events.fifo")
+ *       .contentBasedDeduplication(true)
+ *       .deadLetterQueue(ref("orderEventsDlq", (r) => ({ queue: r.queue, maxReceiveCount: 5 }))),
+ *   },
+ *   { orderEventsDlq: [], orderEvents: ["orderEventsDlq"] },
  * );
  * ```
  */
 export declare function createQueueBuilder(): IQueueBuilder;
+export declare function createQueueBuilder<R extends QueueRole>(role: R): IQueueBuilder<R>;
 export {};
 //# sourceMappingURL=queue-builder.d.ts.map

package/dist/esm/queue-builder.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"queue-builder.d.ts","sourceRoot":"","sources":["../../src/queue-builder.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,KAAK,EAAE,MAAM,4BAA4B,CAAC;AACxD,OAAO,EAAE,KAAK,MAAM,EAAE,KAAK,EAAE,KAAK,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAC1E,OAAO,EAAE,KAAK,UAAU,EAAE,MAAM,YAAY,CAAC;AAC7C,OAAO,EAAE,UAAU,EAAE,KAAK,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAChE,OAAO,EAAE,KAAK,cAAc,EAAiB,MAAM,8BAA8B,CAAC;AAClF,OAAO,EAAE,sBAAsB,EAAE,MAAM,0BAA0B,CAAC;AAClE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAehE;;;;GAIG;AACH,MAAM,WAAW,iBAAkB,SAAQ,UAAU;IACnD;;;;;;;;;;;;OAYG;IACH,iBAAiB,CAAC,EAAE,gBAAgB,GAAG,KAAK,CAAC;CAC9C;AAED;;;GAGG;AACH,MAAM,WAAW,kBAAkB;IACjC,sDAAsD;IACtD,KAAK,EAAE,KAAK,CAAC;IAEb;;;;;;;;;;;OAWG;IACH,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;CAC/B;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,MAAM,MAAM,aAAa,GAAG,cAAc,CAAC,iBAAiB,EAAE,YAAY,CAAC,CAAC;AAE5E,cAAM,YAAa,YAAW,SAAS,CAAC,kBAAkB,CAAC;;IACzD,KAAK,EAAE,OAAO,CAAC,iBAAiB,CAAC,CAAM;IAGvC,QAAQ,CACN,GAAG,EAAE,MAAM,EACX,SAAS,EAAE,CAAC,KAAK,EAAE,sBAAsB,CAAC,MAAM,CAAC,KAAK,sBAAsB,CAAC,MAAM,CAAC,GACnF,IAAI;IAKP,gCAAgC;IAChC,CAAC,UAAU,CAAC,CAAC,MAAM,EAAE,YAAY,GAAG,IAAI;IAIxC,KAAK,CAAC,KAAK,EAAE,UAAU,EAAE,EAAE,EAAE,MAAM,GAAG,kBAAkB;CAgBzD;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,kBAAkB,IAAI,aAAa,CAElD"}
+{"version":3,"file":"queue-builder.d.ts","sourceRoot":"","sources":["../../src/queue-builder.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,KAAK,EAAE,MAAM,4BAA4B,CAAC;AACxD,OAAO,EAAE,KAAK,MAAM,EAAE,KAAK,EAAE,KAAK,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAC1E,OAAO,EAAE,KAAK,UAAU,EAAE,MAAM,YAAY,CAAC;AAC7C,OAAO,EAAE,UAAU,EAAE,KAAK,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAChE,OAAO,EAAE,KAAK,cAAc,EAAiB,MAAM,8BAA8B,CAAC;AAClF,OAAO,EAAE,sBAAsB,EAAE,MAAM,0BAA0B,CAAC;AAClE,OAAO,KAAK,EAAE,0BAA0B,EAAE,uBAAuB,EAAE,MAAM,kBAAkB,CAAC;AAC5F,OAAO,EAAyB,KAAK,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAOxE;;;;GAIG;AACH,MAAM,WAAW,kBAAkB;IACjC,sDAAsD;IACtD,KAAK,EAAE,KAAK,CAAC;IAEb;;;;;;;;;;;OAWG;IACH,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;CAC/B;AAED;;;;;;GAMG;AACH,UAAU,yBAA0B,SAAQ,UAAU,EAAE,0BAA0B;IAChF;;;;OAIG;IACH,SAAS,CAAC,EAAE,SAAS,CAAC;CACvB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,MAAM,MAAM,aAAa,CAAC,CAAC,SAAS,SAAS,GAAG,UAAU,IAAI,cAAc,CAC1E,uBAAuB,CAAC,CAAC,CAAC,EAC1B,YAAY,CACb,CAAC;AAEF,cAAM,YAAa,YAAW,SAAS,CAAC,kBAAkB,CAAC;;IACzD,KAAK,EAAE,OAAO,CAAC,yBAAyB,CAAC,CAAM;IAG/C,QAAQ,CACN,GAAG,EAAE,MAAM,EACX,SAAS,EAAE,CAAC,KAAK,EAAE,sBAAsB,CAAC,MAAM,CAAC,KAAK,sBAAsB,CAAC,MAAM,CAAC,GACnF,IAAI;IAKP,gCAAgC;IAChC,CAAC,UAAU,CAAC,CAAC,MAAM,EAAE,YAAY,GAAG,IAAI;IAIxC,KAAK,CAAC,KAAK,EAAE,UAAU,EAAE,EAAE,EAAE,MAAM,GAAG,kBAAkB;CA+BzD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,wBAAgB,kBAAkB,IAAI,aAAa,CAAC;AACpD,wBAAgB,kBAAkB,CAAC,CAAC,SAAS,SAAS,EAAE,IAAI,EAAE,CAAC,GAAG,aAAa,CAAC,CAAC,CAAC,CAAC"}

package/dist/esm/queue-builder.js

@@ -1,20 +1,13 @@
-import { Annotations, Token } from "aws-cdk-lib";
 import { Queue } from "aws-cdk-lib/aws-sqs";
 import { COPY_STATE } from "@composurecdk/core";
 import { taggedBuilder } from "@composurecdk/cloudformation";
 import { AlarmDefinitionBuilder } from "@composurecdk/cloudwatch";
-import { createQueueAlarms } from "./queue-alarms.js";
+import { isDlqRole, isFifoRole } from "./queue-role.js";
 import { QUEUE_DEFAULTS } from "./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;
+import { DLQ_QUEUE_DEFAULTS } from "./dlq-defaults.js";
+import { dlqAlarmProfile, PRIMARY_ALARM_PROFILE } from "./queue-alarm-profiles.js";
+import { createQueueAlarms } from "./queue-alarms.js";
+import { validateQueueProps } from "./queue-validation.js";
 class QueueBuilder {
     props = {};
     #customAlarms = [];
@@ -27,67 +20,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 = isFifoRole(role);
+        const dlq = isDlqRole(role);
         const mergedProps = {
             ...QUEUE_DEFAULTS,
-            ...queueProps,
+            ...(dlq ? DLQ_QUEUE_DEFAULTS : {}),
+            ...configured,
+            ...(fifo ? { fifo: true } : {}),
         };
-        warnIfLowMaxReceiveCount(scope, id, mergedProps);
-        const queue = new Queue(scope, id, mergedProps);
-        const alarms = createQueueAlarms(scope, id, queue, alarmConfig, this.#customAlarms);
+        validateQueueProps(scope, id, role, mergedProps);
+        const { recommendedAlarms, ...queueProps } = mergedProps;
+        const queue = new Queue(scope, id, queueProps);
+        const profile = dlq
+            ? dlqAlarmProfile(scope, mergedProps.retentionPeriod)
+            : PRIMARY_ALARM_PROFILE;
+        const alarms = 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: [] },
- * );
- * ```
- */
-export function createQueueBuilder() {
-    return 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 (Token.isUnresolved(maxReceiveCount))
-        return;
-    if (maxReceiveCount >= RECOMMENDED_MIN_MAX_RECEIVE_COUNT)
-        return;
-    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`.
+export function createQueueBuilder(role = "standard") {
+    const builder = taggedBuilder(QueueBuilder);
+    builder.queueRole(role);
+    return builder;
 }
 //# sourceMappingURL=queue-builder.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"queue-builder.js","sourceRoot":"","sources":["../../src/queue-builder.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AAEjD,OAAO,EAAe,KAAK,EAAmB,MAAM,qBAAqB,CAAC;AAE1E,OAAO,EAAE,UAAU,EAAkB,MAAM,oBAAoB,CAAC;AAChE,OAAO,EAAuB,aAAa,EAAE,MAAM,8BAA8B,CAAC;AAClF,OAAO,EAAE,sBAAsB,EAAE,MAAM,0BAA0B,CAAC;AAElE,OAAO,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AACtD,OAAO,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;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,sBAAsB,CAAS,GAAG,CAAC,CAAC,CAAC,CAAC;QAC5E,OAAO,IAAI,CAAC;IACd,CAAC;IAED,gCAAgC;IAChC,CAAC,UAAU,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,cAAc;YACjB,GAAG,UAAU;SACO,CAAC;QAEvB,wBAAwB,CAAC,KAAK,EAAE,EAAE,EAAE,WAAW,CAAC,CAAC;QAEjD,MAAM,KAAK,GAAG,IAAI,KAAK,CAAC,KAAK,EAAE,EAAE,EAAE,WAAW,CAAC,CAAC;QAEhD,MAAM,MAAM,GAAG,iBAAiB,CAAC,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,MAAM,UAAU,kBAAkB;IAChC,OAAO,aAAa,CAAkC,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,KAAK,CAAC,YAAY,CAAC,eAAe,CAAC;QAAE,OAAO;IAChD,IAAI,eAAe,IAAI,iCAAiC;QAAE,OAAO;IACjE,WAAW,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":"AACA,OAAO,EAAe,KAAK,EAAmB,MAAM,qBAAqB,CAAC;AAE1E,OAAO,EAAE,UAAU,EAAkB,MAAM,oBAAoB,CAAC;AAChE,OAAO,EAAuB,aAAa,EAAE,MAAM,8BAA8B,CAAC;AAClF,OAAO,EAAE,sBAAsB,EAAE,MAAM,0BAA0B,CAAC;AAElE,OAAO,EAAE,SAAS,EAAE,UAAU,EAAkB,MAAM,iBAAiB,CAAC;AACxE,OAAO,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAC/C,OAAO,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AACvD,OAAO,EAAE,eAAe,EAAE,qBAAqB,EAAE,MAAM,2BAA2B,CAAC;AACnF,OAAO,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AACtD,OAAO,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;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,sBAAsB,CAAS,GAAG,CAAC,CAAC,CAAC,CAAC;QAC5E,OAAO,IAAI,CAAC;IACd,CAAC;IAED,gCAAgC;IAChC,CAAC,UAAU,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,UAAU,CAAC,IAAI,CAAC,CAAC;QAC9B,MAAM,GAAG,GAAG,SAAS,CAAC,IAAI,CAAC,CAAC;QAE5B,MAAM,WAAW,GAAG;YAClB,GAAG,cAAc;YACjB,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC,kBAAkB,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,kBAAkB,CAAC,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,KAAK,CAAC,KAAK,EAAE,EAAE,EAAE,UAAU,CAAC,CAAC;QAE/C,MAAM,OAAO,GAAG,GAAG;YACjB,CAAC,CAAC,eAAe,CAAC,KAAK,EAAE,WAAW,CAAC,eAAe,CAAC;YACrD,CAAC,CAAC,qBAAqB,CAAC;QAC1B,MAAM,MAAM,GAAG,iBAAiB,CAC9B,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,MAAM,UAAU,kBAAkB,CAAC,OAAkB,UAAU;IAC7D,MAAM,OAAO,GAAG,aAAa,CAA0C,YAAY,CAAC,CAAC;IACpF,OAA8D,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC;IAChF,OAAO,OAAO,CAAC;AACjB,CAAC"}

package/dist/esm/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/esm/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/esm/queue-props.js

@@ -0,0 +1,13 @@
+/**
+ * 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 const FIFO_ONLY_PROP_KEYS = [
+    "fifo",
+    "contentBasedDeduplication",
+    "deduplicationScope",
+    "fifoThroughputLimit",
+];
+//# sourceMappingURL=queue-props.js.map

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

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

package/dist/esm/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/esm/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/esm/queue-role.js

@@ -0,0 +1,9 @@
+/** Whether the role builds a FIFO queue. */
+export function isFifoRole(role) {
+    return role === "fifo" || role === "fifo-dlq";
+}
+/** Whether the role builds a dead-letter queue. */
+export function isDlqRole(role) {
+    return role === "dlq" || role === "fifo-dlq";
+}
+//# sourceMappingURL=queue-role.js.map

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

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

package/dist/esm/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/esm/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/esm/queue-validation.js

@@ -0,0 +1,139 @@
+import { Annotations, Token } from "aws-cdk-lib";
+import { DeduplicationScope, FifoThroughputLimit } from "aws-cdk-lib/aws-sqs";
+import { FIFO_ONLY_PROP_KEYS } from "./queue-props.js";
+import { isDlqRole, isFifoRole } 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 function validateQueueProps(scope, id, role, props) {
+    if (!isFifoRole(role))
+        throwIfFifoPropsOnNonFifoRole(id, role, props);
+    validateFifoQueueProps(id, props);
+    if (isDlqRole(role)) {
+        throwIfRedriveOnDlqRole(id, role, props);
+    }
+    else {
+        throwIfRedriveTargetFifoMismatch(id, 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 (Token.isUnresolved(maxReceiveCount))
+        return;
+    if (maxReceiveCount >= RECOMMENDED_MIN_MAX_RECEIVE_COUNT)
+        return;
+    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 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("${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 && !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 === FifoThroughputLimit.PER_MESSAGE_GROUP_ID &&
+        deduplicationScope !== 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("${isFifoRole(role) ? "fifo" : "standard"}").`);
+}
+//# sourceMappingURL=queue-validation.js.map