bunqueue 2.8.53 → 2.8.56

package/dist/application/queue-manager/delivery.js

@@ -0,0 +1,143 @@
+import { DEFAULT_LOCK_TTL } from '../../domain/types/job';
+import { setDlqRetryState } from '../../domain/types/dlq';
+import { withWriteLock } from '../../shared/lock';
+import { pushJob, pushJobBatch } from '../operations/push';
+import { pushFlowBatch } from '../operations/flowPush';
+import { pullJob, pullJobBatch } from '../operations/pull';
+import { commitRemovedCompletion } from '../dependencyCompletions';
+import * as lockMgr from '../lockManager';
+import { managerRuntime } from './context';
+import { QueueManagerState } from './state';
+export class QueueManagerDelivery extends QueueManagerState {
+    async push(queue, input) {
+        managerRuntime(this).registerQueueName(queue);
+        return pushJob(queue, input, this.contextFactory.getPushContext());
+    }
+    async pushBatch(queue, inputs) {
+        managerRuntime(this).registerQueueName(queue);
+        return pushJobBatch(queue, inputs, this.contextFactory.getPushContext());
+    }
+    async pushFlow(batch) {
+        return pushFlowBatch(batch, this.contextFactory.getPushContext());
+    }
+    async pull(queue, timeoutMs = 0, signal) {
+        const job = await pullJob(queue, timeoutMs, this.contextFactory.getPullContext(), signal);
+        if (job)
+            this.scheduleJobTimeout(job);
+        return job;
+    }
+    async pullWithLock(queue, owner, timeoutMs = 0, lockTtl = DEFAULT_LOCK_TTL, signal) {
+        const job = await pullJob(queue, timeoutMs, this.contextFactory.getPullContext(), signal);
+        if (!job)
+            return { job: null, token: null };
+        const token = lockMgr.createLock(job.id, owner, this.contextFactory.getLockContext(), lockTtl);
+        this.scheduleJobTimeout(job);
+        return { job, token };
+    }
+    async pullBatch(queue, count, timeoutMs = 0, signal) {
+        const jobs = await pullJobBatch(queue, count, timeoutMs, this.contextFactory.getPullContext(), signal);
+        for (const job of jobs)
+            this.scheduleJobTimeout(job);
+        return jobs;
+    }
+    // biome-ignore lint/complexity/useMaxParams: public API includes cancellation and lock policy
+    async pullBatchWithLock(queue, count, owner, timeoutMs = 0, lockTtl = DEFAULT_LOCK_TTL, signal) {
+        const jobs = await pullJobBatch(queue, count, timeoutMs, this.contextFactory.getPullContext(), signal);
+        const tokens = jobs.map((job) => lockMgr.createLock(job.id, owner, this.contextFactory.getLockContext(), lockTtl) ?? '');
+        for (const job of jobs)
+            this.scheduleJobTimeout(job);
+        return { jobs, tokens };
+    }
+    throwIfOwnershipConflict(jobId, lockCtx) {
+        const location = this.jobIndex.get(jobId);
+        if (location?.type === 'processing' && lockCtx.jobLocks.has(jobId)) {
+            throw new Error(`Invalid or expired lock token for job ${jobId}`);
+        }
+    }
+    /** Require the exact current lease token whenever a lock record exists. */
+    assertLeaseToken(jobId, token, lockCtx) {
+        const lock = lockCtx.jobLocks.get(jobId);
+        if (!lock)
+            return;
+        if (!token)
+            throw new Error(`Lock token required for job ${jobId}`);
+        if (lock.token !== token)
+            throw new Error(`Invalid or expired lock token for job ${jobId}`);
+        const location = this.jobIndex.get(jobId);
+        if (location?.type !== 'processing')
+            return;
+        const job = this.processingShards[location.shardIdx].get(jobId);
+        if (!job || (job.startedAt !== null && job.startedAt > lock.createdAt)) {
+            throw new Error(`Invalid or expired lock token for job ${jobId}`);
+        }
+    }
+    isExpiredButOwned(jobId, token, lockCtx) {
+        const location = this.jobIndex.get(jobId);
+        if (location?.type !== 'processing')
+            return false;
+        const lock = lockCtx.jobLocks.get(jobId);
+        if (lock?.token !== token)
+            return false;
+        const job = this.processingShards[location.shardIdx].get(jobId);
+        return !(job && job.startedAt !== null && job.startedAt > lock.createdAt);
+    }
+    isStallRetried(jobId) {
+        const location = this.jobIndex.get(jobId);
+        if (location?.type !== 'queue')
+            return false;
+        const job = this.shards[location.shardIdx].getQueue(location.queueName).find(jobId);
+        return job !== null && job.attempts > 0;
+    }
+    /** Match a late outcome to the exact cron lease retired by lock expiry. */
+    isRetiredCronOutcome(jobId, token) {
+        return (token !== undefined &&
+            !this.jobIndex.has(jobId) &&
+            this.retiredCronLeaseTokens.get(jobId) === token);
+    }
+    async completeStallRetriedJob(jobId, result, removeOnComplete) {
+        const location = this.jobIndex.get(jobId);
+        if (location?.type !== 'queue')
+            return false;
+        const shard = this.shards[location.shardIdx];
+        let job = null;
+        await withWriteLock(this.shardLocks[location.shardIdx], () => {
+            job = shard.getQueue(location.queueName).remove(jobId);
+            if (job) {
+                shard.decrementQueued(jobId);
+                shard.releaseJobResources(location.queueName, job.uniqueKey, job.groupId, job.id);
+            }
+        });
+        if (!job)
+            return false;
+        const completedJob = job;
+        setDlqRetryState(completedJob, null);
+        const ctx = this.contextFactory.getAckContext();
+        if (!(completedJob.removeOnComplete || removeOnComplete === true)) {
+            ctx.completedJobs.add(jobId);
+            ctx.completedJobsData.set(jobId, completedJob);
+            if (result !== undefined) {
+                ctx.jobResults.set(jobId, result);
+                ctx.storage?.storeResult(jobId, result);
+            }
+            ctx.jobIndex.set(jobId, { type: 'completed', queueName: completedJob.queue });
+            ctx.storage?.markCompleted(jobId, Date.now(), completedJob.timeline);
+        }
+        else {
+            commitRemovedCompletion(completedJob, ctx);
+            ctx.jobIndex.delete(jobId);
+        }
+        if (result !== undefined)
+            ctx.dependencyResults.retain(jobId, result);
+        ctx.dependencyResults.releaseConsumer(jobId);
+        ctx.totalCompleted.value++;
+        ctx.broadcast({
+            eventType: "completed" /* EventType.Completed */,
+            queue: location.queueName,
+            jobId,
+            timestamp: Date.now(),
+            data: result,
+        });
+        ctx.onJobCompleted(jobId);
+        return true;
+    }
+}

