@aws-sdk/lib-sqs 0.0.0-stage → 3.1158.0

package/dist-cjs/index.js

@@ -0,0 +1,666 @@
+const { SQSClient, ReceiveMessageCommand, DeleteMessageBatchCommand, ChangeMessageVisibilityCommand } = require("@aws-sdk/client-sqs");
+
+class Message {
+    raw;
+    body;
+    messageId;
+    receiptHandle;
+    attributes;
+    messageAttributes;
+    receivedAt;
+    _callbacks;
+    _handled = false;
+    constructor(raw, callbacks) {
+        this.raw = raw;
+        this.body = raw.Body;
+        this.messageId = raw.MessageId ?? "";
+        this.receiptHandle = raw.ReceiptHandle ?? "";
+        this.attributes = raw.Attributes ?? {};
+        this.messageAttributes = raw.MessageAttributes ?? {};
+        this.receivedAt = new Date();
+        this._callbacks = callbacks;
+    }
+    get handled() {
+        return this._handled;
+    }
+    enqueueDelete() {
+        if (this._handled)
+            return;
+        this._handled = true;
+        this._callbacks.enqueueDelete(this);
+    }
+    keep() {
+        this._handled = true;
+        this._callbacks.keep(this.receiptHandle);
+    }
+    async release() {
+        this._handled = true;
+        await this._callbacks.release(this.receiptHandle);
+    }
+    async changeVisibility(timeoutMs) {
+        await this._callbacks.changeVisibility(this.receiptHandle, timeoutMs);
+    }
+}
+
+class PollerError extends Error {
+    name = "PollerError";
+    constructor(message, options) {
+        super(message, options);
+    }
+}
+class TimeoutError extends PollerError {
+    name = "TimeoutError";
+    timeoutMs;
+    constructor(message, timeoutMs, options) {
+        super(message, options);
+        this.timeoutMs = timeoutMs;
+    }
+}
+class DeleteError extends PollerError {
+    name = "DeleteError";
+    failures;
+    messageIds;
+    constructor(message, failures, messageIds, options) {
+        super(message, options);
+        this.failures = failures;
+        this.messageIds = messageIds ?? [];
+    }
+}
+class VisibilityExtensionError extends PollerError {
+    name = "VisibilityExtensionError";
+    messageId;
+    constructor(message, messageId, options) {
+        super(message, options);
+        this.messageId = messageId;
+    }
+}
+
+const DEFAULTS = {
+    receiveWaitTimeMs: 20_000,
+    receiveBatchSize: 10,
+    activePollIntervalMs: 0,
+    idlePollIntervalMs: 0,
+    maxConcurrency: 10,
+    deleteMessages: true,
+    deleteBatchSize: 10,
+    deleteWaitMs: 2_000,
+    backoffMs: 1_000,
+    maxBackoffMs: 30_000,
+    shutdownTimeoutMs: 30_000,
+    extendTimeout: false,
+    extendTimeoutAdvanceMs: 5_000,
+    maxTimeoutExtensionMs: 43_200_000,
+};
+const MIN_POLL_INTERVAL_MS = 100;
+function createRun(previous) {
+    let resolveDone = () => { };
+    const done = new Promise((resolve) => {
+        resolveDone = resolve;
+    });
+    return {
+        ac: new AbortController(),
+        hard: new AbortController(),
+        stopping: false,
+        graceful: true,
+        finished: false,
+        consecutiveErrors: 0,
+        inFlight: 0,
+        drainResolvers: [],
+        receiptHandles: new Set(),
+        done,
+        resolveDone,
+        previous: previous?.done,
+    };
+}
+const toError = (err) => (err instanceof Error ? err : new PollerError(String(err)));
+class SQSPoller {
+    _client;
+    _config;
+    _stats = {
+        requestCount: 0,
+        receivedMessageCount: 0,
+        deletedMessageCount: 0,
+        errorCount: 0,
+        lastMessageReceivedAt: null,
+        pollingStartedAt: null,
+        pollingStoppedAt: null,
+    };
+    _run = null;
+    _externalSignal;
+    _deleteBatch = [];
+    _deleteTimer = null;
+    _pendingFlushes = [];
+    _heartbeatTimers = new Map();
+    _heartbeatsInFlight = new Map();
+    _listeners = {
+        message: [],
+        empty: [],
+        idle: [],
+        stopped: [],
+        error: [],
+        timeoutExtended: [],
+        heartbeatExpired: [],
+    };
+    constructor(config) {
+        if (!config.queueUrl)
+            throw new PollerError("queueUrl is required");
+        this._client = config.client ?? new SQSClient(config.clientConfig ?? {});
+        const batchSize = config.receiveBatchSize ?? DEFAULTS.receiveBatchSize;
+        if (batchSize < 1 || batchSize > 10 || !Number.isInteger(batchSize))
+            throw new PollerError("receiveBatchSize must be an integer between 1 and 10");
+        const deleteBatchSize = config.deleteBatchSize ?? DEFAULTS.deleteBatchSize;
+        if (deleteBatchSize < 1 || deleteBatchSize > 10 || !Number.isInteger(deleteBatchSize))
+            throw new PollerError("deleteBatchSize must be an integer between 1 and 10");
+        const receiveWaitTimeMs = config.receiveWaitTimeMs ?? DEFAULTS.receiveWaitTimeMs;
+        if (receiveWaitTimeMs < 0 || receiveWaitTimeMs > 20_000)
+            throw new PollerError("receiveWaitTimeMs must be between 0 and 20000");
+        const maxConcurrency = config.maxConcurrency ?? DEFAULTS.maxConcurrency;
+        if (!Number.isInteger(maxConcurrency) || maxConcurrency < 1)
+            throw new PollerError("maxConcurrency must be a positive integer");
+        if (config.extendTimeout) {
+            if (config.visibilityTimeoutMs == null)
+                throw new PollerError("visibilityTimeoutMs is required when extendTimeout is true");
+            if ((config.extendTimeoutAdvanceMs ?? DEFAULTS.extendTimeoutAdvanceMs) >= config.visibilityTimeoutMs)
+                throw new PollerError("extendTimeoutAdvanceMs must be less than visibilityTimeoutMs");
+        }
+        this._config = {
+            queueUrl: config.queueUrl,
+            receiveWaitTimeMs,
+            receiveBatchSize: batchSize,
+            activePollIntervalMs: config.activePollIntervalMs ?? DEFAULTS.activePollIntervalMs,
+            idlePollIntervalMs: config.idlePollIntervalMs ?? DEFAULTS.idlePollIntervalMs,
+            maxConcurrency,
+            deleteMessages: config.deleteMessages ?? DEFAULTS.deleteMessages,
+            deleteBatchSize,
+            deleteWaitMs: config.deleteWaitMs ?? DEFAULTS.deleteWaitMs,
+            backoffMs: config.backoffMs ?? DEFAULTS.backoffMs,
+            maxBackoffMs: config.maxBackoffMs ?? DEFAULTS.maxBackoffMs,
+            shutdownTimeoutMs: config.shutdownTimeoutMs ?? DEFAULTS.shutdownTimeoutMs,
+            extendTimeout: config.extendTimeout ?? DEFAULTS.extendTimeout,
+            extendTimeoutAdvanceMs: config.extendTimeoutAdvanceMs ?? DEFAULTS.extendTimeoutAdvanceMs,
+            maxTimeoutExtensionMs: config.maxTimeoutExtensionMs ?? DEFAULTS.maxTimeoutExtensionMs,
+            visibilityTimeoutMs: config.visibilityTimeoutMs,
+            idleTimeoutMs: config.idleTimeoutMs,
+            beforeRequest: config.beforeRequest,
+            systemAttributeNames: config.systemAttributeNames,
+            messageAttributeNames: config.messageAttributeNames,
+        };
+        this._externalSignal = config.abortSignal;
+        if (this._externalSignal) {
+            this._externalSignal.addEventListener("abort", () => {
+                void this.stop();
+            }, { once: true });
+        }
+    }
+    get running() {
+        return this._run !== null && !this._run.stopping;
+    }
+    get inFlight() {
+        return this._run?.inFlight ?? 0;
+    }
+    getStats() {
+        return { ...this._stats };
+    }
+    toJSON() {
+        const now = new Date();
+        const s = this._stats.pollingStartedAt;
+        return {
+            requestCount: this._stats.requestCount,
+            receivedMessageCount: this._stats.receivedMessageCount,
+            deletedMessageCount: this._stats.deletedMessageCount,
+            errorCount: this._stats.errorCount,
+            lastMessageReceivedAt: this._stats.lastMessageReceivedAt?.toISOString() ?? null,
+            pollingStartedAt: s?.toISOString() ?? null,
+            pollingStoppedAt: this._stats.pollingStoppedAt?.toISOString() ?? null,
+            pollingDurationMs: s ? (this._stats.pollingStoppedAt ?? now).getTime() - s.getTime() : 0,
+        };
+    }
+    toString() {
+        const s = this._stats;
+        return `SQSPoller(${this.running ? "running" : "stopped"}, requests=${s.requestCount}, received=${s.receivedMessageCount}, deleted=${s.deletedMessageCount}, errors=${s.errorCount}, inFlight=${this.inFlight})`;
+    }
+    on(event, listener) {
+        this._listeners[event].push(listener);
+        return () => {
+            this.off(event, listener);
+        };
+    }
+    off(event, listener) {
+        if (!listener) {
+            this._listeners[event] = [];
+            return this;
+        }
+        const arr = this._listeners[event];
+        const idx = arr.indexOf(listener);
+        if (idx !== -1)
+            arr.splice(idx, 1);
+        return this;
+    }
+    start() {
+        this._assertCanStart("Poller is already running");
+        const run = createRun(this._run);
+        this._run = run;
+        void this._pollLoop(run);
+    }
+    async stop(graceful = true) {
+        const run = this._run;
+        if (!run)
+            return { ...this._stats };
+        run.stopping = true;
+        run.ac.abort();
+        if (!graceful) {
+            run.graceful = false;
+            run.hard.abort();
+        }
+        if (run.iterator) {
+            const outcome = run.graceful ? await this._waitFor(run.done, run) : "hard";
+            if (outcome === "timeout")
+                this._emitShutdownTimeout("the async iterator was not advanced");
+            if (outcome !== "done")
+                await run.iterator.return(undefined);
+        }
+        await run.done;
+        return { ...this._stats };
+    }
+    [Symbol.asyncIterator]() {
+        const ref = {};
+        ref.gen = this._iterate(ref);
+        return ref.gen;
+    }
+    async *_iterate(ref) {
+        this._assertCanStart("Poller is already running or an open iterator exists");
+        const run = createRun(this._run);
+        run.iterator = ref.gen;
+        this._run = run;
+        try {
+            await this._beginRun(run);
+            while (!run.stopping && !this._isAborted(run)) {
+                let batch = [];
+                try {
+                    if (!(await this._runBeforeRequest(run)))
+                        break;
+                    const messages = await this._receiveMessages(run);
+                    run.consecutiveErrors = 0;
+                    if (messages.length === 0) {
+                        if (await this._handleEmpty(run))
+                            break;
+                        continue;
+                    }
+                    this._recordReceived(messages.length);
+                    batch = messages.map((raw) => this._wrapMessage(raw, run));
+                    for (const msg of batch)
+                        this._startHeartbeat(msg, run);
+                }
+                catch (err) {
+                    if (this._isAborted(run))
+                        break;
+                    await this._handlePollError(err, run);
+                    continue;
+                }
+                for (const msg of batch) {
+                    if (run.stopping || this._isAborted(run))
+                        break;
+                    yield msg;
+                    void this._stopHeartbeat(msg.receiptHandle, run);
+                    if (this._config.deleteMessages && !msg.handled)
+                        msg.enqueueDelete();
+                }
+                if (this._config.activePollIntervalMs > 0)
+                    await this._delay(this._config.activePollIntervalMs, run);
+            }
+        }
+        finally {
+            await this._teardown(run);
+        }
+    }
+    _assertCanStart(activeMessage) {
+        if (this._run && !this._run.stopping)
+            throw new PollerError(activeMessage);
+        if (this._externalSignal?.aborted)
+            throw new PollerError("abortSignal is already aborted");
+    }
+    async _beginRun(run) {
+        if (run.previous)
+            await run.previous;
+        this._stats.pollingStartedAt = new Date();
+        this._stats.pollingStoppedAt = null;
+    }
+    async _teardown(run) {
+        await this._stopHeartbeats(run);
+        do {
+            await this._flushDeleteBatch();
+            await this._awaitPendingFlushes();
+        } while (this._deleteBatch.length > 0);
+        run.stopping = true;
+        run.finished = true;
+        this._stats.pollingStoppedAt = new Date();
+        if (this._run === run)
+            this._run = null;
+        run.resolveDone();
+        this._emit("stopped", { ...this._stats });
+    }
+    _waitFor(work, run) {
+        return new Promise((resolve) => {
+            if (run.hard.signal.aborted) {
+                resolve("hard");
+                return;
+            }
+            let timer;
+            function finish(outcome) {
+                clearTimeout(timer);
+                run.hard.signal.removeEventListener("abort", onHard);
+                resolve(outcome);
+            }
+            function onHard() {
+                finish("hard");
+            }
+            timer = setTimeout(() => finish("timeout"), this._config.shutdownTimeoutMs);
+            run.hard.signal.addEventListener("abort", onHard, { once: true });
+            void work.then(() => finish("done"));
+        });
+    }
+    async _waitForDrain(run) {
+        if (run.inFlight === 0)
+            return;
+        const drained = new Promise((resolve) => run.drainResolvers.push(resolve));
+        if ((await this._waitFor(drained, run)) === "timeout") {
+            this._emitShutdownTimeout(`${run.inFlight} message(s) were still in flight`);
+        }
+    }
+    _emitShutdownTimeout(reason) {
+        this._stats.errorCount++;
+        this._emit("error", new TimeoutError(`Shutdown timed out because ${reason}. If a handler or loop body awaits stop(), use \`void poller.stop()\` instead.`, this._config.shutdownTimeoutMs));
+    }
+    async _pollLoop(run) {
+        await this._beginRun(run);
+        while (!run.stopping && !this._isAborted(run)) {
+            try {
+                while (!run.stopping && run.inFlight >= this._config.maxConcurrency)
+                    await this._delay(50, run);
+                if (run.stopping || this._isAborted(run))
+                    break;
+                if (!(await this._runBeforeRequest(run)))
+                    break;
+                const messages = await this._receiveMessages(run, Math.min(this._config.receiveBatchSize, this._config.maxConcurrency - run.inFlight));
+                run.consecutiveErrors = 0;
+                if (messages.length === 0) {
+                    if (await this._handleEmpty(run))
+                        break;
+                    continue;
+                }
+                this._recordReceived(messages.length);
+                for (const raw of messages) {
+                    const msg = this._wrapMessage(raw, run);
+                    run.inFlight++;
+                    void this._processMessage(msg, run).finally(() => {
+                        run.inFlight--;
+                        if (run.inFlight === 0) {
+                            for (const resolve of run.drainResolvers)
+                                resolve();
+                            run.drainResolvers = [];
+                        }
+                    });
+                }
+                if (this._config.activePollIntervalMs > 0)
+                    await this._delay(this._config.activePollIntervalMs, run);
+            }
+            catch (err) {
+                if (this._isAborted(run))
+                    break;
+                await this._handlePollError(err, run);
+            }
+        }
+        if (run.graceful)
+            await this._waitForDrain(run);
+        await this._teardown(run);
+    }
+    async _processMessage(msg, run) {
+        this._startHeartbeat(msg, run);
+        try {
+            const hasListeners = this._listeners.message.length > 0;
+            if (hasListeners)
+                await this._emitAsync("message", msg);
+            if (this._config.deleteMessages && !msg.handled && hasListeners)
+                msg.enqueueDelete();
+        }
+        catch (err) {
+            this._stats.errorCount++;
+            this._emit("error", toError(err));
+        }
+        finally {
+            void this._stopHeartbeat(msg.receiptHandle, run);
+        }
+    }
+    async _runBeforeRequest(run) {
+        if (!this._config.beforeRequest)
+            return true;
+        try {
+            await this._config.beforeRequest(this.getStats());
+            return true;
+        }
+        catch (err) {
+            run.stopping = true;
+            this._emit("error", toError(err));
+            return false;
+        }
+    }
+    async _handleEmpty(run) {
+        this._emit("empty");
+        if (this._checkIdleTimeout()) {
+            run.stopping = true;
+            this._emit("idle");
+            return true;
+        }
+        const delayMs = this._effectiveIdlePollInterval();
+        if (delayMs > 0)
+            await this._delay(delayMs, run);
+        return false;
+    }
+    async _handlePollError(err, run) {
+        run.consecutiveErrors++;
+        this._stats.errorCount++;
+        this._emit("error", toError(err));
+        await this._backoff(run);
+    }
+    _recordReceived(count) {
+        this._stats.receivedMessageCount += count;
+        this._stats.lastMessageReceivedAt = new Date();
+    }
+    async _receiveMessages(run, maxMessages) {
+        this._stats.requestCount++;
+        const result = await this._client.send(new ReceiveMessageCommand({
+            QueueUrl: this._config.queueUrl,
+            WaitTimeSeconds: Math.floor(this._config.receiveWaitTimeMs / 1000),
+            MaxNumberOfMessages: maxMessages ?? this._config.receiveBatchSize,
+            VisibilityTimeout: this._config.visibilityTimeoutMs != null ? Math.ceil(this._config.visibilityTimeoutMs / 1000) : undefined,
+            MessageSystemAttributeNames: this._config.systemAttributeNames,
+            MessageAttributeNames: this._config.messageAttributeNames,
+        }), { abortSignal: run.ac.signal });
+        return result.Messages ?? [];
+    }
+    _enqueueDelete(msg, run) {
+        this._deleteBatch.push(msg);
+        if (run.finished || this._deleteBatch.length >= this._config.deleteBatchSize) {
+            this._trackFlush(this._flushDeleteBatch());
+        }
+        else if (!this._deleteTimer) {
+            this._deleteTimer = setTimeout(() => {
+                this._deleteTimer = null;
+                this._trackFlush(this._flushDeleteBatch());
+            }, this._config.deleteWaitMs);
+        }
+    }
+    async _flushDeleteBatch() {
+        if (this._deleteTimer) {
+            clearTimeout(this._deleteTimer);
+            this._deleteTimer = null;
+        }
+        if (this._deleteBatch.length === 0)
+            return;
+        const batch = this._deleteBatch.splice(0, this._config.deleteBatchSize);
+        const idMap = new Map();
+        const entries = batch.map((m, i) => {
+            const id = String(i);
+            idMap.set(id, m.messageId);
+            return { Id: id, ReceiptHandle: m.receiptHandle };
+        });
+        try {
+            const result = await this._client.send(new DeleteMessageBatchCommand({ QueueUrl: this._config.queueUrl, Entries: entries }));
+            this._stats.deletedMessageCount += result.Successful?.length ?? 0;
+            if (result.Failed?.length) {
+                this._stats.errorCount += result.Failed.length;
+                const mapped = result.Failed.map((f) => ({ ...f, MessageId: idMap.get(f.Id) ?? f.Id }));
+                this._emit("error", new DeleteError(`Failed to delete ${result.Failed.length} message(s): ${mapped.map((f) => f.MessageId).join(", ")}`, result.Failed, mapped.map((f) => f.MessageId)));
+            }
+        }
+        catch (err) {
+            this._stats.errorCount++;
+            this._emit("error", err instanceof Error ? err : new PollerError(String(err)));
+        }
+        if (this._deleteBatch.length > 0)
+            await this._flushDeleteBatch();
+    }
+    _trackFlush(p) {
+        this._pendingFlushes.push(p);
+        p.finally(() => {
+            const i = this._pendingFlushes.indexOf(p);
+            if (i !== -1)
+                this._pendingFlushes.splice(i, 1);
+        });
+    }
+    async _awaitPendingFlushes() {
+        while (this._pendingFlushes.length > 0)
+            await Promise.all([...this._pendingFlushes]);
+    }
+    _startHeartbeat(msg, run) {
+        if (!this._config.extendTimeout || this._config.visibilityTimeoutMs == null)
+            return;
+        const intervalMs = this._config.visibilityTimeoutMs - this._config.extendTimeoutAdvanceMs;
+        if (intervalMs <= 0)
+            return;
+        run.receiptHandles.add(msg.receiptHandle);
+        const startTime = Date.now();
+        const scheduleNext = () => {
+            const timer = setTimeout(async () => {
+                if (Date.now() - startTime > this._config.maxTimeoutExtensionMs) {
+                    this._heartbeatTimers.delete(msg.receiptHandle);
+                    run.receiptHandles.delete(msg.receiptHandle);
+                    this._emit("heartbeatExpired", msg);
+                    return;
+                }
+                try {
+                    const extension = this._client.send(new ChangeMessageVisibilityCommand({
+                        QueueUrl: this._config.queueUrl,
+                        ReceiptHandle: msg.receiptHandle,
+                        VisibilityTimeout: Math.ceil(this._config.visibilityTimeoutMs / 1000),
+                    }));
+                    this._heartbeatsInFlight.set(msg.receiptHandle, extension);
+                    await extension;
+                    this._emit("timeoutExtended", msg);
+                }
+                catch (err) {
+                    this._stats.errorCount++;
+                    this._emit("error", new VisibilityExtensionError(`Failed to extend visibility for message ${msg.messageId}`, msg.messageId, {
+                        cause: err instanceof Error ? err : undefined,
+                    }));
+                }
+                finally {
+                    this._heartbeatsInFlight.delete(msg.receiptHandle);
+                }
+                if (this._heartbeatTimers.has(msg.receiptHandle))
+                    scheduleNext();
+            }, intervalMs);
+            this._heartbeatTimers.set(msg.receiptHandle, timer);
+        };
+        scheduleNext();
+    }
+    async _stopHeartbeat(receiptHandle, run) {
+        const t = this._heartbeatTimers.get(receiptHandle);
+        if (t) {
+            clearTimeout(t);
+            this._heartbeatTimers.delete(receiptHandle);
+        }
+        await this._heartbeatsInFlight.get(receiptHandle)?.catch(() => { });
+        run.receiptHandles.delete(receiptHandle);
+    }
+    async _stopHeartbeats(run) {
+        await Promise.all([...run.receiptHandles].map((rh) => this._stopHeartbeat(rh, run)));
+    }
+    _wrapMessage(raw, run) {
+        const callbacks = {
+            enqueueDelete: (m) => this._trackFlush(this._stopHeartbeat(m.receiptHandle, run).then(() => this._enqueueDelete(m, run))),
+            keep: (rh) => void this._stopHeartbeat(rh, run),
+            release: (rh) => this._stopHeartbeat(rh, run)
+                .then(() => this._client.send(new ChangeMessageVisibilityCommand({
+                QueueUrl: this._config.queueUrl,
+                ReceiptHandle: rh,
+                VisibilityTimeout: 0,
+            })))
+                .then(() => { }),
+            changeVisibility: (rh, ms) => this._stopHeartbeat(rh, run)
+                .then(() => this._client.send(new ChangeMessageVisibilityCommand({
+                QueueUrl: this._config.queueUrl,
+                ReceiptHandle: rh,
+                VisibilityTimeout: Math.ceil(ms / 1000),
+            })))
+                .then(() => { }),
+        };
+        return new Message(raw, callbacks);
+    }
+    _isAborted(run) {
+        return run.ac.signal.aborted || this._externalSignal?.aborted === true;
+    }
+    _checkIdleTimeout() {
+        if (this._config.idleTimeoutMs == null)
+            return false;
+        const started = this._stats.pollingStartedAt?.getTime() ?? 0;
+        const lastMessage = this._stats.lastMessageReceivedAt?.getTime() ?? 0;
+        const since = Math.max(started, lastMessage);
+        return since > 0 && Date.now() - since > this._config.idleTimeoutMs;
+    }
+    _effectiveIdlePollInterval() {
+        if (this._config.idlePollIntervalMs > 0)
+            return this._config.idlePollIntervalMs;
+        return this._config.receiveWaitTimeMs === 0 ? MIN_POLL_INTERVAL_MS : 0;
+    }
+    async _backoff(run) {
+        await this._delay(Math.min(this._config.backoffMs * 2 ** (run.consecutiveErrors - 1), this._config.maxBackoffMs), run);
+    }
+    _delay(ms, run) {
+        return new Promise((r) => {
+            const signal = run.ac.signal;
+            if (signal.aborted) {
+                r();
+                return;
+            }
+            const onAbort = () => {
+                clearTimeout(timer);
+                r();
+            };
+            const timer = setTimeout(() => {
+                signal.removeEventListener("abort", onAbort);
+                r();
+            }, ms);
+            signal.addEventListener("abort", onAbort, { once: true });
+        });
+    }
+    _emit(event, ...args) {
+        for (const fn of this._listeners[event]) {
+            try {
+                fn(...args);
+            }
+            catch { }
+        }
+    }
+    async _emitAsync(event, ...args) {
+        for (const fn of this._listeners[event])
+            await fn(...args);
+    }
+}
+
+exports.DeleteError = DeleteError;
+exports.Message = Message;
+exports.PollerError = PollerError;
+exports.SQSPoller = SQSPoller;
+exports.TimeoutError = TimeoutError;
+exports.VisibilityExtensionError = VisibilityExtensionError;

package/dist-es/Message.js

@@ -0,0 +1,41 @@
+export class Message {
+    raw;
+    body;
+    messageId;
+    receiptHandle;
+    attributes;
+    messageAttributes;
+    receivedAt;
+    _callbacks;
+    _handled = false;
+    constructor(raw, callbacks) {
+        this.raw = raw;
+        this.body = raw.Body;
+        this.messageId = raw.MessageId ?? "";
+        this.receiptHandle = raw.ReceiptHandle ?? "";
+        this.attributes = raw.Attributes ?? {};
+        this.messageAttributes = raw.MessageAttributes ?? {};
+        this.receivedAt = new Date();
+        this._callbacks = callbacks;
+    }
+    get handled() {
+        return this._handled;
+    }
+    enqueueDelete() {
+        if (this._handled)
+            return;
+        this._handled = true;
+        this._callbacks.enqueueDelete(this);
+    }
+    keep() {
+        this._handled = true;
+        this._callbacks.keep(this.receiptHandle);
+    }
+    async release() {
+        this._handled = true;
+        await this._callbacks.release(this.receiptHandle);
+    }
+    async changeVisibility(timeoutMs) {
+        await this._callbacks.changeVisibility(this.receiptHandle, timeoutMs);
+    }
+}