tspace-mysql 1.9.2 → 1.9.3-beta.2

package/dist/lib/core/Queue/worker.d.ts

@@ -0,0 +1,102 @@
+import type { T } from "../UtilityTypes";
+import { Blueprint } from "../Blueprint";
+import { Model } from "../Model";
+import type { Handler, QueueAddOptions, QueueProcessOptions } from "./types";
+declare const schema: {
+    id: Blueprint<number>;
+    uuid: Blueprint<string | null>;
+    name: Blueprint<string>;
+    status: Blueprint<T.Default<NonNullable<"pending" | "active" | "completed" | "failed">>>;
+    priority: Blueprint<T.Default<number>>;
+    payload: Blueprint<string | null>;
+    result: Blueprint<string | null>;
+    error: Blueprint<string | null>;
+    metadata: Blueprint<string | null>;
+    attempts: Blueprint<T.Default<number>>;
+    max_attempts: Blueprint<T.Default<number>>;
+    delay_ms: Blueprint<T.Default<number>>;
+    locked_by: Blueprint<string | null>;
+    locked_at: Blueprint<T.DateTime | null>;
+    available_at: Blueprint<NonNullable<T.DateTime>>;
+    completed_at: Blueprint<T.DateTime | null>;
+    created_at: Blueprint<T.DateTime | null>;
+    updated_at: Blueprint<T.DateTime | null>;
+};
+export declare class Worker extends Model<T.Schema<typeof schema>> {
+    private HOSTNAME;
+    private INSPECT_EXEC;
+    private STOPPING;
+    private IS_FLUSHING;
+    private ACTIVE_JOBS;
+    private MAX_IDLE_RETRIES;
+    private BATCH_SIZE;
+    private MAX_WAIT_MS;
+    private POLL;
+    private BUFFER;
+    private WORKER_STATE;
+    private EVENT_SUBSCRIBERS;
+    protected boot(): void;
+    initialize(opts?: {
+        inspect?: boolean;
+        flush?: boolean;
+        hostname?: string;
+        maxIdleRetries?: number;
+        poll?: {
+            enabled?: boolean;
+            timeout?: number;
+        };
+    }): Promise<this>;
+    shutdown(): Promise<void>;
+    flush(): Promise<void>;
+    getJobOverallStats(name?: string): Promise<{
+        total: number;
+        completed: number;
+        active: number;
+        pending: number;
+        failed: number;
+    }>;
+    getJobStats(name?: string): Promise<{
+        name: string;
+        completed: number;
+        active: number;
+        pending: number;
+        failed: number;
+    }[]>;
+    getJobs(name?: string): Promise<{
+        [x: string]: unknown;
+        id: number;
+        uuid: string | null;
+        name: string;
+        status: "pending" | "active" | "completed" | "failed";
+        priority: number;
+        payload: string | null;
+        result: string | null;
+        error: string | null;
+        metadata: string | null;
+        attempts: number;
+        max_attempts: number;
+        delay_ms: number;
+        locked_by: string | null;
+        locked_at: T.DateTime | null;
+        available_at: NonNullable<T.DateTime>;
+        completed_at: T.DateTime | null;
+        created_at: T.DateTime | null;
+        updated_at: T.DateTime | null;
+    }[]>;
+    getNames(): Promise<any[]>;
+    add(name: string, payload: any, opts?: QueueAddOptions): Promise<void>;
+    process(name: string, handler: Handler, opts?: QueueProcessOptions): Promise<void>;
+    publish(event: string, payload: any, opts?: QueueAddOptions): Promise<void>;
+    subscribe(event: string, name: string, handler: Handler, opts?: QueueProcessOptions): Promise<void>;
+    private _runJob;
+    private _dequeueMany;
+    private _flushBuffer;
+    private _wakeWorker;
+    private _pollWorkerJobs;
+    private _initializeWorkerJobs;
+    private _getPendingOrFailedJobs;
+    private _safeJsonParse;
+    private _safeJsonStringify;
+    private _sleep;
+}
+export {};

package/dist/lib/core/{Queue.js → Queue/worker.js}

@@ -1,11 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Queue = void 0;
-const Blueprint_1 = require("./Blueprint");
-const DB_1 = require("./DB");
+exports.Worker = void 0;
+const Blueprint_1 = require("../Blueprint");
+const DB_1 = require("../DB");
 ;