package/dist/application/queue-manager/dependencies.d.ts

@@ -0,0 +1,8 @@
+import type { JobId } from '../../domain/types/job';
+import { QueueManagerFlowOptions } from './flow-options';
+export declare class QueueManagerDependencies extends QueueManagerFlowOptions {
+    getFailedChildrenValues(parentJobId: JobId): Promise<Record<string, string>>;
+    getIgnoredChildrenFailures(parentJobId: JobId): Promise<Record<string, string>>;
+    removeChildDependency(childJobId: JobId): Promise<boolean>;
+    removeUnprocessedChildren(parentJobId: JobId): Promise<void>;
+}

package/dist/application/queue-manager/dependencies.js

@@ -0,0 +1,127 @@
+import { processingShardIndex, shardIndex } from '../../shared/hash';
+import { QueueManagerFlowOptions } from './flow-options';
+export class QueueManagerDependencies extends QueueManagerFlowOptions {
+    async getFailedChildrenValues(parentJobId) {
+        return this.failedChildrenValues.get(parentJobId) ?? {};
+    }
+    async getIgnoredChildrenFailures(parentJobId) {
+        return this.ignoredChildrenFailures.get(parentJobId) ?? {};
+    }
+    async removeChildDependency(childJobId) {
+        const childJob = await this.getJob(childJobId);
+        if (!childJob)
+            throw new Error(`Job not found: ${childJobId}`);
+        if (!childJob.parentId)
+            throw new Error(`Job ${childJobId} has no parent`);
+        const parentId = childJob.parentId;
+        const parentJob = await this.getJob(parentId);
+        if (!parentJob || this.jobIndex.get(parentId)?.type !== 'queue')
+            return false;
+        const childLocation = this.jobIndex.get(childJobId);
+        if (childLocation?.type !== 'queue' && childLocation?.type !== 'processing')
+            return false;
+        const parentIndex = shardIndex(parentJob.queue);
+        const shardIndexes = [...new Set([parentIndex, shardIndex(childJob.queue)])].sort((a, b) => a - b);
+        const processingIndexes = childLocation.type === 'processing' ? [processingShardIndex(childJobId)] : [];
+        const guards = [];
+        let removed = false;
+        let promoted = false;
+        let releasedDependencies = [];
+        try {
+            for (const index of shardIndexes)
+                guards.push(await this.shardLocks[index].acquireWrite());
+            for (const index of processingIndexes) {
+                guards.push(await this.processingLocks[index].acquireWrite());
+            }
+            if (this.jobIndex.get(parentId)?.type !== 'queue' ||
+                this.jobIndex.get(childJobId)?.type !== childLocation.type) {
+                return false;
+            }
+            const shard = this.shards[parentIndex];
+            if (!shard.waitingDeps.has(parentId) || !parentJob.dependsOn.includes(childJobId)) {
+                return false;
+            }
+            const unresolved = parentJob.dependsOn.filter((dependency) => dependency !== childJobId &&
+                !this.completedJobs.has(dependency) &&
+                !this.depCompletions.has(dependency));
+            releasedDependencies = parentJob.dependsOn.filter((dependency) => !unresolved.includes(dependency));
+            const childrenIds = parentJob.childrenIds.filter((childId) => childId !== childJobId);
+            const childData = { ...childJob.data };
+            delete childData.__parentId;
+            delete childData.__parentQueue;
+            const parentData = { ...parentJob.data };
+            if (childrenIds.length > 0)
+                parentData.__childrenIds = childrenIds.map(String);
+            else
+                delete parentData.__childrenIds;
+            const runAt = unresolved.length === 0 ? Date.now() : parentJob.runAt;
+            const parentState = unresolved.length > 0
+                ? 'waiting-children'
+                : parentJob.priority > 0
+                    ? 'prioritized'
+                    : 'waiting';
+            const detachedChild = { ...childJob, parentId: null, data: childData };
+            const detachedParent = {
+                ...parentJob,
+                childrenIds,
+                dependsOn: unresolved,
+                data: parentData,
+                runAt,
+            };
+            this.storage?.removeFlowLink(detachedChild, detachedParent, parentState);
+            childJob.parentId = null;
+            childJob.data = childData;
+            parentJob.childrenIds = childrenIds;
+            parentJob.dependsOn = unresolved;
+            parentJob.data = parentData;
+            parentJob.runAt = runAt;
+            shard.unregisterDependencies(parentId, releasedDependencies);
+            for (const dependency of releasedDependencies) {
+                this.dependencyResults.releaseDependency(parentId, dependency);
+            }
+            if (unresolved.length === 0) {
+                shard.waitingDeps.delete(parentId);
+                shard.getQueue(parentJob.queue).push(parentJob);
+                shard.incrementQueued(parentId, false, parentJob.createdAt, parentJob.queue, runAt);
+                this.jobIndex.set(parentId, {
+                    type: 'queue',
+                    shardIdx: parentIndex,
+                    queueName: parentJob.queue,
+                });
+                shard.notify(parentJob.queue);
+                promoted = true;
+            }
+            removed = true;
+        }
+        finally {
+            for (let index = guards.length - 1; index >= 0; index--)
+                guards[index].release();
+        }
+        this.releaseCompletionPins(releasedDependencies);
+        if (promoted) {
+            this.eventsManager.broadcast({
+                eventType: 'waiting',
+                queue: parentJob.queue,
+                jobId: parentId,
+                timestamp: Date.now(),
+                prev: 'waiting-children',
+            });
+        }
+        return removed;
+    }
+    async removeUnprocessedChildren(parentJobId) {
+        const parent = await this.getJob(parentJobId);
+        if (!parent?.childrenIds || parent.childrenIds.length === 0)
+            return;
+        for (const childId of parent.childrenIds) {
+            if (this.jobIndex.get(childId)?.type !== 'queue')
+                continue;
+            try {
+                await this.cancel(childId);
+            }
+            catch {
+                // Best effort: active and terminal children are intentionally retained.
+            }
+        }
+    }
+}

