@remit/sqs-client 0.0.15 → 0.0.17

package/dist/attempt-budget.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Reads a handler's redelivery budget from the environment. CDK derives every
+ * `*_MAX_ATTEMPTS` var from the corresponding queue's own `MAX_RECEIVE_COUNT`
+ * (`infra/stacks/dev/stacks/remit-queue-stack.ts`, `deploy/vps/queues.json`)
+ * so a worker's idea of "last attempt" cannot drift from the redrive policy
+ * that actually dead-letters the record (issue #1270). SQS's
+ * `ApproximateReceiveCount` is the source of truth for how many times a record
+ * has been delivered; once it reaches this budget the current invocation is
+ * the last attempt, and the handler resolves exhaustion itself instead of
+ * letting the record dead-letter undiagnosed. The fallback keeps an
+ * environment that never injects the var — local dev, unit tests — behaving
+ * like production.
+ */
+export declare const attemptBudget: (envName: string, fallback: number, processEnv?: NodeJS.ProcessEnv) => number;

package/{src/attempt-budget.ts → dist/attempt-budget.js}

@@ -11,14 +11,12 @@
  * environment that never injects the var — local dev, unit tests — behaving
  * like production.
  */
-export const attemptBudget = (
-	envName: string,
-	fallback: number,
-	processEnv: NodeJS.ProcessEnv = process.env,
-): number => {
-	const raw = processEnv[envName];
-	if (!raw) return fallback;
-	const parsed = Number.parseInt(raw, 10);
-	if (!Number.isFinite(parsed) || parsed <= 0) return fallback;
-	return parsed;
+export const attemptBudget = (envName, fallback, processEnv = process.env) => {
+    const raw = processEnv[envName];
+    if (!raw)
+        return fallback;
+    const parsed = Number.parseInt(raw, 10);
+    if (!Number.isFinite(parsed) || parsed <= 0)
+        return fallback;
+    return parsed;
 };

package/{src/heartbeat.ts → dist/heartbeat.d.ts}

@@ -1,6 +1,3 @@
-import { readdir, rm, writeFile } from "node:fs/promises";
-import { basename, dirname, join } from "node:path";
-
 /**
  * Poll-loop liveness as a file (docs/design/standalone-observability.md, D1).
  *
@@ -25,9 +22,6 @@ import { basename, dirname, join } from "node:path";
  * each cycle is healthy here.
  */
 export type Heartbeat = () => Promise<void>;
-
-const noHeartbeat: Heartbeat = () => Promise.resolve();
-
 /**
  * `WORKER_HEARTBEAT_PREFIX` is set per worker service by the self-host compose
  * stack, which owns both the path and the volume it lands on; each loop appends
@@ -38,31 +32,11 @@ const noHeartbeat: Heartbeat = () => Promise.resolve();
  * stat-able: an empty rewrite is not guaranteed to advance mtime when the file
  * is already zero-length, and mtime is the whole signal.
  */
-export const createHeartbeat = (
-	name: string,
-	prefix: string | undefined = process.env.WORKER_HEARTBEAT_PREFIX,
-): Heartbeat => {
-	if (!prefix) return noHeartbeat;
-	const filePath = `${prefix}.${name}`;
-	return () => writeFile(filePath, `${new Date().toISOString()}\n`);
-};
-
+export declare const createHeartbeat: (name: string, prefix?: string | undefined) => Heartbeat;
 /**
  * Drops the files this service left on the volume, before its loops start
  * writing again. The healthcheck fails on the oldest file it finds, so a queue
  * a later version stops polling would otherwise leave a file nobody rewrites,
  * and a worker that can never report healthy again.
  */
-export const clearHeartbeats = async (
-	prefix: string | undefined = process.env.WORKER_HEARTBEAT_PREFIX,
-): Promise<void> => {
-	if (!prefix) return;
-	const directory = dirname(prefix);
-	const owned = `${basename(prefix)}.`;
-	const names = await readdir(directory);
-	await Promise.all(
-		names
-			.filter((name) => name.startsWith(owned))
-			.map((name) => rm(join(directory, name))),
-	);
-};
+export declare const clearHeartbeats: (prefix?: string | undefined) => Promise<void>;

package/dist/heartbeat.js

@@ -0,0 +1,35 @@
+import { readdir, rm, writeFile } from "node:fs/promises";
+import { basename, dirname, join } from "node:path";
+const noHeartbeat = () => Promise.resolve();
+/**
+ * `WORKER_HEARTBEAT_PREFIX` is set per worker service by the self-host compose
+ * stack, which owns both the path and the volume it lands on; each loop appends
+ * its own queue name. Unset — the Lambda deployment, where the poller does not
+ * run at all, and any local process — writes nothing.
+ *
+ * The written value is the timestamp itself, so the file is readable as well as
+ * stat-able: an empty rewrite is not guaranteed to advance mtime when the file
+ * is already zero-length, and mtime is the whole signal.
+ */
+export const createHeartbeat = (name, prefix = process.env.WORKER_HEARTBEAT_PREFIX) => {
+    if (!prefix)
+        return noHeartbeat;
+    const filePath = `${prefix}.${name}`;
+    return () => writeFile(filePath, `${new Date().toISOString()}\n`);
+};
+/**
+ * Drops the files this service left on the volume, before its loops start
+ * writing again. The healthcheck fails on the oldest file it finds, so a queue
+ * a later version stops polling would otherwise leave a file nobody rewrites,
+ * and a worker that can never report healthy again.
+ */
+export const clearHeartbeats = async (prefix = process.env.WORKER_HEARTBEAT_PREFIX) => {
+    if (!prefix)
+        return;
+    const directory = dirname(prefix);
+    const owned = `${basename(prefix)}.`;
+    const names = await readdir(directory);
+    await Promise.all(names
+        .filter((name) => name.startsWith(owned))
+        .map((name) => rm(join(directory, name))));
+};

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export interface SqsStaticCredentials {
+    accessKeyId: string;
+    secretAccessKey: string;
+}
+export declare function resolveSqsCredentials(env?: NodeJS.ProcessEnv): SqsStaticCredentials | undefined;

package/{src/index.ts → dist/index.js}

@@ -1,23 +1,14 @@
-export interface SqsStaticCredentials {
-	accessKeyId: string;
-	secretAccessKey: string;
-}
-
 // On AWS, SQS shares the process-wide credential chain (AWS_ACCESS_KEY_ID / IAM
 // role). On Scaleway, Messaging & Queuing has its own credential pair, distinct
 // from the Object Storage (S3) keys, so it can't ride the default chain — the app
 // is handed SQS_ACCESS_KEY_ID / SQS_SECRET_ACCESS_KEY and must feed them to the
 // SQS client explicitly. When they are absent (AWS, or local ElasticMQ), returning
 // undefined lets the SDK fall back to its default credential provider chain.
-export function resolveSqsCredentials(
-	env: NodeJS.ProcessEnv = process.env,
-): SqsStaticCredentials | undefined {
-	const accessKeyId = env.SQS_ACCESS_KEY_ID;
-	const secretAccessKey = env.SQS_SECRET_ACCESS_KEY;
-
-	if (accessKeyId && secretAccessKey) {
-		return { accessKeyId, secretAccessKey };
-	}
-
-	return undefined;
+export function resolveSqsCredentials(env = process.env) {
+    const accessKeyId = env.SQS_ACCESS_KEY_ID;
+    const secretAccessKey = env.SQS_SECRET_ACCESS_KEY;
+    if (accessKeyId && secretAccessKey) {
+        return { accessKeyId, secretAccessKey };
+    }
+    return undefined;
 }

package/dist/poller.d.ts

@@ -0,0 +1,54 @@
+import type { SQSHandler } from "aws-lambda";
+import { type Heartbeat } from "./heartbeat.js";
+/**
+ * Production queue poller — the non-e2e counterpart of the per-worker
+ * `e2e-processor-shim.ts` scripts. It receives from an SQS-compatible
+ * endpoint (real SQS or ElasticMQ), wraps each batch in an `SQSEvent`, and
+ * invokes the exact production Lambda `handler`, honouring
+ * `batchItemFailures` the way the SQS service does: delete what succeeded,
+ * leave failures for redelivery.
+ *
+ * Unlike the e2e shim (one child process per queue, via `node:cluster`),
+ * this runs every target queue as a concurrent poll loop inside a single
+ * process — the right shape for a container whose only job is "poll these
+ * queues, invoke this handler, exit on SIGTERM."
+ */
+export interface QueuePollerLog {
+    info: (fields: Record<string, unknown>, message: string) => void;
+    error: (fields: Record<string, unknown>, message: string) => void;
+}
+export interface QueuePollerTarget {
+    readonly queueUrl: string;
+    readonly handler: SQSHandler;
+    /** Reported as the Lambda `Context.functionName` the handler observes. */
+    readonly functionName: string;
+    readonly maxMessages?: number;
+    readonly visibilityTimeoutSeconds?: number;
+}
+export interface RunQueuePollerOptions {
+    readonly targets: readonly QueuePollerTarget[];
+    readonly log: QueuePollerLog;
+    readonly signals?: readonly NodeJS.Signals[];
+    /** One per target. Defaults to a file under `WORKER_HEARTBEAT_PREFIX`. */
+    readonly createHeartbeat?: (name: string) => Heartbeat;
+}
+/**
+ * What a handler has before the queue redelivers the record underneath it.
+ * Exported because a handler that budgets its own wait has to agree with it;
+ * `deploy/vps/queues.json` sets the same number on the queue itself, and this
+ * is the one that applies wherever a target passes no override.
+ */
+export declare const DEFAULT_VISIBILITY_TIMEOUT_SECONDS = 300;
+/**
+ * Runs every target's poll loop until one of `signals` is received (default:
+ * SIGINT, SIGTERM). The signal aborts each loop's in-flight
+ * long-poll receive so an idle worker returns at once instead of waiting out
+ * the current 20s poll; a loop mid-handler finishes that handler first. Rejects
+ * (crashes the process) if any loop throws — a stuck poller should exit loudly,
+ * not degrade silently.
+ *
+ * Every loop writes its own heartbeat file (see heartbeat.ts) at the top of its
+ * receive attempt, which is how a loop that hangs instead of throwing — the
+ * case this cannot make loud by itself — becomes visible.
+ */
+export declare const runQueuePoller: (options: RunQueuePollerOptions) => Promise<void>;

package/dist/poller.js

@@ -0,0 +1,180 @@
+import { randomUUID } from "node:crypto";
+import { inspect } from "node:util";
+import { DeleteMessageCommand, ReceiveMessageCommand, } from "@aws-sdk/client-sqs";
+import { clearHeartbeats, createHeartbeat, } from "./heartbeat.js";
+import { createSqsClient } from "./producer.js";
+// One message per receive, not the SQS maximum of 10. Handlers process a batch
+// sequentially, so a batch of ten is ten handler runs between two heartbeats:
+// ten stalled SMTP sends at nodemailer's 300 s socket timeout is 50 minutes of
+// legitimate silence, and a threshold that tolerates it detects nothing. At one
+// message the quiet stretch a healthy loop can produce is one handler run, and
+// the extra receive per message is a millisecond against the local queue
+// sidecar — the same total work either way.
+const DEFAULT_MAX_MESSAGES = 1;
+/**
+ * What a handler has before the queue redelivers the record underneath it.
+ * Exported because a handler that budgets its own wait has to agree with it;
+ * `deploy/vps/queues.json` sets the same number on the queue itself, and this
+ * is the one that applies wherever a target passes no override.
+ */
+export const DEFAULT_VISIBILITY_TIMEOUT_SECONDS = 300;
+const pollTarget = async (target, log, isShuttingDown, shutdownSignal, buildHeartbeat) => {
+    const queueName = new URL(target.queueUrl).pathname.split("/").pop();
+    const heartbeat = buildHeartbeat(queueName ?? target.functionName);
+    const sqs = createSqsClient({ queueUrl: target.queueUrl });
+    const maxMessages = target.maxMessages ?? DEFAULT_MAX_MESSAGES;
+    const visibilityTimeout = target.visibilityTimeoutSeconds ?? DEFAULT_VISIBILITY_TIMEOUT_SECONDS;
+    log.info({ queue: queueName, maxMessages }, "poller: started");
+    // Always long-poll (SQS max WaitTimeSeconds). An empty long poll is free
+    // and returns as soon as a message arrives, so this is never slower than
+    // short-polling under load — it just stops burning a ReceiveMessage call
+    // (and, against real SQS, its cost) every loop iteration while traffic is
+    // continuous.
+    const LONG_POLL_WAIT_SECONDS = 20;
+    while (!isShuttingDown()) {
+        // Top of the receive attempt, before the long poll: this loop's own file,
+        // so a loop that stops turning — wedged in a socket read, or in a handler
+        // that never returns — goes stale on its own however busy its siblings are.
+        //
+        // A write that fails must not take the worker down with it. A full disk is
+        // the likeliest cause and the moment the loop should stay up, failing
+        // records into the dead-letter queues with logs rather than crash-looping
+        // on the monitoring. The missed beat is itself the signal: the healthcheck
+        // goes stale, which is what this file exists to report.
+        await heartbeat().catch((error) => {
+            log.error({ queue: queueName, error: inspect(error) }, "poller: heartbeat write failed");
+        });
+        let response;
+        try {
+            // Abort the receive on shutdown. Without this, a container stopped
+            // while idle waits out the current 20s long poll before the loop
+            // checks the flag again, and a self-update then burns the whole
+            // stop grace on every idle worker — the bulk of the visible restart
+            // downtime. The abort ends the in-flight receive at once; an
+            // in-flight handler below is never interrupted, so a message being
+            // processed still finishes cleanly. The heartbeat above already wrote
+            // this iteration, so the abort exits without a further beat.
+            response = await sqs.send(new ReceiveMessageCommand({
+                QueueUrl: target.queueUrl,
+                MaxNumberOfMessages: maxMessages,
+                WaitTimeSeconds: LONG_POLL_WAIT_SECONDS,
+                VisibilityTimeout: visibilityTimeout,
+                MessageSystemAttributeNames: ["ApproximateReceiveCount"],
+            }), { abortSignal: shutdownSignal });
+        }
+        catch (error) {
+            if (shutdownSignal.aborted)
+                break;
+            throw error;
+        }
+        if (!response.Messages || response.Messages.length === 0) {
+            continue;
+        }
+        const messages = response.Messages.flatMap((m) => m.Body && m.ReceiptHandle && m.MessageId
+            ? [
+                {
+                    messageId: m.MessageId,
+                    receiptHandle: m.ReceiptHandle,
+                    body: m.Body,
+                    receiveCount: m.Attributes?.ApproximateReceiveCount ?? "1",
+                },
+            ]
+            : []);
+        if (messages.length === 0)
+            continue;
+        // One batch is one handler invocation, so the id is minted per batch: it is
+        // the `requestId` every line of that invocation is grouped by (see
+        // deploy/vps/README.md, "Logs"). A context built once per target would put
+        // the whole queue's lifetime under one id, which correlates nothing.
+        //
+        // Minted before the poller's own bracketing lines rather than next to the
+        // handler call: grouping on the id has to reach the line saying whether the
+        // message was deleted or left for redelivery, which is what someone looks
+        // for after a failure.
+        const lambdaContext = {
+            functionName: target.functionName,
+            awsRequestId: randomUUID(),
+        };
+        log.info({
+            queue: queueName,
+            count: messages.length,
+            requestId: lambdaContext.awsRequestId,
+        }, "poller: invoking handler");
+        const event = {
+            Records: messages.map((m) => ({
+                messageId: m.messageId,
+                receiptHandle: m.receiptHandle,
+                body: m.body,
+                attributes: {
+                    ApproximateReceiveCount: m.receiveCount,
+                    SentTimestamp: "0",
+                    SenderId: "poller",
+                    ApproximateFirstReceiveTimestamp: "0",
+                },
+                messageAttributes: {},
+                md5OfBody: "",
+                eventSource: "aws:sqs",
+                eventSourceARN: target.queueUrl,
+                awsRegion: "local",
+            })),
+        };
+        const result = (await target.handler(event, lambdaContext, () => { }));
+        const failedIds = new Set((result?.batchItemFailures ?? []).map((f) => f.itemIdentifier));
+        const succeeded = messages.filter((m) => !failedIds.has(m.messageId));
+        // Batch is capped at maxMessages (one by default, 10 is the SQS ceiling),
+        // so a handful of concurrent DeleteMessage calls is safe and avoids paying
+        // N sequential round trips between every receive/handler cycle.
+        await Promise.all(succeeded.map((message) => sqs.send(new DeleteMessageCommand({
+            QueueUrl: target.queueUrl,
+            ReceiptHandle: message.receiptHandle,
+        }))));
+        log.info({
+            queue: queueName,
+            deleted: succeeded.length,
+            leftForRedelivery: failedIds.size,
+            requestId: lambdaContext.awsRequestId,
+        }, "poller: batch processed");
+    }
+    log.info({ queue: queueName }, "poller: stopped");
+};
+/**
+ * Runs every target's poll loop until one of `signals` is received (default:
+ * SIGINT, SIGTERM). The signal aborts each loop's in-flight
+ * long-poll receive so an idle worker returns at once instead of waiting out
+ * the current 20s poll; a loop mid-handler finishes that handler first. Rejects
+ * (crashes the process) if any loop throws — a stuck poller should exit loudly,
+ * not degrade silently.
+ *
+ * Every loop writes its own heartbeat file (see heartbeat.ts) at the top of its
+ * receive attempt, which is how a loop that hangs instead of throwing — the
+ * case this cannot make loud by itself — becomes visible.
+ */
+export const runQueuePoller = async (options) => {
+    const { targets, log } = options;
+    const signals = options.signals ?? ["SIGINT", "SIGTERM"];
+    const buildHeartbeat = options.createHeartbeat ?? createHeartbeat;
+    if (targets.length === 0) {
+        throw new Error("runQueuePoller: no targets configured");
+    }
+    // Files from the previous run of this service, before its loops write again:
+    // the healthcheck reads the oldest file it finds, so one left behind by a
+    // queue this version no longer polls would fail the check forever.
+    await clearHeartbeats().catch((error) => {
+        log.error({ error: inspect(error) }, "poller: heartbeat cleanup failed");
+    });
+    let shuttingDown = false;
+    const isShuttingDown = () => shuttingDown;
+    // Aborted alongside the flag so a loop currently blocked in its long-poll
+    // receive returns at once, rather than after up to WaitTimeSeconds.
+    const shutdown = new AbortController();
+    const onSignal = (signal) => {
+        log.info({ signal }, "poller: shutdown signal received");
+        shuttingDown = true;
+        shutdown.abort();
+    };
+    for (const signal of signals) {
+        process.on(signal, onSignal);
+    }
+    log.info({ queues: targets.map((t) => t.queueUrl) }, "poller: starting");
+    await Promise.all(targets.map((target) => pollTarget(target, log, isShuttingDown, shutdown.signal, buildHeartbeat)));
+};

package/{src/producer.ts → dist/producer.d.ts}

@@ -1,21 +1,18 @@
 import { SQSClient } from "@aws-sdk/client-sqs";
-import { AwsQueryProtocol } from "@aws-sdk/core/protocols";
-import { resolveSqsCredentials, type SqsStaticCredentials } from "./index.js";
-
-export interface CreateQueueProducerOptions {
-	readonly queueUrl: string;
-	readonly endpoint?: string;
-	readonly env?: NodeJS.ProcessEnv;
-	/**
-	 * Credentials to use when the queue URL resolves to a local endpoint. A
-	 * local queue server ignores them, but the SDK still needs something to
-	 * sign with and a self-hosted stack has no credential chain to fall back on.
-	 */
-	readonly localCredentials?: SqsStaticCredentials;
+import type { QueueMessage, QueueProducer } from "@remit/data-ports";
+import { type SqsStaticCredentials } from "./index.js";
+export interface CreateSqsClientOptions {
+    readonly queueUrl: string;
+    readonly endpoint?: string;
+    readonly env?: NodeJS.ProcessEnv;
+    /**
+     * Credentials to use when the queue URL resolves to a local endpoint. A
+     * local queue server ignores them, but the SDK still needs something to
+     * sign with and a self-hosted stack has no credential chain to fall back on.
+     */
+    readonly localCredentials?: SqsStaticCredentials;
+    readonly requestTimeoutMs?: number;
 }
-
-const LOOPBACK_HOSTNAMES = new Set(["localhost", "127.0.0.1", "[::1]"]);
-
 /**
  * Whether a queue URL addresses a local, SQS-compatible queue server
  * (ElasticMQ, the queue sidecar) rather than real SQS.
@@ -36,17 +33,7 @@ const LOOPBACK_HOSTNAMES = new Set(["localhost", "127.0.0.1", "[::1]"]);
  * here would take a worker down at import instead of surfacing the bad
  * configuration at the send that actually uses it.
  */
-export const isLocalEndpoint = (queueUrl: string): boolean => {
-	let url: URL;
-	try {
-		url = new URL(queueUrl);
-	} catch {
-		return false;
-	}
-	if (url.protocol === "http:") return true;
-	return url.protocol === "https:" && LOOPBACK_HOSTNAMES.has(url.hostname);
-};
-
+export declare const isLocalEndpoint: (queueUrl: string) => boolean;
 /**
  * Producer-side counterpart of `runQueuePoller`: the one place an
  * SQS-compatible client is constructed for sending. A queue URL that points at
@@ -55,15 +42,12 @@ export const isLocalEndpoint = (queueUrl: string): boolean => {
  * endpoint and ride the default credential chain unless
  * `SQS_ACCESS_KEY_ID`/`SQS_SECRET_ACCESS_KEY` are present.
  */
-export const createQueueProducer = (
-	options: CreateQueueProducerOptions,
-): SQSClient => {
-	const { queueUrl, endpoint, env, localCredentials } = options;
-	const local = isLocalEndpoint(queueUrl);
-	return new SQSClient({
-		endpoint: endpoint ?? (local ? new URL(queueUrl).origin : undefined),
-		...(local && { protocol: AwsQueryProtocol }),
-		credentials:
-			(local ? localCredentials : undefined) ?? resolveSqsCredentials(env),
-	});
-};
+export declare const createSqsClient: (options: CreateSqsClientOptions) => SQSClient;
+/**
+ * The SQS adapter for the `QueueProducer` port. A FIFO queue (`.fifo`) gets
+ * the message group, and the deduplication id when the message carries one
+ * (otherwise the queue deduplicates by content); a standard queue rejects
+ * both, so they are left off. A local queue server (ElasticMQ) does not honour
+ * a per-message delay on its FIFO queues, so the delay is dropped there.
+ */
+export declare const createQueueProducer: <T, M extends QueueMessage<T> = QueueMessage<T>>(options: CreateSqsClientOptions) => QueueProducer<T, M>;

package/dist/producer.js

@@ -0,0 +1,105 @@
+import { SendMessageBatchCommand, SendMessageCommand, SQSClient, } from "@aws-sdk/client-sqs";
+import { AwsQueryProtocol } from "@aws-sdk/core/protocols";
+import { resolveSqsCredentials } from "./index.js";
+const DEFAULT_REQUEST_TIMEOUT_MS = 45_000;
+const LOOPBACK_HOSTNAMES = new Set(["localhost", "127.0.0.1", "[::1]"]);
+/**
+ * Whether a queue URL addresses a local, SQS-compatible queue server
+ * (ElasticMQ, the queue sidecar) rather than real SQS.
+ *
+ * Any plain `http://` URL is local: real SQS and Scaleway M&Q are always
+ * HTTPS, and a self-hosted stack addresses its queue server by container name
+ * (`http://queue:9324/...`), not by `localhost`. Over HTTPS only a loopback
+ * host is local, which covers a local server behind TLS.
+ *
+ * The URL is parsed rather than prefix-matched. Prefix-matching the string
+ * gets the interesting cases wrong in both directions: it reads
+ * `https://localhost.example.com` and `https://localhost@example.com` as
+ * local (the host is neither), and misses `https://user:pass@localhost` and
+ * an uppercase `HTTP://` scheme (both of which are).
+ *
+ * A queue URL that does not parse is treated as remote. It cannot be sent to
+ * either way, and several callers build their client at module load — throwing
+ * here would take a worker down at import instead of surfacing the bad
+ * configuration at the send that actually uses it.
+ */
+export const isLocalEndpoint = (queueUrl) => {
+    let url;
+    try {
+        url = new URL(queueUrl);
+    }
+    catch {
+        return false;
+    }
+    if (url.protocol === "http:")
+        return true;
+    return url.protocol === "https:" && LOOPBACK_HOSTNAMES.has(url.hostname);
+};
+/**
+ * Producer-side counterpart of `runQueuePoller`: the one place an
+ * SQS-compatible client is constructed for sending. A queue URL that points at
+ * a local endpoint (ElasticMQ) gets its origin as the SDK endpoint and the
+ * query protocol ElasticMQ speaks; real SQS and Scaleway M&Q resolve their own
+ * endpoint and ride the default credential chain unless
+ * `SQS_ACCESS_KEY_ID`/`SQS_SECRET_ACCESS_KEY` are present.
+ */
+export const createSqsClient = (options) => {
+    const { queueUrl, endpoint, env, localCredentials } = options;
+    const requestTimeout = options.requestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS;
+    const local = isLocalEndpoint(queueUrl);
+    return new SQSClient({
+        requestHandler: { requestTimeout, throwOnRequestTimeout: true },
+        endpoint: endpoint ?? (local ? new URL(queueUrl).origin : undefined),
+        ...(local && { protocol: AwsQueryProtocol }),
+        credentials: (local ? localCredentials : undefined) ?? resolveSqsCredentials(env),
+    });
+};
+const isFifoQueue = (queueUrl) => queueUrl.endsWith(".fifo");
+const isGrouped = (message) => "groupId" in message && typeof message.groupId === "string";
+const isDeduplicated = (message) => isGrouped(message) &&
+    "deduplicationId" in message &&
+    typeof message.deduplicationId === "string";
+/**
+ * The SQS adapter for the `QueueProducer` port. A FIFO queue (`.fifo`) gets
+ * the message group, and the deduplication id when the message carries one
+ * (otherwise the queue deduplicates by content); a standard queue rejects
+ * both, so they are left off. A local queue server (ElasticMQ) does not honour
+ * a per-message delay on its FIFO queues, so the delay is dropped there.
+ */
+export const createQueueProducer = (options) => {
+    const { queueUrl } = options;
+    const client = createSqsClient(options);
+    const fifo = isFifoQueue(queueUrl);
+    const local = isLocalEndpoint(queueUrl);
+    const attributes = (message) => ({
+        ...(fifo && isGrouped(message) && { MessageGroupId: message.groupId }),
+        ...(fifo &&
+            isDeduplicated(message) && {
+            MessageDeduplicationId: message.deduplicationId,
+        }),
+        ...(message.delaySeconds &&
+            !local && { DelaySeconds: message.delaySeconds }),
+    });
+    return {
+        send: async (message) => {
+            await client.send(new SendMessageCommand({
+                QueueUrl: queueUrl,
+                MessageBody: JSON.stringify(message.body),
+                ...attributes(message),
+            }));
+        },
+        sendBatch: async (messages) => {
+            const result = await client.send(new SendMessageBatchCommand({
+                QueueUrl: queueUrl,
+                Entries: messages.map((message, index) => ({
+                    Id: `${index}`,
+                    MessageBody: JSON.stringify(message.body),
+                    ...attributes(message),
+                })),
+            }));
+            return {
+                refused: new Set((result.Failed ?? []).map((entry) => Number(entry.Id))),
+            };
+        },
+    };
+};