-const Model_1 = require("./Model");
-const Meta_1 = require("./Meta");
+const Model_1 = require("../Model");
 const QUEUE_STATUS = {
     dispatch: 'Dispatch',
     receive: 'Receive',
@@ -49,27 +48,31 @@ const schema = {
     max_attempts: Blueprint_1.Blueprint.int().default(3),
     delay_ms: Blueprint_1.Blueprint.int().default(0),
     locked_by: Blueprint_1.Blueprint.text().null(),
-    locked_at: Blueprint_1.Blueprint.timestamp().null(),
-    available_at: Blueprint_1.Blueprint.timestamp().notNull(),
-    completed_at: Blueprint_1.Blueprint.timestamp().null(),
-    created_at: Blueprint_1.Blueprint.timestamp().null(),
-    updated_at: Blueprint_1.Blueprint.timestamp().null()
+    locked_at: Blueprint_1.Blueprint.datetime().null(),
+    available_at: Blueprint_1.Blueprint.datetime().notNull(),
+    completed_at: Blueprint_1.Blueprint.datetime().null(),
+    created_at: Blueprint_1.Blueprint.datetime().null(),
+    updated_at: Blueprint_1.Blueprint.datetime().null()
 };
 class Worker extends Model_1.Model {
     HOSTNAME = String(process.env?.hostname ?? 'unknown');
     INSPECT_EXEC = false;
     STOPPING = false;
     IS_FLUSHING = false;
-    LIMIT_CONNECTIONS = 41;
-    MAX_IDLE_RETRIES = 15;
     ACTIVE_JOBS = 0;
+    MAX_IDLE_RETRIES = 3;
     BATCH_SIZE = 1000;
     MAX_WAIT_MS = 50;
+    POLL = {
+        interval: null,
+        timeout: 1000 * 60
+    };
     BUFFER = {
         jobs: [],
         timeout: null
     };
     WORKER_STATE = new Map();
+    EVENT_SUBSCRIBERS = new Map();
     boot() {
         this.useUUID();
         this.useTimestamp();
@@ -82,6 +85,7 @@ class Worker extends Model_1.Model {
             throw new Error('Queue is not supported for MongoDB. Use a different driver or disable queue features.');
         }
         await this.sync({ force: true, index: true }).catch(() => null);
+        await this._initializeWorkerJobs();
         if (opts.inspect) {
             this.INSPECT_EXEC = true;
             console.log(`\x1b[34mQueue:\x1b[0m \x1b[32mJob processing started\x1b[0m`);
@@ -95,31 +99,37 @@ class Worker extends Model_1.Model {
         if (opts.maxIdleRetries) {
             this.MAX_IDLE_RETRIES = opts.maxIdleRetries;
         }
-        if (opts.limitConnections) {
-            this.LIMIT_CONNECTIONS = opts.limitConnections;
-        }
-        else {
-            const maxConnections = await DB_1.DB.getMaxConnections().catch(() => null);
-            this.LIMIT_CONNECTIONS = maxConnections
-                ? Math.max(10, Math.floor(maxConnections / 3))
-                : this.LIMIT_CONNECTIONS;
+        if (opts.poll?.enabled) {
+            this.POLL.timeout = opts.poll?.timeout ?? this.POLL.timeout;
+            this.POLL.interval = setInterval(() => {
+                this._pollWorkerJobs();
+            }, this.POLL.timeout);
         }
         return this;
     }
     async shutdown() {
-        this.STOPPING = true;
         while (this.ACTIVE_JOBS > 0) {
             if (this.INSPECT_EXEC) {
                 console.log(`\x1b[34mQueue:\x1b[0m Currently processing ${this.ACTIVE_JOBS} job(s)`);
             }
-            await new Promise(r => setTimeout(r, 200));
+            await this._sleep(200);
+        }
+        await this._sleep(2000);
+        if (this.POLL.interval) {
+            clearInterval(this.POLL.timeout);
+            this.POLL.interval = null;
         }
+        this.STOPPING = true;
         if (this.INSPECT_EXEC) {
-            console.log("\x1b[34mQueue:\x1b[0m \x1b[32mJob processing stopped\x1b[0m");
+            console.log("\x1b[34mQueue:\x1b[0m \x1b[31mJob processing stopped\x1b[0m");
         }
     }
     async flush() {
+        const jobs = await new Worker().count('id');
         await this.truncate({ force: true });
+        if (this.INSPECT_EXEC) {
+            console.log(`\x1b[34mQueue:\x1b[0m \x1b[31mFlush all jobs (${jobs} jobs)\x1b[0m`);
+        }
         return;
     }
     async getJobOverallStats(name) {
@@ -148,7 +158,7 @@ class Worker extends Model_1.Model {
             .when(name, (q) => q.where('name', 'LIKE', `%${DB_1.DB.escape(name)}%`))
             .groupBy('name', 'status')
             .orderBy('name')
-            .get();
+            .findMany();
         const map = new Map();
         for (const row of rows) {
             const name = row.name;
@@ -178,7 +188,7 @@ class Worker extends Model_1.Model {
     async getJobs(name) {
         const jobs = await new Worker()
             .when(name != null, (q) => q.where('name', 'LIKE', `%${DB_1.DB.escape(name)}%`))
-            .get();
+            .findMany();
         return jobs;
     }
     async getNames() {
@@ -188,14 +198,16 @@ class Worker extends Model_1.Model {
         return new Promise((resolve, reject) => {
             const jobData = {
                 name,
-                payload: payload == null ? null : this.safeJsonStringify(payload),
+                payload: payload == null ? null : this._safeJsonStringify(payload),
                 status: 'pending',
-                delay_ms: opts.delayMs ?? 0,
-                available_at: opts.delayMs ? new Date(Date.now() + opts.delayMs) : new Date(),
                 priority: opts.priority ?? 0,
                 attempts: 0,
                 max_attempts: opts.maxAttempts ?? 3,
-                metadata: opts.metadata ? this.safeJsonStringify(opts.metadata) : null
+                metadata: opts.metadata ? this._safeJsonStringify(opts.metadata) : null,
+                delay_ms: opts.delayMs ?? 0,
+                available_at: opts.delayMs ? new Date(Date.now() + opts.delayMs) : new Date(),
+                created_at: new Date(),
+                updated_at: new Date()
             };
             this.BUFFER.jobs.push({ jobData, resolve, reject });
             if (this.BUFFER.jobs.length >= this.BATCH_SIZE) {
@@ -230,9 +242,10 @@ class Worker extends Model_1.Model {
             if (!state)
                 return;
             if (state.running >= state.opts.concurrency) {
-                const jitter = Math.random() * 200;
+                const jitter = Math.floor(Math.random() * 2000) + 500;
+                const delayMs = (state.opts.interval ?? 0) + jitter;
                 state.running--;
-                setTimeout(dispatch, state.opts.interval + jitter);
+                setTimeout(dispatch, delayMs);
                 return;
             }
             const capacity = state.opts.concurrency - state.running;
@@ -246,9 +259,9 @@ class Worker extends Model_1.Model {
                     }
                     return;
                 }
-                const backoff = Math.min(1000, 50 * state.idle);
-                const jitter = Math.random() * 200;
-                setTimeout(dispatch, opts.interval + backoff + jitter);
+                const jitter = Math.floor(Math.random() * 4000) + 1000;
+                const delayMs = (opts.interval ?? 0) + jitter;
+                setTimeout(dispatch, delayMs);
                 return;
             }
             state.idle = 0;
@@ -258,6 +271,26 @@ class Worker extends Model_1.Model {
         };
         return dispatch();
     }
+    async publish(event, payload, opts = {}) {
+        const subscribers = this.EVENT_SUBSCRIBERS.get(event);
+        if (!subscribers || subscribers.size === 0) {
+            return;
+        }
+        await Promise.all([...subscribers].map(name => this.add(name, payload, opts)));
+    }
+    async subscribe(event, name, handler, opts = {
+        interval: 1_000,
+        concurrency: 1
+    }) {
+        const jobName = `${event}.${name}`;
+        if (!this.EVENT_SUBSCRIBERS.has(event)) {
+            this.EVENT_SUBSCRIBERS.set(event, new Set());
+        }
+        this.EVENT_SUBSCRIBERS
+            .get(event)
+            .add(jobName);
+        await this.process(jobName, handler, opts);
+    }
     async _runJob(name, job, state) {
         state.running++;
         this.ACTIVE_JOBS++;
@@ -268,15 +301,21 @@ class Worker extends Model_1.Model {
             }
             const startTime = +new Date();
             if (job.__job.delay_ms) {
-                await new Promise(r => setTimeout(r, job.__job.delay_ms));
+                await this._sleep(job.__job.delay_ms);
             }
-            const result = await handler(job);
+            const result = await handler({
+                id: job.id,
+                name: job.name,
+                status: job.status,
+                payload: job.payload
+            });
             await new Worker()
                 .where('id', job.id)
                 .update({
                 status: 'completed',
-                result: this.safeJsonStringify(result),
-                completed_at: this.$utils.timestamp()
+                result: this._safeJsonStringify(result),
+                completed_at: this.$utils.timestamp(),
+                attempts: 0
             })
                 .void()
                 .save();
@@ -293,7 +332,7 @@ class Worker extends Model_1.Model {
                 .where('id', job.id)
                 .update({
                 status: 'failed',
-                error: this.safeJsonStringify({
+                error: this._safeJsonStringify({
                     message: err.message,
                     name: err.name,
                     stack: err.stack,
@@ -315,8 +354,8 @@ class Worker extends Model_1.Model {
                         .update({
                         status: 'completed',
                         attempts,
-                        result: this.safeJsonStringify(result),
-                        completed_at: this.$utils.timestamp()
+                        result: this._safeJsonStringify(result),
+                        completed_at: this.$utils.timestamp(),
                     })
                         .void()
                         .save();
@@ -335,7 +374,7 @@ class Worker extends Model_1.Model {
                             .update({
                             status: 'failed',
                             attempts,
-                            error: this.safeJsonStringify({
+                            error: this._safeJsonStringify({
                                 retry: true,
                                 message: err?.message,
                                 name: err?.name,
@@ -367,25 +406,8 @@ class Worker extends Model_1.Model {
             .where('name', name)
             .whereQuery(query => {
             return query
-                .where('status', '=', 'pending')
-                .when(DB_1.DB.driver() === 'mysql' || DB_1.DB.driver() === 'mariadb', (q) => {
-                return q.whereRaw(`DATE_SUB(
-                        ${(0, Meta_1.Meta)(Worker).columnRef('available_at')}, 
-                        INTERVAL (${(0, Meta_1.Meta)(Worker).columnRef('delay_ms')} * 1000) MICROSECOND
-                    ) <= ?`, [`'${this.$utils.timestamp()}'`]);
-            })
-                .when(DB_1.DB.driver() === 'postgres', (q) => {
-                return q.whereRaw(`${(0, Meta_1.Meta)(Worker).columnRef('available_at')}
-                    - 
-                    (${(0, Meta_1.Meta)(Worker).columnRef('delay_ms')} * INTERVAL '1 millisecond')
-                    <= ?`, [`'${this.$utils.timestamp()}'`]);
-            })
-                .when(DB_1.DB.driver() === 'sqlite', (q) => {
-                return q.whereRaw(`datetime(
-                        ${(0, Meta_1.Meta)(Worker).columnRef('available_at')},
-                        '-' || (${(0, Meta_1.Meta)(Worker).columnRef('delay_ms')} / 1000.0) || ' seconds'
-                    ) <= ?`, [`'${this.$utils.timestamp()}'`]);
-            })
+                .whereIn('status', ['pending'])
+                .where('created_at', '<=', this.$utils.timestamp())
                 .orWhereQuery((q) => {
                 return q
                     .where('status', '=', 'active')
@@ -395,7 +417,7 @@ class Worker extends Model_1.Model {
             .latest('priority')
             .oldest('id')
             .limit(limit)
-            .get();
+            .findMany();
         if (!findJobs.length) {
             return [];
         }
@@ -407,7 +429,7 @@ class Worker extends Model_1.Model {
                 .limit(limit)
                 .forUpdate({ skipLocked: true })
                 .bind(trx)
-                .get();
+                .findMany();
             if (!jobs.length) {
                 return [];
             }
@@ -426,7 +448,7 @@ class Worker extends Model_1.Model {
                 id: job.id,
                 name: job.name,
                 status: job.status,
-                payload: this.safeJsonParse(job.payload),
+                payload: this._safeJsonParse(job.payload),
                 __job: job
             }));
         });
@@ -479,7 +501,7 @@ class Worker extends Model_1.Model {
             }
         }
     }
-    _wakeWorker(name) {
+    async _wakeWorker(name) {
         const state = this.WORKER_STATE.get(name);
         if (!state || !state.sleeping || !state.handler)
             return;
@@ -490,12 +512,49 @@ class Worker extends Model_1.Model {
             console.log(`\x1b[34mQueue:\x1b[0m \x1b[35m'${name}'\x1b[0m \x1b[36m${QUEUE_STATUS.wokeUp}\x1b[0m`);
         }
         if (isSleeping) {
-            this.process(name, state.handler, {
-                concurrency: state.opts.concurrency
-            });
+            await this.process(name, state.handler, state.opts);
+        }
+        return;
+    }
+    async _pollWorkerJobs() {
+        const jobs = await this._getPendingOrFailedJobs();
+        for (const job of jobs) {
+            this._wakeWorker(job);
+        }
+        return;
+    }
+    async _initializeWorkerJobs() {
+        const jobs = await this._getPendingOrFailedJobs();
+        await Promise.all(jobs.map(job => this._wakeWorker(job)));
+        return;
+    }
+    async _getPendingOrFailedJobs() {
+        const jobsToProcess = await new Worker()
+            .select('id')
+            .whereIn('status', ['pending', 'failed'])
+            .where('available_at', '<=', this.$utils.timestamp())
+            .findMany();
+        await new Worker()
+            .updateMany({
+            status: 'pending',
+            attempts: 0
+        })
+            .whereIn('id', jobsToProcess.map(f => f.id))
+            .void()
+            .save();
+        const jobs = await new Worker()
+            .select('name')
+            .where('status', 'pending')
+            .where('available_at', '<=', this.$utils.timestamp())
+            .groupBy('name')
+            .toArray('name');
+        if (this.INSPECT_EXEC) {
+            console.log(`\x1b[34mQueue:\x1b[0m \x1b[32mPoll checked\x1b[0m (${jobs.length} jobs)`);
         }
+        ;
+        return jobs;
     }
-    safeJsonParse(payload) {
+    _safeJsonParse(payload) {
         try {
             return JSON.parse(payload);
         }
@@ -503,7 +562,7 @@ class Worker extends Model_1.Model {
             return payload;
         }
     }
-    safeJsonStringify(payload) {
+    _safeJsonStringify(payload) {
         if (payload == null)
             return null;
         try {
@@ -524,203 +583,9 @@ class Worker extends Model_1.Model {
             return payload;
         }
     }
-}
-/**
- * Queue facade class (static API wrapper)
- *
- * This class provides a singleton-style interface over the underlying Worker instance.
- * It must be initialized before use via `Queue.start()`.
- *
- * @example
- * ```ts
- * const sendEmail = (job) => console.log('send mail :' + job.payload.email)
- *
- * await Queue.start({ inspect : true, flush : true // **remove all jobs });
- *
- * // register
- * Queue.progress("send-email", async (job) => {
- *     return await sendEmail(job);
- * }, { concurrency : 3 });
- *
- * // add
- * Queue.add("send-email", { email: "test@gmail.com" });
- *
- * ```
- */
-class Queue {
-    /**
-     * Internal Worker instance used for all queue operations.
-     * @type {Worker | null}
-     */
-    static WORKER;
-    static MESSAGE = {
-        INIT_ERROR: `Queue is not initialized. Please call 'await Queue.start()' before using it.`
-    };
-    /**
-     * The 'start' method is used to initialize the Queue system.
-     * Creates and prepares the underlying Worker instance.
-     * @param {Object} [opts] - options (inspect, flush)
-     * @property {boolean} opts.inspect queue work flow
-     * @property {boolean} opts.flush  remove all queue
-     * @property {number} opts.maxIdleRetries - Maximum idle time () when no jobs are available
-     * @property {number} opts.limitConnections - Allowed DB connections limit before pausing
-     * @returns {Promise<void>}
-     */
-    static async start(opts = {}) {
-        this.WORKER = await new Worker().initialize(opts);
-        return;
-    }
-    /**
-     * The 'end' method is used to shutdown the Queue system.
-     *
-     * @returns {Promise<void>}
-     */
-    static async end() {
-        if (this.WORKER == null) {
-            throw new Error(this.MESSAGE.INIT_ERROR);
-        }
-        await this.WORKER.shutdown();
-        this.WORKER = null;
-        return;
-    }
-    /**
-     * The 'flush' method is used to flush all jobs in the queue (dangerous operation).
-     *
-     * @throws {Error} If Queue is not initialized.
-     * @returns {Promise<void>}
-     */
-    static async flush() {
-        if (this.WORKER == null) {
-            throw new Error(this.MESSAGE.INIT_ERROR);
-        }
-        await this.WORKER.flush();
-    }
-    /**
-     * The 'getJobOverallStats' method is used to get aggregated queue statistics.
-     *
-     * @param {string} [name] - Optional queue name filter.
-     * @throws {Error} If Queue is not initialized.
-     * @returns {Promise<any>}
-     */
-    static async getJobOverallStats(name) {
-        if (this.WORKER == null) {
-            throw new Error(this.MESSAGE.INIT_ERROR);
-        }
-        return await this.WORKER.getJobOverallStats(name);
-    }
-    /**
-     * The 'getJobStats' method is used to Get jobs statistics grouped by name.
-     *
-     * @param {string} [name] - Optional queue name filter.
-     * @throws {Error} If Queue is not initialized.
-     * @returns {Promise<any>}
-     */
-    static async getJobStats(name) {
-        if (this.WORKER == null) {
-            throw new Error(this.MESSAGE.INIT_ERROR);
-        }
-        return await this.WORKER.getJobStats(name);
-    }
-    /**
-     * The 'getJobs' method is used to Get jobs.
-     *
-     * @param {string} [name] - Optional queue name filter.
-     * @throws {Error} If Queue is not initialized.
-     * @returns {Promise<T.Result<Worker>[]>}
-     */
-    static async getJobs(name) {
-        if (this.WORKER == null) {
-            throw new Error(this.MESSAGE.INIT_ERROR);
-        }
-        return await this.WORKER.getJobs(name);
-    }
-    /**
-     * Get all unique queue names.
-     *
-     * @throws {Error} If Queue is not initialized.
-     * @returns {Promise<string[]>}
-     */
-    static async getNames() {
-        if (this.WORKER == null) {
-            throw new Error(this.MESSAGE.INIT_ERROR);
-        }
-        return await this.WORKER.getNames();
-    }
-    /**
-     * Access raw Worker instance safely.
-     *
-     * @param {(worker: Worker) => any} cb - Callback with Worker instance.
-     * @throws {Error} If Queue is not initialized.
-     * @returns {Promise<Work>}
-     */
-    static async worker(cb) {
-        if (this.WORKER == null) {
-            throw new Error(this.MESSAGE.INIT_ERROR);
-        }
-        return await cb(this.WORKER);
-    }
-    /**
-     * Start a worker for processing jobs of a specific name.
-     *
-     * @param {string} name - Queue name to process.
-     * @param {Handler} handler - Job handler function.
-     * @param {QueueProcessOptions} [opts] - Job options (interval, concurrency)
-     * @throws {Error} If Queue is not initialized.
-     * @returns {Promise<void>}
-     *
-     * @example
-     * const helloWorld = (job) => console.log('hello world :' + job.id);
-     *
-     * Queue.progress("hello", async (job) => {
-     *  return await helloWorld(job)
-     * }, { concurrency : 3 });
-     */
-    static async process(name, handler, opts = { interval: 1_000, concurrency: 1 }) {
-        if (this.WORKER == null) {
-            throw new Error(this.MESSAGE.INIT_ERROR);
-        }
-        return await this.WORKER.process(name, handler, opts);
-    }
-    /**
-     * Start a worker for processing jobs of a specific name.
-     *
-     * @param {string} name - Queue name to process.
-     * @param {Handler} handler - Job handler function.
-     * @param {QueueProcessOptions} [opts] - Job options (interval, concurrency)
-     * @throws {Error} If Queue is not initialized.
-     * @returns {Promise<void>}
-     *
-     * @example
-     * const helloWorld = (job) => console.log('hello world :' + job.id);
-     *
-     * Queue.on("hello", async (job) => {
-     *  return await helloWorld(job)
-     * }, { concurrency : 3 });
-     */
-    static async on(name, handler, opts = { interval: 1_000, concurrency: 1 }) {
-        return await this.process(name, handler, opts);
-    }
-    /**
-     * Add a new job into the queue.
-     *
-     * @param {string} name - Queue name / job type.
-     * @param {any} payload - Job payload data.
-     * @param {QueueAddOptions} [opts] - Job options (delay, priority, retry, etc.)
-     * @throws {Error} If Queue is not initialized.
-     * @returns {Promise<T.Result<Worker>>}
-     *
-     * @example
-     * ```ts
-     * Queue.add("send-email", { email: "test@gmail.com" });
-     * ```
-     */
-    static async add(name, payload, opts = {}) {
-        if (this.WORKER == null) {
-            throw new Error(this.MESSAGE.INIT_ERROR);
-        }
-        return await this.WORKER.add(name, payload, opts);
+    async _sleep(ms) {
+        return await new Promise(r => setTimeout(r, ms));
     }
 }
-exports.Queue = Queue;
-exports.default = Queue;
-//# sourceMappingURL=Queue.js.map
+exports.Worker = Worker;
+//# sourceMappingURL=worker.js.map