package/dist/application/queue-manager/dependency-runtime.d.ts

@@ -0,0 +1,8 @@
+import type { JobId } from '../../domain/types/job';
+import { QueueManagerServices } from './services';
+export declare class QueueManagerDependencyRuntime extends QueueManagerServices {
+    protected onJobsCompleted(completedIds: JobId[]): void;
+    protected scheduleDependencyFlush(): void;
+    protected runDependencyFlush(): Promise<void>;
+    protected hasPendingDeps(): boolean;
+}

package/dist/application/queue-manager/dependency-runtime.js

@@ -0,0 +1,40 @@
+import { processPendingDependencies } from '../dependencyProcessor';
+import { handleTaskError, handleTaskSuccess } from '../taskErrorTracking';
+import { QueueManagerServices } from './services';
+export class QueueManagerDependencyRuntime extends QueueManagerServices {
+    onJobsCompleted(completedIds) {
+        for (const id of completedIds)
+            this.pendingDepChecks.add(id);
+        this.scheduleDependencyFlush();
+    }
+    scheduleDependencyFlush() {
+        if (this.depFlushScheduled)
+            return;
+        this.depFlushScheduled = true;
+        queueMicrotask(() => {
+            this.depFlushScheduled = false;
+            if (!this.depFlushRunning)
+                void this.runDependencyFlush();
+        });
+    }
+    async runDependencyFlush() {
+        this.depFlushRunning = true;
+        try {
+            while (this.pendingDepChecks.size > 0) {
+                await processPendingDependencies(this.contextFactory.getBackgroundContext());
+                handleTaskSuccess('dependency');
+            }
+        }
+        catch (error) {
+            handleTaskError('dependency', error);
+        }
+        finally {
+            this.depFlushRunning = false;
+            if (this.pendingDepChecks.size > 0)
+                this.scheduleDependencyFlush();
+        }
+    }
+    hasPendingDeps() {
+        return this.shards.some((shard) => shard.waitingDeps.size > 0);
+    }
+}

