@efebia/queue 0.0.1

package/lib/index.d.ts

@@ -0,0 +1,2 @@
+export * from './memory';
+export * from './queue';

package/lib/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./memory"), exports);
+__exportStar(require("./queue"), exports);

package/lib/memory.d.ts

@@ -0,0 +1,8 @@
+import { Queue, QueueCallback, QueueOptions, SentMessage } from "./queue";
+export declare class MemoryQueue<TMessage extends object> extends Queue<SentMessage<TMessage>, TMessage> {
+    messages: SentMessage<TMessage>[];
+    constructor(opts: Partial<QueueOptions>);
+    readMessages(): Promise<SentMessage<TMessage>[] | undefined>;
+    processMessage(message: SentMessage<TMessage>, callback?: QueueCallback<TMessage> | undefined): Promise<void>;
+    sendMessage(body: SentMessage<TMessage>): void;
+}

package/lib/memory.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemoryQueue = void 0;
+const queue_1 = require("./queue");
+const utils_1 = require("./utils");
+class MemoryQueue extends queue_1.Queue {
+    constructor(opts) {
+        super(opts);
+        this.messages = [];
+    }
+    async readMessages() {
+        if (this.messages.length === 0) {
+            await (0, utils_1.sleep)(100);
+            return undefined;
+        }
+        return [this.messages.at(0)];
+    }
+    async processMessage(message, callback) {
+        const { name, params } = message;
+        if (!callback)
+            return;
+        const state = { del: true };
+        await callback(name, params, state);
+        if (state.del) {
+            this.messages.shift();
+        }
+    }
+    sendMessage(body) {
+        this.messages.push(body);
+    }
+}
+exports.MemoryQueue = MemoryQueue;

package/lib/queue.d.ts

@@ -0,0 +1,29 @@
+export type QueueOptions = {
+    sleepTimeout: number;
+    errorCallback: (error: any) => void | Promise<void>;
+};
+export type QueueCallback<TMessage> = (name: string, params: TMessage, state: {
+    del: boolean;
+}) => void | Promise<void>;
+export type Message<TParams> = {
+    name: string;
+    params: TParams;
+};
+export type SentMessage<TParams> = Message<TParams> & {
+    params: {
+        createdAt: Date;
+    };
+};
+export declare abstract class Queue<TReceivedMessage, TMessage extends object = object> {
+    forever: boolean;
+    options: QueueOptions;
+    constructor(opts: Partial<QueueOptions>);
+    abstract readMessages(): TReceivedMessage[] | Promise<TReceivedMessage[] | undefined> | undefined;
+    abstract processMessage(message: TReceivedMessage, callback?: QueueCallback<TMessage>): void | Promise<void>;
+    abstract sendMessage(body: SentMessage<TMessage>): void | Promise<void>;
+    start(callback: QueueCallback<TMessage>, canThrow?: boolean): Promise<void>;
+    stop(): void;
+    resume(...args: Parameters<typeof this.start>): Promise<void>;
+    isRunning(): boolean;
+    send(body: Message<TMessage>): void;
+}

package/lib/queue.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Queue = void 0;
+const utils_1 = require("./utils");
+class Queue {
+    constructor(opts) {
+        this.forever = true;
+        this.options = Object.assign({
+            sleepTimeout: 5000,
+            errorCallback: (e) => console.error(e)
+        }, opts);
+    }
+    async start(callback, canThrow = false) {
+        while (this.forever) {
+            try {
+                const messages = await this.readMessages();
+                if (messages === undefined)
+                    continue;
+                for (const message of messages) {
+                    await this.processMessage(message, callback);
+                }
+            }
+            catch (error) {
+                if (canThrow)
+                    throw error;
+                await this.options.errorCallback(error);
+                await (0, utils_1.sleep)(this.options.sleepTimeout);
+            }
+        }
+    }
+    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() }) });
+        this.sendMessage(updatedBody);
+    }
+}
+exports.Queue = Queue;

package/lib/utils.d.ts

@@ -0,0 +1 @@
+export declare const sleep: (ms: number) => Promise<unknown>;

package/lib/utils.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sleep = void 0;
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+exports.sleep = sleep;

package/package.json

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