@zintrust/queue-sqs 0.1.12

package/README.md

@@ -0,0 +1,22 @@
+# @zintrust/queue-sqs
+
+AWS SQS queue driver registration for Zintrust.
+
+- Docs: https://zintrust.com/queue
+
+## Install
+
+```bash
+npm i @zintrust/queue-sqs
+```
+
+## Usage
+
+```ts
+import '@zintrust/queue-sqs/register';
+```
+
+Then set `QUEUE_DRIVER=sqs` and configure:
+
+- `AWS_REGION`
+- `SQS_QUEUE_URL` (or pass queue URL explicitly in your app config)

package/dist/index.d.ts

@@ -0,0 +1,22 @@
+export type QueueMessage<T = unknown> = {
+    id: string;
+    payload: T;
+    attempts: number;
+};
+export type SqsQueueConfig = {
+    driver: 'sqs';
+    region?: string;
+    queueUrl?: string;
+    waitTimeSeconds?: number;
+    visibilityTimeout?: number;
+};
+export declare const SqsQueue: Readonly<{
+    create(config?: SqsQueueConfig): {
+        enqueue<T = unknown>(queue: string, payload: T): Promise<string>;
+        dequeue<T = unknown>(queue: string): Promise<QueueMessage<T> | undefined>;
+        ack(queue: string, id: string): Promise<void>;
+        length(queue: string): Promise<number>;
+        drain(queue: string): Promise<void>;
+    };
+}>;
+export default SqsQueue;

package/dist/index.js

@@ -0,0 +1,98 @@
+import { ErrorFactory, generateUuid } from '@zintrust/core';
+async function importSqs() {
+    // Avoid a string-literal import so TypeScript doesn't require the module at build time.
+    const specifier = '@aws-sdk/client-sqs';
+    return (await import(specifier));
+}
+function resolveRegion(config) {
+    const region = (config?.region ?? process.env['AWS_REGION'] ?? '').toString().trim();
+    if (region === '')
+        throw ErrorFactory.createConfigError('SQS: missing AWS_REGION');
+    return region;
+}
+function resolveQueueUrl(config) {
+    const queueUrl = (config?.queueUrl ?? process.env['SQS_QUEUE_URL'] ?? '').toString().trim();
+    if (queueUrl === '')
+        throw ErrorFactory.createConfigError('SQS: missing SQS_QUEUE_URL');
+    return queueUrl;
+}
+async function ensure(state, config) {
+    if (state.client !== undefined && state.mod !== undefined)
+        return { client: state.client, mod: state.mod };
+    state.mod = await importSqs();
+    state.client = new state.mod.SQSClient({ region: resolveRegion(config) });
+    return { client: state.client, mod: state.mod };
+}
+function resolveUrl(_queue, config) {
+    return resolveQueueUrl(config);
+}
+function createSqsQueueDriver(config) {
+    const waitTimeSeconds = config?.waitTimeSeconds ?? 0;
+    const visibilityTimeout = config?.visibilityTimeout;
+    const state = { receipts: new Map() };
+    return {
+        async enqueue(queue, payload) {
+            const id = generateUuid();
+            const { client, mod } = await ensure(state, config);
+            const body = JSON.stringify({ id, payload, attempts: 0 });
+            await client.send(new mod.SendMessageCommand({
+                QueueUrl: resolveUrl(queue, config),
+                MessageBody: body,
+            }));
+            return id;
+        },
+        async dequeue(queue) {
+            const { client, mod } = await ensure(state, config);
+            const resp = (await client.send(new mod.ReceiveMessageCommand({
+                QueueUrl: resolveUrl(queue, config),
+                MaxNumberOfMessages: 1,
+                WaitTimeSeconds: waitTimeSeconds,
+                VisibilityTimeout: visibilityTimeout,
+            })));
+            const msg = resp.Messages?.[0];
+            if (msg?.Body === undefined)
+                return undefined;
+            try {
+                const parsed = JSON.parse(msg.Body);
+                if (msg.ReceiptHandle && typeof parsed?.id === 'string' && parsed.id.trim() !== '') {
+                    state.receipts.set(parsed.id, msg.ReceiptHandle);
+                }
+                return parsed;
+            }
+            catch (err) {
+                throw ErrorFactory.createTryCatchError('Failed to parse queue message', err);
+            }
+        },
+        async ack(queue, id) {
+            const receipt = state.receipts.get(id);
+            if (receipt === undefined)
+                return;
+            state.receipts.delete(id);
+            const { client, mod } = await ensure(state, config);
+            await client.send(new mod.DeleteMessageCommand({
+                QueueUrl: resolveUrl(queue, config),
+                ReceiptHandle: receipt,
+            }));
+        },
+        async length(queue) {
+            const { client, mod } = await ensure(state, config);
+            const resp = (await client.send(new mod.GetQueueAttributesCommand({
+                QueueUrl: resolveUrl(queue, config),
+                AttributeNames: ['ApproximateNumberOfMessages'],
+            })));
+            const raw = resp.Attributes?.['ApproximateNumberOfMessages'] ?? '0';
+            const n = Number(raw);
+            return Number.isFinite(n) ? n : 0;
+        },
+        async drain(queue) {
+            const { client, mod } = await ensure(state, config);
+            await client.send(new mod.PurgeQueueCommand({ QueueUrl: resolveUrl(queue, config) }));
+        },
+    };
+}
+export const SqsQueue = Object.freeze({
+    create(config) {
+        return createSqsQueueDriver(config);
+    },
+});
+export default SqsQueue;

package/dist/register.d.ts

@@ -0,0 +1,5 @@
+type QueueApi = {
+    register: (name: string, driver: unknown) => void;
+};
+export declare function registerSqsQueueDriver(queue: QueueApi): Promise<void>;
+export {};

package/dist/register.js

@@ -0,0 +1,21 @@
+export async function registerSqsQueueDriver(queue) {
+    const { SqsQueue } = (await import('./index.js'));
+    queue.register('sqs', SqsQueue.create());
+}
+const importCore = async () => {
+    try {
+        return await import('@zintrust/core');
+    }
+    catch {
+        try {
+            return await import('@zintrust/core');
+        }
+        catch {
+            return {};
+        }
+    }
+};
+const core = (await importCore());
+if (core.Queue !== undefined) {
+    await registerSqsQueueDriver(core.Queue);
+}

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@zintrust/queue-sqs",
+  "version": "0.1.12",
+  "private": false,
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./register": {
+      "types": "./dist/register.d.ts",
+      "default": "./dist/register.js"
+    }
+  },
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "peerDependencies": {
+    "@zintrust/core": "^0.1.12"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "prepublishOnly": "npm run build"
+  }
+}