package/dist/application/queue-manager/flow-failures.d.ts

@@ -0,0 +1,18 @@
+import type { Shard } from '../../domain/queue/shard';
+import type { DlqEntry } from '../../domain/types/dlq';
+import type { Job, JobId } from '../../domain/types/job';
+import type { JobLocation } from '../../domain/types/queue';
+import type { SetLike } from '../../shared/lru';
+import { QueueManagerDependencyRuntime } from './dependency-runtime';
+export declare class QueueManagerFlowFailures extends QueueManagerDependencyRuntime {
+    protected onDlqEvicted(entry: DlqEntry): void;
+    getJobIndex(): Map<JobId, JobLocation>;
+    getCompletedJobs(): SetLike<JobId>;
+    getDepCompletions(): SetLike<JobId>;
+    getShards(): Shard[];
+    protected onJobCompleted(completedId: JobId): void;
+    protected onJobFailed(failedId: JobId): void;
+    protected checkFlowCompleted(completedId: JobId): Promise<void>;
+    protected failParentOnChildFailure(childJob: Job, error: string | undefined): Promise<void>;
+    protected moveParentToFailed(parentId: JobId, childJob: Job, error: string | undefined): Promise<void>;
+}

package/dist/application/queue-manager/flow-failures.js

@@ -0,0 +1,107 @@
+import { shardIndex } from '../../shared/hash';
+import { withWriteLock } from '../../shared/lock';
+import { QueueManagerDependencyRuntime } from './dependency-runtime';
+export class QueueManagerFlowFailures extends QueueManagerDependencyRuntime {
+    onDlqEvicted(entry) {
+        const location = this.jobIndex.get(entry.job.id);
+        const ownsTerminal = location === undefined || (location.type === 'dlq' && location.queueName === entry.job.queue);
+        if (ownsTerminal) {
+            this.jobIndex.delete(entry.job.id);
+            this.jobResults.delete(entry.job.id);
+            this.jobLogs.delete(entry.job.id);
+        }
+        this.storage?.purgeDlqEntries(entry.job.queue, [entry.job.id], ownsTerminal ? [entry.job.id] : [], false);
+    }
+    getJobIndex() {
+        return this.jobIndex;
+    }
+    getCompletedJobs() {
+        return this.completedJobs;
+    }
+    getDepCompletions() {
+        return this.depCompletions;
+    }
+    getShards() {
+        return this.shards;
+    }
+    onJobCompleted(completedId) {
+        this.failedChildrenValues.delete(completedId);
+        this.ignoredChildrenFailures.delete(completedId);
+        this.storage?.deleteFlowFailure(completedId);
+        this.pendingDepChecks.add(completedId);
+        this.scheduleDependencyFlush();
+        void this.checkFlowCompleted(completedId);
+    }
+    onJobFailed(failedId) {
+        this.failedChildrenValues.delete(failedId);
+        this.ignoredChildrenFailures.delete(failedId);
+        this.storage?.deleteFlowFailure(failedId);
+    }
+    async checkFlowCompleted(completedId) {
+        const job = await this.getJob(completedId);
+        if (!job?.parentId)
+            return;
+        const parent = await this.getJob(job.parentId);
+        if (!parent?.childrenIds || parent.childrenIds.length === 0)
+            return;
+        if (parent.childrenIds.every((childId) => this.completedJobs.has(childId))) {
+            this.dashboardEmit?.('flow:completed', {
+                parentJobId: String(parent.id),
+                queue: parent.queue,
+                childrenCount: parent.childrenIds.length,
+            });
+        }
+    }
+    async failParentOnChildFailure(childJob, error) {
+        if (childJob.parentId)
+            await this.moveParentToFailed(childJob.parentId, childJob, error);
+    }
+    async moveParentToFailed(parentId, childJob, error) {
+        const parentJob = await this.getJob(parentId);
+        if (!parentJob || this.jobIndex.get(parentId)?.type !== 'queue')
+            return;
+        const index = shardIndex(parentJob.queue);
+        let releasedDependencies = [];
+        await withWriteLock(this.shardLocks[index], () => {
+            if (this.jobIndex.get(parentId)?.type !== 'queue')
+                return;
+            const shard = this.shards[index];
+            if (shard.waitingDeps.has(parentId)) {
+                releasedDependencies = [...parentJob.dependsOn];
+                shard.waitingDeps.delete(parentId);
+                shard.unregisterDependencies(parentId, parentJob.dependsOn);
+            }
+            shard.waitingChildren.delete(parentId);
+            const queue = shard.getQueue(parentJob.queue);
+            if (queue.find(parentId)) {
+                queue.remove(parentId);
+                shard.decrementQueued(parentId);
+            }
+            const failError = `Child job ${childJob.id} failed: ${error ?? 'unknown error'}`;
+            const entry = shard.addToDlq(parentJob, "unknown" /* FailureReason.Unknown */, failError);
+            this.jobIndex.set(parentId, { type: 'dlq', queueName: parentJob.queue });
+            this.storage?.saveDlqEntry(entry);
+            this.storage?.deleteJob(parentId);
+            this.storage?.deleteFlowFailure(parentId, childJob.id);
+        });
+        this.releaseCompletionPins(releasedDependencies);
+        this.failedChildrenValues.delete(parentId);
+        this.ignoredChildrenFailures.delete(parentId);
+        this.dependencyResults.releaseConsumer(parentId);
+        const failError = `Child job ${childJob.id} failed: ${error ?? 'unknown error'}`;
+        this.eventsManager.broadcast({
+            eventType: "failed" /* EventType.Failed */,
+            queue: parentJob.queue,
+            jobId: parentId,
+            timestamp: Date.now(),
+            error: failError,
+            data: parentJob.data,
+        });
+        this.dashboardEmit?.('flow:failed', {
+            parentJobId: String(parentId),
+            failedChildId: String(childJob.id),
+            queue: parentJob.queue,
+            error: error ?? 'Child job failed',
+        });
+    }
+}

