tspace-mysql 1.9.3 → 1.9.4

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 = 5;
     BATCH_SIZE = 1000;
     MAX_WAIT_MS = 50;
+    POLL = {
+        timeout: null,
+        interval: 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,41 @@ 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.interval = opts.poll?.interval ?? this.POLL.interval;
+            this.POLL.timeout = setInterval(() => {
+                this._pollWorkerJobs();
+            }, this.POLL.interval);
         }
         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)`);
+                console.log([
+                    `\x1b[34mQueue:\x1b[0m`,
+                    `\x1b[38;2;77;215;240mCurrently processing\x1b[0m`,
+                    `${this.ACTIVE_JOBS} job(s)`
+                ].join(' '));
             }
-            await new Promise(r => setTimeout(r, 200));
+            await this._sleep(200);
         }
+        await this._sleep(2000);
+        if (this.POLL.timeout) {
+            clearInterval(this.POLL.interval);
+            this.POLL.timeout = 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 +162,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 +192,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,21 +202,23 @@ 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) {
-                this._flushBuffer(name);
+                this._flushBuffer();
             }
             else if (!this.BUFFER.timeout) {
-                this.BUFFER.timeout = setTimeout(() => this._flushBuffer(name), this.MAX_WAIT_MS);
+                this.BUFFER.timeout = setTimeout(() => this._flushBuffer(), this.MAX_WAIT_MS);
             }
         });
     }
@@ -221,7 +237,11 @@ class Worker extends Model_1.Model {
             }
         });
         if (this.INSPECT_EXEC) {
-            console.log(`\x1b[34mQueue:\x1b[0m \x1b[35m'${name}'\x1b[0m \x1b[32m${QUEUE_STATUS.dispatch}\x1b[0m`);
+            console.log([
+                '\x1b[34mQueue:\x1b[0m',
+                `\x1b[35m'${name}'\x1b[0m`,
+                `\x1b[32m${QUEUE_STATUS.dispatch}\x1b[0m`,
+            ].join(' '));
         }
         const dispatch = async () => {
             if (this.STOPPING)
@@ -230,9 +250,9 @@ class Worker extends Model_1.Model {
             if (!state)
                 return;
             if (state.running >= state.opts.concurrency) {
-                const jitter = Math.random() * 200;
+                const delayMs = opts.interval ?? 1000;
                 state.running--;
-                setTimeout(dispatch, state.opts.interval + jitter);
+                setTimeout(dispatch, delayMs);
                 return;
             }
             const capacity = state.opts.concurrency - state.running;
@@ -242,13 +262,16 @@ class Worker extends Model_1.Model {
                 if (state.idle >= this.MAX_IDLE_RETRIES) {
                     state.sleeping = true;
                     if (this.INSPECT_EXEC) {
-                        console.log(`\x1b[34mQueue:\x1b[0m \x1b[35m'${name}'\x1b[0m \x1b[90m${QUEUE_STATUS.idle} (no jobs available)\x1b[0m`);
+                        console.log([
+                            '\x1b[34mQueue:\x1b[0m',
+                            `\x1b[35m'${name}'\x1b[0m`,
+                            `\x1b[90m${QUEUE_STATUS.idle} (no jobs available)\x1b[0m`,
+                        ].join(' '));
                     }
                     return;
                 }
-                const backoff = Math.min(1000, 50 * state.idle);
-                const jitter = Math.random() * 200;
-                setTimeout(dispatch, opts.interval + backoff + jitter);
+                const delayMs = opts.interval ?? 1000;
+                setTimeout(dispatch, delayMs);
                 return;
             }
             state.idle = 0;
@@ -258,42 +281,95 @@ 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++;
-        const handler = state.handler;
+        const startTime = +new Date();
+        if (job.__job.delay_ms) {
+            setTimeout(async () => {
+                await this._wakeWorker(name);
+                await this._executeJob({ name, job, state, startTime });
+                state.running--;
+                this.ACTIVE_JOBS--;
+            }, job.__job.delay_ms);
+            return;
+        }
+        await this._executeJob({ name, job, state, startTime });
+        state.running--;
+        this.ACTIVE_JOBS--;
+        return;
+    }
+    async _executeJob({ name, job, state, startTime }) {
+        if (this.INSPECT_EXEC) {
+            console.log([
+                '\x1b[34mQueue:\x1b[0m',
+                `\x1b[35m'${name}'\x1b[0m`,
+                `\x1b[38;2;77;215;240m${QUEUE_STATUS.processing}\x1b[0m`,
+                `job \x1b[38;5;208m${job.id}\x1b[0m`,
+            ].join(' '));
+        }
         try {
-            if (this.INSPECT_EXEC) {
-                console.log(`\x1b[34mQueue:\x1b[0m \x1b[35m'${name}'\x1b[0m \x1b[38;2;77;215;240m${QUEUE_STATUS.processing}\x1b[0m job \x1b[38;5;208m${job.id}\x1b[0m`);
-            }
-            const startTime = +new Date();
-            if (job.__job.delay_ms) {
-                await new Promise(r => setTimeout(r, job.__job.delay_ms));
-            }
-            const result = await handler(job);
+            const result = await state.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();
             const endTime = +new Date();
             if (this.INSPECT_EXEC) {
-                console.log(`\x1b[34mQueue:\x1b[0m \x1b[35m'${name}'\x1b[0m \x1b[32m${QUEUE_STATUS.completed}\x1b[0m job \x1b[38;5;208m${job.id}\x1b[0m (${endTime - startTime}ms)`);
+                console.log([
+                    '\x1b[34mQueue:\x1b[0m',
+                    `\x1b[35m'${name}'\x1b[0m`,
+                    `\x1b[32m${QUEUE_STATUS.completed}\x1b[0m`,
+                    `job \x1b[38;5;208m${job.id}\x1b[0m`,
+                    `(${endTime - startTime}ms)`,
+                ].join(' '));
             }
         }
         catch (err) {
             if (this.INSPECT_EXEC) {
-                console.log(`\x1b[34mQueue:\x1b[0m \x1b[35m'${name}'\x1b[0m \x1b[31m${QUEUE_STATUS.failed}\x1b[0m job \x1b[38;5;208m${job.id}\x1b[0m`);
+                console.log([
+                    '\x1b[34mQueue:\x1b[0m',
+                    `\x1b[35m'${name}'\x1b[0m`,
+                    `\x1b[31m${QUEUE_STATUS.failed}\x1b[0m`,
+                    `job \x1b[38;5;208m${job.id}\x1b[0m`,
+                ].join(' '));
             }
             await new Worker()
                 .where('id', job.id)
                 .update({
                 status: 'failed',
-                error: this.safeJsonStringify({
+                error: this._safeJsonStringify({
                     message: err.message,
                     name: err.name,
                     stack: err.stack,
@@ -308,26 +384,40 @@ class Worker extends Model_1.Model {
                 attempts++;
                 try {
                     const startTime = +new Date();
-                    const result = await handler(job);
+                    const result = await state.handler(job);
                     const endTime = +new Date();
                     await new Worker()
                         .where('id', job.id)
                         .update({
                         status: 'completed',
                         attempts,
-                        result: this.safeJsonStringify(result),
-                        completed_at: this.$utils.timestamp()
+                        result: this._safeJsonStringify(result),
+                        completed_at: this.$utils.timestamp(),
                     })
                         .void()
                         .save();
                     if (this.INSPECT_EXEC) {
-                        console.log(`\x1b[34mQueue:\x1b[0m \x1b[35m'${name}'\x1b[0m \x1b[32m${QUEUE_STATUS.retry.completed}\x1b[0m job \x1b[38;5;208m${job.id}\x1b[0m (${endTime - startTime}ms ${attempts}/${maxAttempts})`);
+                        console.log([
+                            '\x1b[34mQueue:\x1b[0m',
+                            `\x1b[35m'${name}'\x1b[0m`,
+                            `\x1b[32m${QUEUE_STATUS.retry.completed}\x1b[0m`,
+                            'job',
+                            `\x1b[38;5;208m${job.id}\x1b[0m`,
+                            `(${endTime - startTime}ms ${attempts}/${maxAttempts})`,
+                        ].join(' '));
                     }
                     break;
                 }
                 catch (err) {
                     if (this.INSPECT_EXEC) {
-                        console.log(`\x1b[34mQueue:\x1b[0m \x1b[35m'${name}'\x1b[0m \x1b[31m${QUEUE_STATUS.retry.attempts}\x1b[0m job \x1b[38;5;208m${job.id}\x1b[0m (${attempts}/${maxAttempts})`);
+                        console.log([
+                            '\x1b[34mQueue:\x1b[0m',
+                            `\x1b[35m'${name}'\x1b[0m`,
+                            `\x1b[31m${QUEUE_STATUS.retry.attempts}\x1b[0m`,
+                            'job',
+                            `\x1b[38;5;208m${job.id}\x1b[0m`,
+                            `(${attempts}/${maxAttempts})`,
+                        ].join(' '));
                     }
                     if (attempts >= maxAttempts) {
                         await new Worker()
@@ -335,7 +425,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,
@@ -346,7 +436,14 @@ class Worker extends Model_1.Model {
                             .void()
                             .save();
                         if (this.INSPECT_EXEC) {
-                            console.log(`\x1b[34mQueue:\x1b[0m \x1b[35m'${name}'\x1b[0m \x1b[31m${QUEUE_STATUS.retry.failed}\x1b[0m job \x1b[38;5;208m${job.id}\x1b[0m (\x1b[33mmax attempts reached\x1b[0m)`);
+                            console.log([
+                                '\x1b[34mQueue:\x1b[0m',
+                                `\x1b[35m'${name}'\x1b[0m`,
+                                `\x1b[31m${QUEUE_STATUS.retry.failed}\x1b[0m`,
+                                'job',
+                                `\x1b[38;5;208m${job.id}\x1b[0m`,
+                                '(\x1b[33mmax attempts reached\x1b[0m)',
+                            ].join(' '));
                         }
                         break;
                     }
@@ -354,48 +451,25 @@ class Worker extends Model_1.Model {
                 }
             }
         }
-        finally {
-            state.running--;
-            this.ACTIVE_JOBS--;
-        }
     }
     async _dequeueMany(name, limit) {
         if (this.STOPPING)
             return [];
+        const now = this.$utils.timestamp();
         const findJobs = await new Worker()
             .select('id')
             .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()}'`]);
-            })
-                .orWhereQuery((q) => {
-                return q
-                    .where('status', '=', 'active')
-                    .where('locked_at', '<', this.$utils.timestamp(new Date(Date.now() - 60 * 1000)));
-            });
+                .where('status', 'pending')
+                .where('created_at', '<', now)
+                .whereNull('locked_at');
         })
             .latest('priority')
+            .oldest('delay_ms')
             .oldest('id')
             .limit(limit)
-            .get();
+            .findMany();
         if (!findJobs.length) {
             return [];
         }
@@ -403,11 +477,12 @@ class Worker extends Model_1.Model {
             const jobs = await new Worker()
                 .whereIn('id', findJobs.map(v => v.id))
                 .latest('priority')
+                .oldest('delay_ms')
                 .oldest('id')
                 .limit(limit)
                 .forUpdate({ skipLocked: true })
                 .bind(trx)
-                .get();
+                .findMany();
             if (!jobs.length) {
                 return [];
             }
@@ -426,12 +501,12 @@ 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
             }));
         });
     }
-    async _flushBuffer(name) {
+    async _flushBuffer() {
         if (this.IS_FLUSHING || this.BUFFER.jobs.length === 0)
             return;
         if (this.BUFFER.timeout) {
@@ -445,21 +520,36 @@ class Worker extends Model_1.Model {
         try {
             const jobsToInsert = currentBatch.map(b => b.jobData);
             const insertedJobds = await new Worker()
-                .select('id')
+                .select('id', 'name')
                 .insertMany(jobsToInsert)
                 .save();
             if (this.INSPECT_EXEC) {
-                const ids = insertedJobds.map(v => v.id);
-                const preview = [
-                    ...ids.slice(0, 3),
-                    "...",
-                    ...ids.slice(-2),
-                ].join(', ');
-                if (ids.length === 1) {
-                    console.log(`\x1b[34mQueue:\x1b[0m \x1b[35m'${name}'\x1b[0m \x1b[32m${QUEUE_STATUS.receive}\x1b[0m job \x1b[38;5;208m${ids}\x1b[0m`);
-                }
-                else {
-                    console.log(`\x1b[34mQueue:\x1b[0m \x1b[35m'${name}'\x1b[0m \x1b[32m${QUEUE_STATUS.receive}\x1b[0m jobs [\x1b[38;5;208m${preview}\x1b[0m] total=(\x1b[38;5;208m${ids.length}\x1b[0m)`);
+                const names = [...new Set(insertedJobds.map(job => job.name))];
+                for (const name of names) {
+                    const ids = insertedJobds.filter(v => v.name === name).map(v => v.id);
+                    const preview = [
+                        ...ids.slice(0, 3),
+                        ...(ids.length > 3 ? ['...', ...ids.slice(Math.max(3, ids.length - 2))] : [])
+                    ].join(', ');
+                    if (ids.length === 1) {
+                        console.log([
+                            '\x1b[34mQueue:\x1b[0m',
+                            `\x1b[35m'${name}'\x1b[0m`,
+                            `\x1b[32m${QUEUE_STATUS.receive}\x1b[0m`,
+                            'job',
+                            `\x1b[38;5;208m${ids}\x1b[0m`,
+                        ].join(' '));
+                    }
+                    else {
+                        console.log([
+                            '\x1b[34mQueue:\x1b[0m',
+                            `\x1b[35m'${name}'\x1b[0m`,
+                            `\x1b[32m${QUEUE_STATUS.receive}\x1b[0m`,
+                            'jobs',
+                            `[\x1b[38;5;208m${preview}\x1b[0m]`,
+                            `total=(\x1b[38;5;208m${ids.length}\x1b[0m)`,
+                        ].join(' '));
+                    }
                 }
             }
             for (let i = 0; i < currentBatch.length; i++) {
@@ -475,11 +565,11 @@ class Worker extends Model_1.Model {
         }
         finally {
             if (this.BUFFER.jobs.length) {
-                this._flushBuffer(name);
+                this._flushBuffer();
             }
         }
     }
-    _wakeWorker(name) {
+    async _wakeWorker(name) {
         const state = this.WORKER_STATE.get(name);
         if (!state || !state.sleeping || !state.handler)
             return;
@@ -487,15 +577,60 @@ class Worker extends Model_1.Model {
         state.sleeping = false;
         state.idle = 0;
         if (this.INSPECT_EXEC) {
-            console.log(`\x1b[34mQueue:\x1b[0m \x1b[35m'${name}'\x1b[0m \x1b[36m${QUEUE_STATUS.wokeUp}\x1b[0m`);
+            console.log([
+                '\x1b[34mQueue:\x1b[0m',
+                `\x1b[35m'${name}'\x1b[0m`,
+                `\x1b[36m${QUEUE_STATUS.wokeUp}\x1b[0m`,
+            ].join(' '));
         }
         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)`,
+            ].join(' '));
         }
+        ;
+        return jobs;
     }
-    safeJsonParse(payload) {
+    _safeJsonParse(payload) {
         try {
             return JSON.parse(payload);
         }
@@ -503,7 +638,7 @@ class Worker extends Model_1.Model {
             return payload;
         }
     }
-    safeJsonStringify(payload) {
+    _safeJsonStringify(payload) {
         if (payload == null)
             return null;
         try {
@@ -524,203 +659,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