bunqueue 1.9.9 → 2.0.1

package/dist/client/queue/queue.js

@@ -51,28 +51,93 @@ export class Queue {
     /** Add a job to the queue */
     async add(name, data, opts = {}) {
         const merged = { ...this.opts.defaultJobOptions, ...opts };
+        // Add parent info to data if specified (BullMQ v5 flow support)
+        const jobData = { name, ...data };
+        if (merged.parent) {
+            jobData.__parentId = merged.parent.id;
+            jobData.__parentQueue = merged.parent.queue;
+        }
         if (this.embedded) {
             const manager = getSharedManager();
+            // Parse removeOnComplete/removeOnFail (can be boolean, number, or KeepJobs)
+            const removeOnComplete = typeof merged.removeOnComplete === 'boolean' ? merged.removeOnComplete : false;
+            const removeOnFail = typeof merged.removeOnFail === 'boolean' ? merged.removeOnFail : false;
+            // Parse repeat options with extended BullMQ v5 fields
+            const repeat = merged.repeat
+                ? {
+                    every: merged.repeat.every,
+                    limit: merged.repeat.limit,
+                    pattern: merged.repeat.pattern,
+                    count: merged.repeat.count,
+                    startDate: merged.repeat.startDate instanceof Date
+                        ? merged.repeat.startDate.getTime()
+                        : typeof merged.repeat.startDate === 'string'
+                            ? new Date(merged.repeat.startDate).getTime()
+                            : merged.repeat.startDate,
+                    endDate: merged.repeat.endDate instanceof Date
+                        ? merged.repeat.endDate.getTime()
+                        : typeof merged.repeat.endDate === 'string'
+                            ? new Date(merged.repeat.endDate).getTime()
+                            : merged.repeat.endDate,
+                    tz: merged.repeat.tz,
+                    immediately: merged.repeat.immediately,
+                    prevMillis: merged.repeat.prevMillis,
+                    offset: merged.repeat.offset,
+                    jobId: merged.repeat.jobId,
+                }
+                : undefined;
             const job = await manager.push(this.name, {
-                data: { name, ...data },
+                data: jobData,
                 priority: merged.priority,
                 delay: merged.delay,
                 maxAttempts: merged.attempts,
                 backoff: merged.backoff,
                 timeout: merged.timeout,
-                customId: merged.jobId,
-                removeOnComplete: merged.removeOnComplete,
-                removeOnFail: merged.removeOnFail,
-                repeat: merged.repeat,
+                customId: merged.jobId ?? merged.deduplication?.id,
+                removeOnComplete,
+                removeOnFail,
+                repeat,
                 stallTimeout: merged.stallTimeout,
                 durable: merged.durable,
+                parentId: merged.parent ? jobId(merged.parent.id) : undefined,
+                // BullMQ v5 options
+                lifo: merged.lifo,
+                stackTraceLimit: merged.stackTraceLimit,
+                keepLogs: merged.keepLogs,
+                sizeLimit: merged.sizeLimit,
+                failParentOnFailure: merged.failParentOnFailure,
+                removeDependencyOnFailure: merged.removeDependencyOnFailure,
+                dedup: merged.deduplication ? { ttl: merged.deduplication.ttl } : undefined,
+                debounceId: merged.debounce?.id,
+                debounceTtl: merged.debounce?.ttl,
+            });
+            return toPublicJob({
+                job,
+                name,
+                getState: (jid) => this.getJobState(jid),
+                remove: (jid) => this.removeAsync(jid),
+                retry: (jid) => this.retryJob(jid),
+                getChildrenValues: (jid) => this.getChildrenValues(jid),
+                updateData: (jid, data) => this.updateJobData(jid, data),
+                promote: (jid) => this.promoteJob(jid),
+                changeDelay: (jid, delay) => this.changeJobDelay(jid, delay),
+                changePriority: (jid, opts) => this.changeJobPriority(jid, opts),
+                extendLock: (jid, token, duration) => this.extendJobLock(jid, token, duration),
+                clearLogs: (jid, keepLogs) => this.clearJobLogs(jid, keepLogs),
+                getDependencies: (jid, opts) => this.getJobDependencies(jid, opts),
+                getDependenciesCount: (jid, opts) => this.getJobDependenciesCount(jid, opts),
+                moveToCompleted: (jid, result, token) => this.moveJobToCompleted(jid, result, token),
+                moveToFailed: (jid, error, token) => this.moveJobToFailed(jid, error, token),
+                moveToWait: (jid, token) => this.moveJobToWait(jid, token),
+                moveToDelayed: (jid, timestamp, token) => this.moveJobToDelayed(jid, timestamp, token),
+                moveToWaitingChildren: (jid, token, opts) => this.moveJobToWaitingChildren(jid, token, opts),
+                waitUntilFinished: (jid, queueEvents, ttl) => this.waitJobUntilFinished(jid, queueEvents, ttl),
             });
-            return toPublicJob(job, name);
         }
         const response = await this.tcp.send({
             cmd: 'PUSH',
             queue: this.name,
-            data: { name, ...data },
+            data: jobData,
             priority: merged.priority,
             delay: merged.delay,
             maxAttempts: merged.attempts,
@@ -84,6 +149,7 @@ export class Queue {
             stallTimeout: merged.stallTimeout,
             durable: merged.durable,
             repeat: merged.repeat,
+            parentId: merged.parent?.id,
         });
         if (!response.ok) {
             throw new Error(response.error ?? 'Failed to add job');
@@ -100,6 +166,9 @@ export class Queue {
             const manager = getSharedManager();
             const inputs = jobs.map(({ name, data, opts }) => {
                 const m = { ...this.opts.defaultJobOptions, ...opts };
+                // Parse removeOnComplete/removeOnFail (can be boolean, number, or KeepJobs)
+                const removeOnComplete = typeof m.removeOnComplete === 'boolean' ? m.removeOnComplete : false;
+                const removeOnFail = typeof m.removeOnFail === 'boolean' ? m.removeOnFail : false;
                 return {
                     data: { name, ...data },
                     priority: m.priority,
@@ -108,11 +177,43 @@ export class Queue {
                     backoff: m.backoff,
                     timeout: m.timeout,
                     customId: m.jobId,
-                    removeOnComplete: m.removeOnComplete,
-                    removeOnFail: m.removeOnFail,
-                    repeat: m.repeat,
+                    removeOnComplete,
+                    removeOnFail,
+                    repeat: m.repeat
+                        ? {
+                            every: m.repeat.every,
+                            limit: m.repeat.limit,
+                            pattern: m.repeat.pattern,
+                            count: m.repeat.count,
+                            startDate: m.repeat.startDate instanceof Date
+                                ? m.repeat.startDate.getTime()
+                                : typeof m.repeat.startDate === 'string'
+                                    ? new Date(m.repeat.startDate).getTime()
+                                    : m.repeat.startDate,
+                            endDate: m.repeat.endDate instanceof Date
+                                ? m.repeat.endDate.getTime()
+                                : typeof m.repeat.endDate === 'string'
+                                    ? new Date(m.repeat.endDate).getTime()
+                                    : m.repeat.endDate,
+                            tz: m.repeat.tz,
+                            immediately: m.repeat.immediately,
+                            prevMillis: m.repeat.prevMillis,
+                            offset: m.repeat.offset,
+                            jobId: m.repeat.jobId,
+                        }
+                        : undefined,
                     stallTimeout: m.stallTimeout,
                     durable: m.durable,
+                    // BullMQ v5 options
+                    lifo: m.lifo,
+                    stackTraceLimit: m.stackTraceLimit,
+                    keepLogs: m.keepLogs,
+                    sizeLimit: m.sizeLimit,
+                    failParentOnFailure: m.failParentOnFailure,
+                    removeDependencyOnFailure: m.removeDependencyOnFailure,
+                    dedup: m.deduplication ? { ttl: m.deduplication.ttl } : undefined,
+                    debounceId: m.debounce?.id,
+                    debounceTtl: m.debounce?.ttl,
                 };
             });
             const ids = await manager.pushBatch(this.name, inputs);
@@ -131,6 +232,8 @@ export class Queue {
                 removeOnComplete: m.removeOnComplete,
                 removeOnFail: m.removeOnFail,
                 stallTimeout: m.stallTimeout,
+                repeat: m.repeat,
+                durable: m.durable,
             };
         });
         const response = await this.tcp.send({ cmd: 'PUSHB', queue: this.name, jobs: jobInputs });
@@ -148,23 +251,121 @@ export class Queue {
             if (!job)
                 return null;
             const jobData = job.data;
-            return toPublicJob(job, jobData?.name ?? 'default');
+            return toPublicJob({
+                job,
+                name: jobData?.name ?? 'default',
+                getState: (jid) => this.getJobState(jid),
+                remove: (jid) => this.removeAsync(jid),
+                retry: (jid) => this.retryJob(jid),
+                getChildrenValues: (jid) => this.getChildrenValues(jid),
+                updateData: (jid, data) => this.updateJobData(jid, data),
+                promote: (jid) => this.promoteJob(jid),
+                changeDelay: (jid, delay) => this.changeJobDelay(jid, delay),
+                changePriority: (jid, opts) => this.changeJobPriority(jid, opts),
+                extendLock: (jid, token, duration) => this.extendJobLock(jid, token, duration),
+                clearLogs: (jid, keepLogs) => this.clearJobLogs(jid, keepLogs),
+                getDependencies: (jid, opts) => this.getJobDependencies(jid, opts),
+                getDependenciesCount: (jid, opts) => this.getJobDependenciesCount(jid, opts),
+                moveToCompleted: (jid, result, token) => this.moveJobToCompleted(jid, result, token),
+                moveToFailed: (jid, error, token) => this.moveJobToFailed(jid, error, token),
+                moveToWait: (jid, token) => this.moveJobToWait(jid, token),
+                moveToDelayed: (jid, timestamp, token) => this.moveJobToDelayed(jid, timestamp, token),
+                moveToWaitingChildren: (jid, token, opts) => this.moveJobToWaitingChildren(jid, token, opts),
+                waitUntilFinished: (jid, queueEvents, ttl) => this.waitJobUntilFinished(jid, queueEvents, ttl),
+            });
         }
         const response = await this.tcp.send({ cmd: 'GetJob', id });
         if (!response.ok || !response.job)
             return null;
         const jobData = response.job;
         const data = jobData.data;
+        const jobIdStr = String(jobData.id);
+        const ts = jobData.createdAt ?? Date.now();
+        const runAt = jobData.runAt ?? ts;
         return {
-            id: String(jobData.id),
+            id: jobIdStr,
             name: data?.name ?? 'default',
             data: jobData.data,
             queueName: this.name,
             attemptsMade: jobData.attempts ?? 0,
-            timestamp: jobData.createdAt ?? Date.now(),
+            timestamp: ts,
             progress: jobData.progress ?? 0,
+            // BullMQ v5 properties
+            delay: runAt > ts ? runAt - ts : 0,
+            processedOn: jobData.startedAt ?? undefined,
+            finishedOn: jobData.completedAt ?? undefined,
+            stacktrace: null,
+            stalledCounter: jobData.stallCount ?? 0,
+            priority: jobData.priority ?? 0,
+            parentKey: undefined,
+            opts: {},
+            token: undefined,
+            processedBy: undefined,
+            deduplicationId: jobData.customId ?? undefined,
+            repeatJobKey: undefined,
+            attemptsStarted: jobData.attempts ?? 0,
+            // Methods
             updateProgress: async () => { },
             log: async () => { },
+            getState: () => this.getJobState(jobIdStr),
+            remove: () => this.removeAsync(jobIdStr),
+            retry: () => this.retryJob(jobIdStr),
+            getChildrenValues: () => this.getChildrenValues(jobIdStr),
+            // BullMQ v5 state check methods
+            isWaiting: async () => (await this.getJobState(jobIdStr)) === 'waiting',
+            isActive: async () => (await this.getJobState(jobIdStr)) === 'active',
+            isDelayed: async () => (await this.getJobState(jobIdStr)) === 'delayed',
+            isCompleted: async () => (await this.getJobState(jobIdStr)) === 'completed',
+            isFailed: async () => (await this.getJobState(jobIdStr)) === 'failed',
+            isWaitingChildren: () => Promise.resolve(false),
+            // BullMQ v5 mutation methods
+            updateData: async () => { },
+            promote: async () => { },
+            changeDelay: async () => { },
+            changePriority: async () => { },
+            extendLock: () => Promise.resolve(0),
+            clearLogs: async () => { },
+            // BullMQ v5 dependency methods
+            getDependencies: () => Promise.resolve({ processed: {}, unprocessed: [] }),
+            getDependenciesCount: () => Promise.resolve({ processed: 0, unprocessed: 0 }),
+            // BullMQ v5 serialization methods
+            toJSON: () => ({
+                id: jobIdStr,
+                name: data?.name ?? 'default',
+                data: jobData.data,
+                opts: {},
+                progress: jobData.progress ?? 0,
+                delay: runAt > ts ? runAt - ts : 0,
+                timestamp: ts,
+                attemptsMade: jobData.attempts ?? 0,
+                stacktrace: null,
+                queueQualifiedName: `bull:${this.name}`,
+            }),
+            asJSON: () => ({
+                id: jobIdStr,
+                name: data?.name ?? 'default',
+                data: JSON.stringify(jobData.data),
+                opts: '{}',
+                progress: String(jobData.progress ?? 0),
+                delay: String(runAt > ts ? runAt - ts : 0),
+                timestamp: String(ts),
+                attemptsMade: String(jobData.attempts ?? 0),
+                stacktrace: null,
+            }),
+            // BullMQ v5 move methods
+            moveToCompleted: () => Promise.resolve(null),
+            moveToFailed: () => Promise.resolve(),
+            moveToWait: () => Promise.resolve(false),
+            moveToDelayed: () => Promise.resolve(),
+            moveToWaitingChildren: () => Promise.resolve(false),
+            waitUntilFinished: () => Promise.resolve(undefined),
+            // BullMQ v5 additional methods
+            discard: () => { },
+            getFailedChildrenValues: () => Promise.resolve({}),
+            getIgnoredChildrenFailures: () => Promise.resolve({}),
+            removeChildDependency: () => Promise.resolve(false),
+            removeDeduplicationKey: () => Promise.resolve(false),
+            removeUnprocessedChildren: () => Promise.resolve(),
         };
     }
     /** Remove a job by ID */
@@ -174,6 +375,55 @@ export class Queue {
         else
             void this.tcp.send({ cmd: 'Cancel', id });
     }
+    /** Remove a job by ID (async) */
+    async removeAsync(id) {
+        if (this.embedded) {
+            await getSharedManager().cancel(jobId(id));
+        }
+        else {
+            await this.tcp.send({ cmd: 'Cancel', id });
+        }
+    }
+    /** Retry a job by ID */
+    async retryJob(id) {
+        if (this.embedded) {
+            // For embedded mode, we need to implement retry in QueueManager
+            // For now, just get the job and re-add it
+            const manager = getSharedManager();
+            const job = await manager.getJob(jobId(id));
+            if (job) {
+                await manager.push(job.queue, { data: job.data, priority: job.priority });
+            }
+        }
+        else {
+            await this.tcp.send({ cmd: 'RetryJob', id });
+        }
+    }
+    /**
+     * Get the return values of all children jobs (BullMQ v5 compatible).
+     * Returns a Record where keys are job keys (queueName:jobId) and values are return values.
+     */
+    getChildrenValues(id) {
+        if (this.embedded) {
+            const manager = getSharedManager();
+            return manager.getChildrenValues(jobId(id));
+        }
+        // TCP mode - would need server-side support
+        // For now, return empty object
+        return Promise.resolve({});
+    }
+    /** Get job state by ID (async, works with both embedded and TCP) */
+    async getJobState(id) {
+        if (this.embedded) {
+            const manager = getSharedManager();
+            const state = await manager.getJobState(jobId(id));
+            return state;
+        }
+        const response = await this.tcp.send({ cmd: 'GetState', id });
+        if (!response.ok)
+            return 'unknown';
+        return response.state;
+    }
     /** Get job counts by state */
     getJobCounts() {
         if (this.embedded) {
@@ -238,13 +488,309 @@ export class Queue {
         else
             void this.tcp.send({ cmd: 'Obliterate', queue: this.name });
     }
+    /** Check if queue is paused */
+    isPaused() {
+        if (this.embedded) {
+            return getSharedManager().isPaused(this.name);
+        }
+        return false;
+    }
+    /** Check if queue is paused (async, works with TCP) */
+    async isPausedAsync() {
+        if (this.embedded)
+            return this.isPaused();
+        const response = await this.tcp.send({ cmd: 'IsPaused', queue: this.name });
+        if (!response.ok)
+            return false;
+        return response.paused === true;
+    }
+    /** Count jobs awaiting processing */
+    count() {
+        if (this.embedded) {
+            return getSharedManager().count(this.name);
+        }
+        return 0;
+    }
+    /** Count jobs awaiting processing (async, works with TCP) */
+    async countAsync() {
+        if (this.embedded)
+            return this.count();
+        const response = await this.tcp.send({ cmd: 'Count', queue: this.name });
+        if (!response.ok)
+            return 0;
+        return response.count ?? 0;
+    }
+    /** Get active jobs */
+    getActive(start = 0, end = 100) {
+        return this.getJobs({ state: 'active', start, end });
+    }
+    /** Get active jobs (async) */
+    async getActiveAsync(start = 0, end = 100) {
+        return this.getJobsAsync({ state: 'active', start, end });
+    }
+    /** Get completed jobs */
+    getCompleted(start = 0, end = 100) {
+        return this.getJobs({ state: 'completed', start, end });
+    }
+    /** Get completed jobs (async) */
+    async getCompletedAsync(start = 0, end = 100) {
+        return this.getJobsAsync({ state: 'completed', start, end });
+    }
+    /** Get failed jobs */
+    getFailed(start = 0, end = 100) {
+        return this.getJobs({ state: 'failed', start, end });
+    }
+    /** Get failed jobs (async) */
+    async getFailedAsync(start = 0, end = 100) {
+        return this.getJobsAsync({ state: 'failed', start, end });
+    }
+    /** Get delayed jobs */
+    getDelayed(start = 0, end = 100) {
+        return this.getJobs({ state: 'delayed', start, end });
+    }
+    /** Get delayed jobs (async) */
+    async getDelayedAsync(start = 0, end = 100) {
+        return this.getJobsAsync({ state: 'delayed', start, end });
+    }
+    /** Get waiting jobs */
+    getWaiting(start = 0, end = 100) {
+        return this.getJobs({ state: 'waiting', start, end });
+    }
+    /** Get waiting jobs (async) */
+    async getWaitingAsync(start = 0, end = 100) {
+        return this.getJobsAsync({ state: 'waiting', start, end });
+    }
+    /** Get active job count */
+    async getActiveCount() {
+        const counts = await this.getJobCountsAsync();
+        return counts.active;
+    }
+    /** Get completed job count */
+    async getCompletedCount() {
+        const counts = await this.getJobCountsAsync();
+        return counts.completed;
+    }
+    /** Get failed job count */
+    async getFailedCount() {
+        const counts = await this.getJobCountsAsync();
+        return counts.failed;
+    }
+    /** Get delayed job count */
+    async getDelayedCount() {
+        if (this.embedded) {
+            const stats = getSharedManager().getStats();
+            return stats.delayed;
+        }
+        const response = await this.tcp.send({ cmd: 'Stats' });
+        if (!response.ok)
+            return 0;
+        return response.stats?.delayed ?? 0;
+    }
+    /** Get waiting job count */
+    async getWaitingCount() {
+        const counts = await this.getJobCountsAsync();
+        return counts.waiting;
+    }
+    /** Clean old jobs from the queue */
+    clean(grace, limit, type) {
+        if (this.embedded) {
+            const count = getSharedManager().clean(this.name, grace, type, limit);
+            // Return empty array for now - would need to track removed IDs
+            return new Array(count).fill('');
+        }
+        return [];
+    }
+    /** Clean old jobs from the queue (async, works with TCP) */
+    async cleanAsync(grace, limit, type) {
+        if (this.embedded)
+            return this.clean(grace, limit, type);
+        const response = await this.tcp.send({
+            cmd: 'Clean',
+            queue: this.name,
+            grace,
+            limit,
+            type,
+        });
+        if (!response.ok)
+            return [];
+        return response.removed ?? [];
+    }
+    /** Retry failed jobs */
+    async retryJobs(opts) {
+        const state = opts?.state ?? 'failed';
+        const count = opts?.count ?? 100;
+        if (this.embedded) {
+            if (state === 'failed') {
+                return getSharedManager().retryDlq(this.name);
+            }
+            else {
+                return getSharedManager().retryCompleted(this.name);
+            }
+        }
+        const cmd = state === 'failed' ? 'RetryDlq' : 'RetryCompleted';
+        const response = await this.tcp.send({ cmd, queue: this.name, count });
+        if (!response.ok)
+            return 0;
+        return response.count ?? 0;
+    }
+    /** Promote delayed jobs to waiting */
+    async promoteJobs(opts) {
+        const count = opts?.count ?? 100;
+        if (this.embedded) {
+            // Get delayed jobs and promote them
+            const jobs = this.getJobs({ state: 'delayed', start: 0, end: count });
+            let promoted = 0;
+            for (const job of jobs) {
+                const success = await getSharedManager().promote(jobId(job.id));
+                if (success)
+                    promoted++;
+            }
+            return promoted;
+        }
+        const response = await this.tcp.send({ cmd: 'PromoteJobs', queue: this.name, count });
+        if (!response.ok)
+            return 0;
+        return response.count ?? 0;
+    }
+    /** Get job logs */
+    async getJobLogs(id, start = 0, end = 100, _asc = true) {
+        if (this.embedded) {
+            const logs = getSharedManager().getLogs(jobId(id));
+            const logStrings = logs.slice(start, end).map((l) => `[${l.level}] ${l.message}`);
+            return { logs: logStrings, count: logs.length };
+        }
+        const response = await this.tcp.send({ cmd: 'GetLogs', id, start, end });
+        if (!response.ok)
+            return { logs: [], count: 0 };
+        const result = response;
+        const logStrings = (result.logs ?? []).map((l) => `[${l.level}] ${l.message}`);
+        return { logs: logStrings, count: result.count ?? 0 };
+    }
+    /** Add a log entry to a job */
+    async addJobLog(id, logRow, _keepLogs) {
+        if (this.embedded) {
+            const success = getSharedManager().addLog(jobId(id), logRow);
+            return success ? 1 : 0;
+        }
+        const response = await this.tcp.send({ cmd: 'AddLog', id, message: logRow });
+        return response.ok ? 1 : 0;
+    }
+    /** Update job progress */
+    async updateJobProgress(id, progress) {
+        const progressValue = typeof progress === 'number' ? progress : 0;
+        const message = typeof progress === 'object' ? JSON.stringify(progress) : undefined;
+        if (this.embedded) {
+            await getSharedManager().updateProgress(jobId(id), progressValue, message);
+            return;
+        }
+        await this.tcp.send({ cmd: 'Progress', id, progress: progressValue, message });
+    }
+    /** Set global concurrency limit for this queue */
+    setGlobalConcurrency(concurrency) {
+        if (this.embedded) {
+            getSharedManager().setConcurrency(this.name, concurrency);
+        }
+        else {
+            void this.tcp.send({ cmd: 'SetConcurrency', queue: this.name, limit: concurrency });
+        }
+    }
+    /** Remove global concurrency limit */
+    removeGlobalConcurrency() {
+        if (this.embedded) {
+            getSharedManager().clearConcurrency(this.name);
+        }
+        else {
+            void this.tcp.send({ cmd: 'ClearConcurrency', queue: this.name });
+        }
+    }
+    /** Get global concurrency limit */
+    getGlobalConcurrency() {
+        // This would need to be implemented in QueueManager
+        // For now, return null
+        return Promise.resolve(null);
+    }
+    /** Set global rate limit for this queue */
+    setGlobalRateLimit(max, _duration) {
+        if (this.embedded) {
+            getSharedManager().setRateLimit(this.name, max);
+        }
+        else {
+            void this.tcp.send({ cmd: 'RateLimit', queue: this.name, limit: max });
+        }
+    }
+    /** Remove global rate limit */
+    removeGlobalRateLimit() {
+        if (this.embedded) {
+            getSharedManager().clearRateLimit(this.name);
+        }
+        else {
+            void this.tcp.send({ cmd: 'RateLimitClear', queue: this.name });
+        }
+    }
+    /** Get global rate limit */
+    getGlobalRateLimit() {
+        // This would need to be implemented in QueueManager
+        // For now, return null
+        return Promise.resolve(null);
+    }
+    /** Get metrics for this queue */
+    async getMetrics(type, _start, _end) {
+        if (this.embedded) {
+            const stats = getSharedManager().getStats();
+            const count = type === 'completed' ? stats.completed : stats.dlq;
+            return { meta: { count }, data: [] };
+        }
+        const response = await this.tcp.send({ cmd: 'Metrics' });
+        if (!response.ok)
+            return { meta: { count: 0 }, data: [] };
+        const stats = response.stats;
+        const count = type === 'completed' ? (stats?.completed ?? 0) : (stats?.dlq ?? 0);
+        return { meta: { count }, data: [] };
+    }
+    /** Get workers processing this queue */
+    async getWorkers() {
+        if (this.embedded) {
+            // Would need to implement worker tracking
+            return [];
+        }
+        const response = await this.tcp.send({ cmd: 'ListWorkers' });
+        if (!response.ok)
+            return [];
+        return (response.workers ?? []);
+    }
+    /** Get worker count */
+    async getWorkersCount() {
+        const workers = await this.getWorkers();
+        return workers.length;
+    }
     /** Get jobs with filtering and pagination */
     getJobs(options = {}) {
         if (this.embedded) {
             const jobs = getSharedManager().getJobs(this.name, options);
             return jobs.map((job) => {
                 const jobData = job.data;
-                return toPublicJob(job, jobData?.name ?? 'default');
+                return toPublicJob({
+                    job,
+                    name: jobData?.name ?? 'default',
+                    getState: (jid) => this.getJobState(jid),
+                    remove: (jid) => this.removeAsync(jid),
+                    retry: (jid) => this.retryJob(jid),
+                    getChildrenValues: (jid) => this.getChildrenValues(jid),
+                    updateData: (jid, data) => this.updateJobData(jid, data),
+                    promote: (jid) => this.promoteJob(jid),
+                    changeDelay: (jid, delay) => this.changeJobDelay(jid, delay),
+                    changePriority: (jid, opts) => this.changeJobPriority(jid, opts),
+                    extendLock: (jid, token, duration) => this.extendJobLock(jid, token, duration),
+                    clearLogs: (jid, keepLogs) => this.clearJobLogs(jid, keepLogs),
+                    getDependencies: (jid, opts) => this.getJobDependencies(jid, opts),
+                    getDependenciesCount: (jid, opts) => this.getJobDependenciesCount(jid, opts),
+                    moveToCompleted: (jid, result, token) => this.moveJobToCompleted(jid, result, token),
+                    moveToFailed: (jid, error, token) => this.moveJobToFailed(jid, error, token),
+                    moveToWait: (jid, token) => this.moveJobToWait(jid, token),
+                    moveToDelayed: (jid, timestamp, token) => this.moveJobToDelayed(jid, timestamp, token),
+                    moveToWaitingChildren: (jid, token, opts) => this.moveJobToWaitingChildren(jid, token, opts),
+                    waitUntilFinished: (jid, queueEvents, ttl) => this.waitJobUntilFinished(jid, queueEvents, ttl),
+                });
             });
         }
         // Sync TCP version returns empty - use getJobsAsync
@@ -267,16 +813,91 @@ export class Queue {
         const jobs = response.jobs;
         return jobs.map((j) => {
             const jobData = j.data;
+            const jobName = jobData?.name ?? 'default';
             return {
                 id: j.id,
-                name: jobData?.name ?? 'default',
+                name: jobName,
                 data: j.data,
                 queueName: j.queue,
                 attemptsMade: j.attempts,
                 timestamp: j.createdAt,
                 progress: j.progress ?? 0,
+                // BullMQ v5 properties
+                delay: 0,
+                processedOn: undefined,
+                finishedOn: undefined,
+                stacktrace: null,
+                stalledCounter: 0,
+                priority: j.priority,
+                parentKey: undefined,
+                opts: {},
+                token: undefined,
+                processedBy: undefined,
+                deduplicationId: undefined,
+                repeatJobKey: undefined,
+                attemptsStarted: j.attempts,
+                // Methods
                 updateProgress: async () => { },
                 log: async () => { },
+                getState: () => this.getJobState(j.id),
+                remove: () => this.removeAsync(j.id),
+                retry: () => this.retryJob(j.id),
+                getChildrenValues: () => this.getChildrenValues(j.id),
+                // BullMQ v5 state check methods
+                isWaiting: async () => (await this.getJobState(j.id)) === 'waiting',
+                isActive: async () => (await this.getJobState(j.id)) === 'active',
+                isDelayed: async () => (await this.getJobState(j.id)) === 'delayed',
+                isCompleted: async () => (await this.getJobState(j.id)) === 'completed',
+                isFailed: async () => (await this.getJobState(j.id)) === 'failed',
+                isWaitingChildren: () => Promise.resolve(false),
+                // BullMQ v5 mutation methods
+                updateData: async () => { },
+                promote: async () => { },
+                changeDelay: async () => { },
+                changePriority: async () => { },
+                extendLock: () => Promise.resolve(0),
+                clearLogs: async () => { },
+                // BullMQ v5 dependency methods
+                getDependencies: () => Promise.resolve({ processed: {}, unprocessed: [] }),
+                getDependenciesCount: () => Promise.resolve({ processed: 0, unprocessed: 0 }),
+                // BullMQ v5 serialization methods
+                toJSON: () => ({
+                    id: j.id,
+                    name: jobName,
+                    data: j.data,
+                    opts: {},
+                    progress: j.progress ?? 0,
+                    delay: 0,
+                    timestamp: j.createdAt,
+                    attemptsMade: j.attempts,
+                    stacktrace: null,
+                    queueQualifiedName: `bull:${j.queue}`,
+                }),
+                asJSON: () => ({
+                    id: j.id,
+                    name: jobName,
+                    data: JSON.stringify(j.data),
+                    opts: '{}',
+                    progress: String(j.progress ?? 0),
+                    delay: '0',
+                    timestamp: String(j.createdAt),
+                    attemptsMade: String(j.attempts),
+                    stacktrace: null,
+                }),
+                // BullMQ v5 move methods
+                moveToCompleted: () => Promise.resolve(null),
+                moveToFailed: () => Promise.resolve(),
+                moveToWait: () => Promise.resolve(false),
+                moveToDelayed: () => Promise.resolve(),
+                moveToWaitingChildren: () => Promise.resolve(false),
+                waitUntilFinished: () => Promise.resolve(undefined),
+                // BullMQ v5 additional methods
+                discard: () => { },
+                getFailedChildrenValues: () => Promise.resolve({}),
+                getIgnoredChildrenFailures: () => Promise.resolve({}),
+                removeChildDependency: () => Promise.resolve(false),
+                removeDeduplicationKey: () => Promise.resolve(false),
+                removeUnprocessedChildren: () => Promise.resolve(),
             };
         });
     }
@@ -360,6 +981,540 @@ export class Queue {
             return 0;
         return response.count ?? 0;
     }
+    // ============================================================================
+    // BullMQ v5 Compatibility Methods (Additional)
+    // ============================================================================
+    /**
+     * Trim events to a maximum length.
+     * In bunqueue, events are emitted in real-time and not stored, so this is a no-op.
+     */
+    trimEvents(_maxLength) {
+        // Events in bunqueue are not persisted - they're emitted via EventEmitter
+        return Promise.resolve(0);
+    }
+    /**
+     * Get jobs sorted by priority (highest first).
+     * In BullMQ, this returns jobs waiting to be processed sorted by priority.
+     */
+    getPrioritized(start = 0, end = -1) {
+        // In bunqueue, all waiting jobs are already prioritized in the priority queue
+        return this.getWaitingAsync(start, end);
+    }
+    /** Get count of prioritized jobs (same as waiting count in bunqueue) */
+    getPrioritizedCount() {
+        return this.getWaitingCount();
+    }
+    /**
+     * Get jobs that are waiting for their parent to complete.
+     * Used in job flows (parent-child dependencies).
+     */
+    getWaitingChildren(start = 0, end = -1) {
+        if (this.embedded) {
+            // Get jobs with pending dependencies
+            const jobs = getSharedManager().getJobs(this.name, {
+                state: 'delayed',
+                start,
+                end: end === -1 ? 1000 : end,
+            });
+            // Filter to only those with dependencies (would need dependency tracking)
+            const result = jobs
+                .filter((j) => {
+                const data = j.data;
+                return data?._waitingParent === true;
+            })
+                .map((job) => {
+                const jobData = job.data;
+                return toPublicJob({
+                    job,
+                    name: jobData?.name ?? 'default',
+                    getState: (jid) => this.getJobState(jid),
+                    remove: (jid) => this.removeAsync(jid),
+                    retry: (jid) => this.retryJob(jid),
+                    getChildrenValues: (jid) => this.getChildrenValues(jid),
+                    updateData: (jid, data) => this.updateJobData(jid, data),
+                    promote: (jid) => this.promoteJob(jid),
+                    changeDelay: (jid, delay) => this.changeJobDelay(jid, delay),
+                    changePriority: (jid, opts) => this.changeJobPriority(jid, opts),
+                    extendLock: (jid, token, duration) => this.extendJobLock(jid, token, duration),
+                    clearLogs: (jid, keepLogs) => this.clearJobLogs(jid, keepLogs),
+                    getDependencies: (jid, opts) => this.getJobDependencies(jid, opts),
+                    getDependenciesCount: (jid, opts) => this.getJobDependenciesCount(jid, opts),
+                });
+            });
+            return Promise.resolve(result);
+        }
+        // TCP mode - not fully supported yet
+        return Promise.resolve([]);
+    }
+    /** Get count of jobs waiting for their parent */
+    async getWaitingChildrenCount() {
+        const children = await this.getWaitingChildren();
+        return children.length;
+    }
+    /**
+     * Get dependencies of a parent job.
+     * Returns processed/unprocessed children of a parent job in a flow.
+     */
+    getDependencies(_parentId, _type, _start = 0, _end = -1) {
+        // Would require implementing dependency tracking
+        return Promise.resolve({
+            processed: {},
+            unprocessed: [],
+        });
+    }
+    /**
+     * Get the TTL of the current rate limit.
+     * Returns 0 if no rate limit is active.
+     */
+    getRateLimitTtl(_maxJobs) {
+        // Would need to track rate limit expiration
+        return Promise.resolve(0);
+    }
+    /**
+     * Set a temporary rate limit that expires after the given time.
+     */
+    async rateLimit(expireTimeMs) {
+        if (this.embedded) {
+            // Set rate limit with expiration
+            getSharedManager().setRateLimit(this.name, 1);
+            // Schedule removal after expiration
+            setTimeout(() => {
+                getSharedManager().clearRateLimit(this.name);
+            }, expireTimeMs);
+        }
+        else {
+            await this.tcp.send({ cmd: 'RateLimit', queue: this.name, limit: 1 });
+            // Note: TCP mode would need server-side expiration support
+        }
+    }
+    /**
+     * Check if the queue is currently rate limited (at max capacity).
+     */
+    isMaxed() {
+        // Would need to check if rate limit is currently blocking
+        return Promise.resolve(false);
+    }
+    // ============================================================================
+    // Job Scheduler Methods (BullMQ v5 repeatable jobs)
+    // ============================================================================
+    /**
+     * Create or update a job scheduler (repeatable job).
+     * This is the BullMQ v5 way to handle cron/repeating jobs.
+     */
+    async upsertJobScheduler(schedulerId, repeatOpts, jobTemplate) {
+        const cronPattern = repeatOpts.pattern;
+        const repeatEvery = repeatOpts.every;
+        if (this.embedded) {
+            const manager = getSharedManager();
+            // Use the cron scheduler
+            manager.addCron({
+                name: schedulerId,
+                queue: this.name,
+                data: jobTemplate?.data ?? {},
+                schedule: cronPattern,
+                repeatEvery,
+                timezone: 'UTC',
+            });
+            return {
+                id: schedulerId,
+                name: jobTemplate?.name ?? 'default',
+                next: Date.now() + (repeatEvery ?? 60000),
+            };
+        }
+        else {
+            const response = await this.tcp.send({
+                cmd: 'Cron',
+                name: schedulerId,
+                queue: this.name,
+                data: jobTemplate?.data ?? {},
+                schedule: cronPattern,
+                repeatEvery,
+            });
+            if (!response.ok)
+                return null;
+            return {
+                id: schedulerId,
+                name: jobTemplate?.name ?? 'default',
+                next: response.nextRun ?? Date.now(),
+            };
+        }
+    }
+    /**
+     * Remove a job scheduler.
+     */
+    async removeJobScheduler(schedulerId) {
+        if (this.embedded) {
+            getSharedManager().removeCron(schedulerId);
+            return true;
+        }
+        else {
+            const response = await this.tcp.send({ cmd: 'CronDelete', name: schedulerId });
+            return response.ok === true;
+        }
+    }
+    /**
+     * Get a job scheduler by ID.
+     */
+    async getJobScheduler(schedulerId) {
+        if (this.embedded) {
+            const crons = getSharedManager().listCrons();
+            const cron = crons.find((c) => c.name === schedulerId);
+            if (!cron)
+                return null;
+            return {
+                id: cron.name,
+                name: cron.name,
+                next: cron.nextRun,
+                pattern: cron.schedule ?? undefined,
+                every: cron.repeatEvery ?? undefined,
+            };
+        }
+        else {
+            const response = await this.tcp.send({ cmd: 'CronList' });
+            if (!response.ok)
+                return null;
+            const crons = response.crons;
+            const cron = crons?.find((c) => c.name === schedulerId);
+            if (!cron)
+                return null;
+            return {
+                id: cron.name,
+                name: cron.name,
+                next: cron.nextRun,
+                pattern: cron.schedule ?? undefined,
+                every: cron.repeatEvery ?? undefined,
+            };
+        }
+    }
+    /**
+     * Get all job schedulers for this queue.
+     */
+    async getJobSchedulers(_start = 0, _end = -1, _asc = true) {
+        if (this.embedded) {
+            const crons = getSharedManager()
+                .listCrons()
+                .filter((c) => c.queue === this.name);
+            return crons.map((c) => ({
+                id: c.name,
+                name: c.name,
+                next: c.nextRun,
+                pattern: c.schedule ?? undefined,
+                every: c.repeatEvery ?? undefined,
+            }));
+        }
+        else {
+            const response = await this.tcp.send({ cmd: 'CronList' });
+            if (!response.ok)
+                return [];
+            const crons = response.crons;
+            return (crons ?? [])
+                .filter((c) => c.queue === this.name)
+                .map((c) => ({
+                id: c.name,
+                name: c.name,
+                next: c.nextRun,
+                pattern: c.schedule ?? undefined,
+                every: c.repeatEvery ?? undefined,
+            }));
+        }
+    }
+    /** Get count of job schedulers for this queue */
+    async getJobSchedulersCount() {
+        const schedulers = await this.getJobSchedulers();
+        return schedulers.length;
+    }
+    // ============================================================================
+    // Deduplication Methods
+    // ============================================================================
+    /**
+     * Get the job ID associated with a deduplication key.
+     */
+    getDeduplicationJobId(deduplicationId) {
+        if (this.embedded) {
+            const job = getSharedManager().getJobByCustomId(deduplicationId);
+            return Promise.resolve(job ? String(job.id) : null);
+        }
+        // TCP mode - would need server support
+        return Promise.resolve(null);
+    }
+    /**
+     * Remove a deduplication key, allowing a new job with the same key.
+     */
+    removeDeduplicationKey(deduplicationId) {
+        if (this.embedded) {
+            // Remove the custom ID mapping
+            const job = getSharedManager().getJobByCustomId(deduplicationId);
+            if (job) {
+                // Would need a method to remove just the customId mapping
+                return Promise.resolve(1);
+            }
+            return Promise.resolve(0);
+        }
+        return Promise.resolve(0);
+    }
+    // ============================================================================
+    // Connection Methods
+    // ============================================================================
+    /**
+     * Wait until the queue is ready (connection established).
+     */
+    async waitUntilReady() {
+        if (this.embedded) {
+            // Embedded mode is always ready
+            return;
+        }
+        // TCP mode - the pool handles connection
+        // Just ensure we can send a ping
+        await this.tcp.send({ cmd: 'Ping' });
+    }
+    /**
+     * Disconnect from the server (async version of close).
+     */
+    disconnect() {
+        this.close();
+        return Promise.resolve();
+    }
+    // ============================================================================
+    // BullMQ v5 Job Mutation Methods (used by Job instances)
+    // ============================================================================
+    /** Update job data */
+    async updateJobData(id, data) {
+        if (this.embedded) {
+            const manager = getSharedManager();
+            await manager.updateJobData(jobId(id), data);
+        }
+        else {
+            await this.tcp.send({ cmd: 'Update', id, data });
+        }
+    }
+    /** Promote a delayed job to waiting */
+    async promoteJob(id) {
+        if (this.embedded) {
+            await getSharedManager().promote(jobId(id));
+        }
+        else {
+            await this.tcp.send({ cmd: 'Promote', id });
+        }
+    }
+    /** Change job delay */
+    async changeJobDelay(id, delay) {
+        if (this.embedded) {
+            const manager = getSharedManager();
+            await manager.changeDelay(jobId(id), delay);
+        }
+        else {
+            await this.tcp.send({ cmd: 'ChangeDelay', id, delay });
+        }
+    }
+    /** Change job priority */
+    async changeJobPriority(id, opts) {
+        if (this.embedded) {
+            const manager = getSharedManager();
+            await manager.changePriority(jobId(id), opts.priority);
+        }
+        else {
+            await this.tcp.send({ cmd: 'ChangePriority', id, priority: opts.priority });
+        }
+    }
+    /** Extend job lock */
+    async extendJobLock(id, token, duration) {
+        if (this.embedded) {
+            const manager = getSharedManager();
+            const extended = await manager.extendLock(jobId(id), token || null, duration);
+            return extended ? duration : 0;
+        }
+        else {
+            const response = await this.tcp.send({ cmd: 'ExtendLock', id, token, duration });
+            return response.ok ? duration : 0;
+        }
+    }
+    /** Clear job logs */
+    async clearJobLogs(id, keepLogs) {
+        if (this.embedded) {
+            const manager = getSharedManager();
+            manager.clearLogs(jobId(id), keepLogs);
+        }
+        else {
+            await this.tcp.send({ cmd: 'ClearLogs', id, keepLogs });
+        }
+    }
+    /** Get job dependencies */
+    async getJobDependencies(id, _opts) {
+        if (this.embedded) {
+            const manager = getSharedManager();
+            const job = await manager.getJob(jobId(id));
+            if (!job)
+                return { processed: {}, unprocessed: [] };
+            const childIds = job.childrenIds;
+            const processed = {};
+            const unprocessed = [];
+            for (const childId of childIds) {
+                const result = manager.getResult(childId);
+                if (result !== undefined) {
+                    const childJob = await manager.getJob(childId);
+                    const key = childJob ? `${childJob.queue}:${childId}` : String(childId);
+                    processed[key] = result;
+                }
+                else {
+                    unprocessed.push(String(childId));
+                }
+            }
+            return { processed, unprocessed };
+        }
+        // TCP mode
+        return { processed: {}, unprocessed: [] };
+    }
+    /** Get job dependencies count */
+    async getJobDependenciesCount(id, _opts) {
+        if (this.embedded) {
+            const deps = await this.getJobDependencies(id);
+            return {
+                processed: Object.keys(deps.processed).length,
+                unprocessed: deps.unprocessed.length,
+            };
+        }
+        return { processed: 0, unprocessed: 0 };
+    }
+    // ============================================================================
+    // BullMQ v5 Job Move Methods
+    // ============================================================================
+    /**
+     * Move job to completed state (BullMQ v5 compatible).
+     * Used internally by workers to mark jobs as complete.
+     */
+    async moveJobToCompleted(id, returnValue, _token) {
+        if (this.embedded) {
+            const manager = getSharedManager();
+            await manager.ack(jobId(id), returnValue);
+            return null; // Could return next job if fetchNext was true
+        }
+        else {
+            await this.tcp.send({ cmd: 'ACK', id, result: returnValue });
+            return null;
+        }
+    }
+    /**
+     * Move job to failed state (BullMQ v5 compatible).
+     * Used internally by workers to mark jobs as failed.
+     */
+    async moveJobToFailed(id, error, _token) {
+        if (this.embedded) {
+            const manager = getSharedManager();
+            await manager.fail(jobId(id), error.message);
+        }
+        else {
+            await this.tcp.send({ cmd: 'FAIL', id, error: error.message });
+        }
+    }
+    /**
+     * Move job back to waiting state (BullMQ v5 compatible).
+     * Useful for re-queueing a job that needs to be processed again.
+     */
+    async moveJobToWait(id, _token) {
+        if (this.embedded) {
+            const manager = getSharedManager();
+            const job = await manager.getJob(jobId(id));
+            if (!job)
+                return false;
+            // Re-queue the job by pushing it again
+            await manager.push(job.queue, {
+                data: job.data,
+                priority: job.priority,
+                customId: job.customId ?? undefined,
+            });
+            return true;
+        }
+        else {
+            const response = await this.tcp.send({ cmd: 'MoveToWait', id });
+            return response.ok === true;
+        }
+    }
+    /**
+     * Move job to delayed state (BullMQ v5 compatible).
+     * The job will become available for processing at the specified timestamp.
+     */
+    async moveJobToDelayed(id, timestamp, _token) {
+        if (this.embedded) {
+            const manager = getSharedManager();
+            const delay = Math.max(0, timestamp - Date.now());
+            await manager.changeDelay(jobId(id), delay);
+        }
+        else {
+            await this.tcp.send({ cmd: 'MoveToDelayed', id, timestamp });
+        }
+    }
+    /**
+     * Move job to waiting-children state (BullMQ v5 compatible).
+     * Job will wait for all children to complete before processing.
+     */
+    async moveJobToWaitingChildren(id, _token, _opts) {
+        if (this.embedded) {
+            // In embedded mode, this is handled automatically by the dependency system
+            // The job is already in waiting-children state if it has pending children
+            const manager = getSharedManager();
+            const job = await manager.getJob(jobId(id));
+            if (!job)
+                return false;
+            // Check if job has unprocessed children
+            const deps = await this.getJobDependencies(id);
+            return deps.unprocessed.length > 0;
+        }
+        return false;
+    }
+    /**
+     * Wait until job has finished (completed or failed).
+     * BullMQ v5 compatible method.
+     */
+    async waitJobUntilFinished(id, queueEvents, ttl) {
+        return new Promise((resolve, reject) => {
+            const timeout = ttl
+                ? setTimeout(() => {
+                    cleanup();
+                    reject(new Error(`Job ${id} timed out after ${ttl}ms`));
+                }, ttl)
+                : null;
+            // Cast queueEvents to expected interface
+            const events = queueEvents;
+            const completedHandler = (data) => {
+                if (data.jobId === id) {
+                    cleanup();
+                    resolve(data.returnvalue);
+                }
+            };
+            const failedHandler = (data) => {
+                if (data.jobId === id) {
+                    cleanup();
+                    reject(new Error(data.failedReason ?? 'Job failed'));
+                }
+            };
+            const cleanup = () => {
+                if (timeout)
+                    clearTimeout(timeout);
+                events.off('completed', completedHandler);
+                events.off('failed', failedHandler);
+            };
+            events.on('completed', completedHandler);
+            events.on('failed', failedHandler);
+            // Also check if job is already finished
+            void this.getJobState(id).then((state) => {
+                if (state === 'completed') {
+                    cleanup();
+                    // Get the result
+                    if (this.embedded) {
+                        const result = getSharedManager().getResult(jobId(id));
+                        resolve(result);
+                    }
+                    else {
+                        resolve(undefined);
+                    }
+                }
+                else if (state === 'failed') {
+                    cleanup();
+                    reject(new Error('Job already failed'));
+                }
+            });
+        });
+    }
     close() {
         if (this.tcpPool) {
             if (this.useSharedPool)
@@ -370,20 +1525,118 @@ export class Queue {
     }
     createJobProxy(id, name, data) {
         const tcp = this.tcp;
+        const ts = Date.now();
         return {
             id,
             name,
             data,
             queueName: this.name,
             attemptsMade: 0,
-            timestamp: Date.now(),
+            timestamp: ts,
             progress: 0,
+            // BullMQ v5 properties
+            delay: 0,
+            processedOn: undefined,
+            finishedOn: undefined,
+            stacktrace: null,
+            stalledCounter: 0,
+            priority: 0,
+            parentKey: undefined,
+            opts: {},
+            token: undefined,
+            processedBy: undefined,
+            deduplicationId: undefined,
+            repeatJobKey: undefined,
+            attemptsStarted: 0,
+            // Methods
             updateProgress: async (progress, message) => {
                 await tcp.send({ cmd: 'Progress', id, progress, message });
             },
             log: async (message) => {
                 await tcp.send({ cmd: 'AddLog', id, message });
             },
+            getState: () => this.getJobState(id),
+            remove: () => this.removeAsync(id),
+            retry: () => this.retryJob(id),
+            getChildrenValues: () => this.getChildrenValues(id),
+            // BullMQ v5 state check methods
+            isWaiting: async () => (await this.getJobState(id)) === 'waiting',
+            isActive: async () => (await this.getJobState(id)) === 'active',
+            isDelayed: async () => (await this.getJobState(id)) === 'delayed',
+            isCompleted: async () => (await this.getJobState(id)) === 'completed',
+            isFailed: async () => (await this.getJobState(id)) === 'failed',
+            isWaitingChildren: () => Promise.resolve(false),
+            // BullMQ v5 mutation methods
+            updateData: async (newData) => {
+                await tcp.send({ cmd: 'Update', id, data: newData });
+            },
+            promote: async () => {
+                await tcp.send({ cmd: 'Promote', id });
+            },
+            changeDelay: async (delay) => {
+                await tcp.send({ cmd: 'ChangeDelay', id, delay });
+            },
+            changePriority: async (opts) => {
+                await tcp.send({ cmd: 'ChangePriority', id, priority: opts.priority });
+            },
+            extendLock: async (_token, duration) => {
+                const res = await tcp.send({ cmd: 'ExtendLock', id, duration });
+                return res.ok ? duration : 0;
+            },
+            clearLogs: async () => {
+                await tcp.send({ cmd: 'ClearLogs', id });
+            },
+            // BullMQ v5 dependency methods
+            getDependencies: () => Promise.resolve({ processed: {}, unprocessed: [] }),
+            getDependenciesCount: () => Promise.resolve({ processed: 0, unprocessed: 0 }),
+            // BullMQ v5 serialization methods
+            toJSON: () => ({
+                id,
+                name,
+                data,
+                opts: {},
+                progress: 0,
+                delay: 0,
+                timestamp: ts,
+                attemptsMade: 0,
+                stacktrace: null,
+                queueQualifiedName: `bull:${this.name}`,
+            }),
+            asJSON: () => ({
+                id,
+                name,
+                data: JSON.stringify(data),
+                opts: '{}',
+                progress: '0',
+                delay: '0',
+                timestamp: String(ts),
+                attemptsMade: '0',
+                stacktrace: null,
+            }),
+            // BullMQ v5 move methods
+            moveToCompleted: async (returnValue) => {
+                await tcp.send({ cmd: 'ACK', id, result: returnValue });
+                return null;
+            },
+            moveToFailed: async (error) => {
+                await tcp.send({ cmd: 'FAIL', id, error: error.message });
+            },
+            moveToWait: async () => {
+                const res = await tcp.send({ cmd: 'MoveToWait', id });
+                return res.ok === true;
+            },
+            moveToDelayed: async (timestamp) => {
+                await tcp.send({ cmd: 'MoveToDelayed', id, timestamp });
+            },
+            moveToWaitingChildren: () => Promise.resolve(false),
+            waitUntilFinished: () => Promise.resolve(undefined),
+            // BullMQ v5 additional methods
+            discard: () => { },
+            getFailedChildrenValues: () => Promise.resolve({}),
+            getIgnoredChildrenFailures: () => Promise.resolve({}),
+            removeChildDependency: () => Promise.resolve(false),
+            removeDeduplicationKey: () => Promise.resolve(false),
+            removeUnprocessedChildren: () => Promise.resolve(),
         };
     }
     createSimpleJob(id, name, data, timestamp) {
@@ -395,8 +1648,82 @@ export class Queue {
             attemptsMade: 0,
             timestamp,
             progress: 0,
+            // BullMQ v5 properties
+            delay: 0,
+            processedOn: undefined,
+            finishedOn: undefined,
+            stacktrace: null,
+            stalledCounter: 0,
+            priority: 0,
+            parentKey: undefined,
+            opts: {},
+            token: undefined,
+            processedBy: undefined,
+            deduplicationId: undefined,
+            repeatJobKey: undefined,
+            attemptsStarted: 0,
+            // Methods
             updateProgress: async () => { },
             log: async () => { },
+            getState: () => this.getJobState(id),
+            remove: () => this.removeAsync(id),
+            retry: () => this.retryJob(id),
+            getChildrenValues: () => this.getChildrenValues(id),
+            // BullMQ v5 state check methods
+            isWaiting: async () => (await this.getJobState(id)) === 'waiting',
+            isActive: async () => (await this.getJobState(id)) === 'active',
+            isDelayed: async () => (await this.getJobState(id)) === 'delayed',
+            isCompleted: async () => (await this.getJobState(id)) === 'completed',
+            isFailed: async () => (await this.getJobState(id)) === 'failed',
+            isWaitingChildren: () => Promise.resolve(false),
+            // BullMQ v5 mutation methods
+            updateData: async () => { },
+            promote: async () => { },
+            changeDelay: async () => { },
+            changePriority: async () => { },
+            extendLock: () => Promise.resolve(0),
+            clearLogs: async () => { },
+            // BullMQ v5 dependency methods
+            getDependencies: () => Promise.resolve({ processed: {}, unprocessed: [] }),
+            getDependenciesCount: () => Promise.resolve({ processed: 0, unprocessed: 0 }),
+            // BullMQ v5 serialization methods
+            toJSON: () => ({
+                id,
+                name,
+                data,
+                opts: {},
+                progress: 0,
+                delay: 0,
+                timestamp,
+                attemptsMade: 0,
+                stacktrace: null,
+                queueQualifiedName: `bull:${this.name}`,
+            }),
+            asJSON: () => ({
+                id,
+                name,
+                data: JSON.stringify(data),
+                opts: '{}',
+                progress: '0',
+                delay: '0',
+                timestamp: String(timestamp),
+                attemptsMade: '0',
+                stacktrace: null,
+            }),
+            // BullMQ v5 move methods
+            moveToCompleted: () => Promise.resolve(null),
+            moveToFailed: () => Promise.resolve(),
+            moveToWait: () => Promise.resolve(false),
+            moveToDelayed: () => Promise.resolve(),
+            moveToWaitingChildren: () => Promise.resolve(false),
+            waitUntilFinished: () => Promise.resolve(undefined),
+            // BullMQ v5 additional methods
+            discard: () => { },
+            getFailedChildrenValues: () => Promise.resolve({}),
+            getIgnoredChildrenFailures: () => Promise.resolve({}),
+            removeChildDependency: () => Promise.resolve(false),
+            removeDeduplicationKey: () => Promise.resolve(false),
+            removeUnprocessedChildren: () => Promise.resolve(),
         };
     }
 }