package/dist/application/queue-manager/flow-options.d.ts

@@ -0,0 +1,8 @@
+import type { Job, JobId } from '../../domain/types/job';
+import { QueueManagerFlowFailures } from './flow-failures';
+export declare class QueueManagerFlowOptions extends QueueManagerFlowFailures {
+    protected onChildDependencyOption(childJob: Job, error: string | undefined): Promise<void>;
+    protected continueParentOnChildFailure(childJob: Job, error: string | undefined): Promise<void>;
+    protected promoteParentAfterChildFailure(parentId: JobId, parentJob: Job, index: number): Promise<void>;
+    protected removeChildFromParentDeps(childJob: Job, error: string | undefined, storeIgnored: boolean): Promise<void>;
+}

package/dist/application/queue-manager/flow-options.js

@@ -0,0 +1,129 @@
+import { shardIndex } from '../../shared/hash';
+import { withWriteLock } from '../../shared/lock';
+import { QueueManagerFlowFailures } from './flow-failures';
+export class QueueManagerFlowOptions extends QueueManagerFlowFailures {
+    async onChildDependencyOption(childJob, error) {
+        if (!childJob.parentId)
+            return;
+        if (childJob.continueParentOnFailure) {
+            await this.continueParentOnChildFailure(childJob, error);
+        }
+        else {
+            await this.removeChildFromParentDeps(childJob, error, childJob.ignoreDependencyOnFailure);
+        }
+    }
+    async continueParentOnChildFailure(childJob, error) {
+        const parentId = childJob.parentId;
+        if (!parentId)
+            return;
+        const parentJob = await this.getJob(parentId);
+        if (!parentJob || this.jobIndex.get(parentId)?.type !== 'queue')
+            return;
+        const childKey = `${childJob.queue}:${childJob.id}`;
+        const existing = this.failedChildrenValues.get(parentId) ?? {};
+        existing[childKey] = error ?? 'unknown error';
+        this.failedChildrenValues.set(parentId, existing);
+        const index = shardIndex(parentJob.queue);
+        let releasedDependencies = [];
+        await withWriteLock(this.shardLocks[index], () => {
+            if (this.jobIndex.get(parentId)?.type !== 'queue')
+                return;
+            const shard = this.shards[index];
+            releasedDependencies = [...parentJob.dependsOn];
+            shard.unregisterDependencies(parentId, releasedDependencies);
+            for (const dependency of releasedDependencies) {
+                this.dependencyResults.releaseDependency(parentId, dependency);
+            }
+            parentJob.dependsOn = [];
+            this.storage?.updateFlowParentResolution(parentJob);
+        });
+        this.releaseCompletionPins(releasedDependencies);
+        await this.promoteParentAfterChildFailure(parentId, parentJob, index);
+    }
+    async promoteParentAfterChildFailure(parentId, parentJob, index) {
+        await new Promise((resolve) => {
+            const timer = setTimeout(resolve, 0);
+            timer.unref?.();
+        });
+        let promoted = false;
+        let releasedDependencies = [];
+        await withWriteLock(this.shardLocks[index], () => {
+            if (this.jobIndex.get(parentId)?.type !== 'queue')
+                return;
+            const shard = this.shards[index];
+            if (shard.waitingDeps.has(parentId)) {
+                releasedDependencies = [...parentJob.dependsOn];
+                shard.waitingDeps.delete(parentId);
+                shard.unregisterDependencies(parentId, parentJob.dependsOn);
+            }
+            shard.waitingChildren.delete(parentId);
+            const queue = shard.getQueue(parentJob.queue);
+            if (!queue.find(parentId)) {
+                const now = Date.now();
+                parentJob.runAt = now;
+                queue.push(parentJob);
+                shard.incrementQueued(parentId, false, parentJob.createdAt, parentJob.queue, now);
+                this.jobIndex.set(parentId, {
+                    type: 'queue',
+                    shardIdx: index,
+                    queueName: parentJob.queue,
+                });
+                this.storage?.updateFlowParentResolution(parentJob);
+                shard.notify(parentJob.queue);
+                promoted = true;
+            }
+        });
+        this.releaseCompletionPins(releasedDependencies);
+        if (promoted) {
+            this.eventsManager.broadcast({
+                eventType: 'waiting',
+                queue: parentJob.queue,
+                jobId: parentId,
+                timestamp: Date.now(),
+                prev: 'waiting-children',
+            });
+        }
+    }
+    async removeChildFromParentDeps(childJob, error, storeIgnored) {
+        const parentId = childJob.parentId;
+        if (!parentId)
+            return;
+        const parentJob = await this.getJob(parentId);
+        if (!parentJob || this.jobIndex.get(parentId)?.type !== 'queue')
+            return;
+        if (storeIgnored) {
+            const childKey = `${childJob.queue}:${childJob.id}`;
+            const existing = this.ignoredChildrenFailures.get(parentId) ?? {};
+            existing[childKey] = error ?? 'unknown error';
+            this.ignoredChildrenFailures.set(parentId, existing);
+        }
+        const index = shardIndex(parentJob.queue);
+        let readyToPromote = false;
+        let releasedDependency = null;
+        await withWriteLock(this.shardLocks[index], () => {
+            if (this.jobIndex.get(parentId)?.type !== 'queue')
+                return;
+            const shard = this.shards[index];
+            if (!shard.waitingDeps.has(parentId))
+                return;
+            const dependencyIndex = parentJob.dependsOn.indexOf(childJob.id);
+            if (dependencyIndex !== -1) {
+                parentJob.dependsOn.splice(dependencyIndex, 1);
+                shard.unregisterDependencies(parentId, [childJob.id]);
+                releasedDependency = childJob.id;
+                this.dependencyResults.releaseDependency(parentId, childJob.id);
+                this.storage?.updateFlowParentResolution(parentJob);
+            }
+            readyToPromote =
+                parentJob.dependsOn.length === 0 ||
+                    parentJob.dependsOn.every((dependency) => this.completedJobs.has(dependency));
+        });
+        if (releasedDependency)
+            this.releaseCompletionPins([releasedDependency]);
+        if (readyToPromote) {
+            await this.promoteParentAfterChildFailure(parentId, parentJob, index);
+        }
+        if (!storeIgnored)
+            this.storage?.deleteFlowFailure(parentId, childJob.id);
+    }
+}

