@efebia/sqs-queue-v2 0.0.1

package/lib/index.d.ts

@@ -0,0 +1,32 @@
+/// <reference types="node" />
+import AWS from "aws-sdk";
+import EventEmitter from "events";
+export type QueueOptions = {
+    sleepTimeout: number;
+};
+export type QueueConstructorOptions = {
+    client: AWS.SQS;
+    receiveOptions: AWS.SQS.ReceiveMessageRequest;
+} & Partial<QueueOptions>;
+export type QueueCallback<TMessage extends object> = (name: string, params: TMessage, state: {
+    del: boolean;
+}) => void | Promise<void>;
+export declare class Queue extends EventEmitter {
+    receiveOptions: AWS.SQS.ReceiveMessageRequest;
+    client: AWS.SQS;
+    forever: boolean;
+    options: Omit<QueueOptions, "client" | "receiveOptions">;
+    constructor({ receiveOptions, client, ...otherOptions }: QueueConstructorOptions);
+    start<TMessage extends object>(callback: QueueCallback<TMessage>, errorCallback: (error: any) => void | Promise<void>, canThrow?: boolean): Promise<void>;
+    processMessage<TMessage extends object>(message: AWS.SQS.Message, callback?: QueueCallback<TMessage>): Promise<void>;
+    delete(ReceiptHandle: string): Promise<{
+        $response: AWS.Response<{}, AWS.AWSError>;
+    }>;
+    stop(): void;
+    resume(...args: Parameters<typeof this.start>): Promise<void>;
+    isRunning(): boolean;
+    send(body: {
+        name: string;
+        params: object;
+    }): Promise<import("aws-sdk/lib/request").PromiseResult<AWS.SQS.SendMessageResult, AWS.AWSError>>;
+}

package/lib/index.js

@@ -0,0 +1,103 @@
+"use strict";
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Queue = void 0;
+const events_1 = __importDefault(require("events"));
+const packageName = '@efebia/sqs-queue-v2';
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+class Queue extends events_1.default {
+    constructor(_a) {
+        var { receiveOptions, client } = _a, otherOptions = __rest(_a, ["receiveOptions", "client"]);
+        super();
+        const options = Object.assign({
+            WaitTimeSeconds: 20,
+            MaxNumberOfMessages: 1,
+        }, receiveOptions);
+        this.forever = true;
+        this.receiveOptions = options;
+        this.client = client;
+        this.options = Object.assign({
+            sleepTimeout: 5000,
+        }, otherOptions);
+    }
+    async start(callback, errorCallback, canThrow = false) {
+        while (this.forever) {
+            try {
+                const { Messages } = await this.client
+                    .receiveMessage(this.receiveOptions)
+                    .promise();
+                if (Messages == undefined)
+                    continue;
+                for (const message of Messages) {
+                    await this.processMessage(message, callback);
+                }
+            }
+            catch (error) {
+                if (canThrow)
+                    throw error;
+                await errorCallback(error);
+                await sleep(this.options.sleepTimeout);
+            }
+        }
+    }
+    async processMessage(message, callback) {
+        const { ReceiptHandle, Body: stringifiedBody } = message;
+        if (!ReceiptHandle) {
+            throw new Error(`${packageName}: NO_RECEIPT_HANDLE`);
+        }
+        if (!stringifiedBody) {
+            await this.delete(ReceiptHandle);
+            throw new Error(`${packageName}: EMPTY_BODY`);
+        }
+        const parsedBody = JSON.parse(stringifiedBody);
+        if (Object.keys(parsedBody).length == 0) {
+            await this.delete(ReceiptHandle);
+            return;
+        }
+        const { name, params } = parsedBody;
+        const state = { del: true };
+        if (callback) {
+            await callback(name, params, state);
+            if (state.del) {
+                await this.delete(ReceiptHandle);
+            }
+        }
+        else {
+            this.emit(name, params, ReceiptHandle);
+        }
+    }
+    delete(ReceiptHandle) {
+        return this.client
+            .deleteMessage({ QueueUrl: this.receiveOptions.QueueUrl, ReceiptHandle })
+            .promise();
+    }
+    stop() {
+        this.forever = false;
+    }
+    resume(...args) {
+        this.forever = true;
+        return this.start(...args);
+    }
+    isRunning() {
+        return this.forever;
+    }
+    send(body) {
+        const updatedBody = Object.assign(Object.assign({}, body), { params: Object.assign(Object.assign({}, body.params), { createdAt: new Date() }) });
+        const MessageBody = JSON.stringify(updatedBody);
+        return this.client.sendMessage({ QueueUrl: this.receiveOptions.QueueUrl, MessageBody }).promise();
+    }
+}
+exports.Queue = Queue;

package/package.json

@@ -0,0 +1,19 @@
+{
+  "name": "@efebia/sqs-queue-v2",
+  "version": "0.0.1",
+  "license": "MIT",
+  "devDependencies": {
+    "@types/node": "^18.11.18",
+    "typescript": "^4.9.4"
+  },
+  "dependencies": {
+    "aws-sdk": "^2.1292.0"
+  },
+  "files": [
+    "/lib"
+  ],
+  "scripts": {
+    "build": "tsc"
+  },
+  "main": "./lib"
+}