package/dist/application/queue-manager/job-management.d.ts

@@ -0,0 +1,17 @@
+import type { JobId } from '../../domain/types/job';
+import { QueueManagerConfiguration } from './configuration';
+export declare class QueueManagerJobManagement extends QueueManagerConfiguration {
+    cancel(jobId: JobId): Promise<boolean>;
+    updateProgress(jobId: JobId, progress: number, message?: string): Promise<boolean>;
+    updateJobData(jobId: JobId, data: unknown): Promise<boolean>;
+    changePriority(jobId: JobId, priority: number, lifo?: boolean): Promise<boolean>;
+    promote(jobId: JobId): Promise<boolean>;
+    promoteJobs(queue: string, count?: number): Promise<number>;
+    moveToDelayed(jobId: JobId, delay: number, token?: string): Promise<boolean>;
+    changeDelay(jobId: JobId, delay: number, token?: string): Promise<boolean>;
+    moveActiveToWait(jobId: JobId, token?: string): Promise<boolean>;
+    changeWaitingDelay(jobId: JobId, delay: number): Promise<boolean>;
+    moveToWaitingChildren(jobId: JobId, token?: string): Promise<boolean>;
+    extendLock(jobId: JobId | string, token: string | null, duration: number): Promise<boolean>;
+    discard(jobId: JobId, token?: string): Promise<boolean>;
+}