bunqueue 2.8.53 → 2.8.56

package/dist/application/queue-manager/job-management.js

@@ -0,0 +1,100 @@
+import * as lockMgr from '../lockManager';
+import * as jobMgmt from '../operations/jobManagement';
+import * as jobPromotion from '../operations/jobPromotion';
+import * as jobTransitions from '../operations/jobStateTransitions';
+import { QueueManagerConfiguration } from './configuration';
+export class QueueManagerJobManagement extends QueueManagerConfiguration {
+    async cancel(jobId) {
+        try {
+            return await jobMgmt.cancelJob(jobId, this.contextFactory.getJobMgmtContext());
+        }
+        finally {
+            this.syncJobTimeout(jobId);
+        }
+    }
+    async updateProgress(jobId, progress, message) {
+        return jobMgmt.updateJobProgress(jobId, progress, this.contextFactory.getJobMgmtContext(), message);
+    }
+    async updateJobData(jobId, data) {
+        return jobMgmt.updateJobData(jobId, data, this.contextFactory.getJobMgmtContext());
+    }
+    async changePriority(jobId, priority, lifo) {
+        return jobMgmt.changeJobPriority(jobId, priority, this.contextFactory.getJobMgmtContext(), lifo);
+    }
+    async promote(jobId) {
+        return jobPromotion.promoteJob(jobId, this.contextFactory.getJobMgmtContext());
+    }
+    async promoteJobs(queue, count) {
+        return jobPromotion.promoteJobs(queue, count, this.contextFactory.getJobMgmtContext());
+    }
+    async moveToDelayed(jobId, delay, token) {
+        return this.changeDelay(jobId, delay, token);
+    }
+    async changeDelay(jobId, delay, token) {
+        try {
+            const lockContext = this.contextFactory.getLockContext();
+            this.assertLeaseToken(jobId, token, lockContext);
+            const context = this.contextFactory.getJobMgmtContext();
+            const location = context.jobIndex.get(jobId);
+            let moved;
+            if (location?.type === 'queue') {
+                moved = await jobTransitions.changeWaitingDelay(jobId, delay, context);
+            }
+            else {
+                moved = await jobMgmt.moveJobToDelayed(jobId, delay, context);
+            }
+            if (moved)
+                lockMgr.releaseLock(jobId, lockContext, token);
+            return moved;
+        }
+        finally {
+            this.syncJobTimeout(jobId);
+        }
+    }
+    async moveActiveToWait(jobId, token) {
+        try {
+            const lockContext = this.contextFactory.getLockContext();
+            this.assertLeaseToken(jobId, token, lockContext);
+            const moved = await jobTransitions.moveActiveToWait(jobId, this.contextFactory.getJobMgmtContext());
+            if (moved)
+                lockMgr.releaseLock(jobId, lockContext, token);
+            return moved;
+        }
+        finally {
+            this.syncJobTimeout(jobId);
+        }
+    }
+    async changeWaitingDelay(jobId, delay) {
+        return jobTransitions.changeWaitingDelay(jobId, delay, this.contextFactory.getJobMgmtContext());
+    }
+    async moveToWaitingChildren(jobId, token) {
+        try {
+            const lockContext = this.contextFactory.getLockContext();
+            this.assertLeaseToken(jobId, token, lockContext);
+            const moved = await jobTransitions.moveToWaitingChildren(jobId, this.contextFactory.getJobMgmtContext());
+            if (moved)
+                lockMgr.releaseLock(jobId, lockContext, token);
+            return moved;
+        }
+        finally {
+            this.syncJobTimeout(jobId);
+        }
+    }
+    async extendLock(jobId, token, duration) {
+        const targetId = typeof jobId === 'string' ? jobId : jobId;
+        const context = this.contextFactory.getLockContext();
+        if (token)
+            return lockMgr.renewJobLock(targetId, token, context, duration);
+        const lock = lockMgr.getLockInfo(targetId, context);
+        return lock ? lockMgr.renewJobLock(targetId, lock.token, context, duration) : false;
+    }
+    async discard(jobId, token) {
+        try {
+            this.assertLeaseToken(jobId, token, this.contextFactory.getLockContext());
+            return await jobMgmt.discardJob(jobId, this.contextFactory.getJobMgmtContext());
+        }
+        finally {
+            this.syncJobTimeout(jobId);
+        }
+    }
+}

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

@@ -0,0 +1,4 @@
+import { QueueManagerDependencies } from './dependencies';
+export declare class QueueManagerLifecycle extends QueueManagerDependencies {
+    shutdown(): void;
+}

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

@@ -0,0 +1,41 @@
+import * as bgTasks from '../backgroundTasks';
+import { QueueManagerDependencies } from './dependencies';
+export class QueueManagerLifecycle extends QueueManagerDependencies {
+    shutdown() {
+        this.cronScheduler.stop();
+        this.workerManager.stop();
+        this.eventsManager.clear();
+        this.telemetryJournal.clearMemory();
+        if (this.backgroundTaskHandles)
+            bgTasks.stopBackgroundTasks(this.backgroundTaskHandles);
+        this.storage?.close();
+        this.jobIndex.clear();
+        this.completedJobs.clear();
+        this.completedJobsData.clear();
+        this.depCompletions.clear();
+        this.timedOutJobs.clear();
+        this.retiredTimeoutLeaseTokens.clear();
+        this.retiredCronLeaseTokens.clear();
+        this.jobResults.clear();
+        this.dependencyResults.clear();
+        this.jobLogs.clear();
+        this.customIdMap.clear();
+        this.pendingDepChecks.clear();
+        this.queueNamesCache.clear();
+        this.jobLocks.clear();
+        this.stalledCandidates.clear();
+        this.clientJobs.clear();
+        this.repeatChain.clear();
+        this.failedChildrenValues.clear();
+        this.ignoredChildrenFailures.clear();
+        for (const shard of this.processingShards)
+            shard.clear();
+        for (const shard of this.shards) {
+            shard.waitingDeps.clear();
+            shard.dependencyIndex.clear();
+            shard.waitingChildren.clear();
+            shard.uniqueKeys.clear();
+            shard.activeGroups.clear();
+        }
+    }
+}

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

@@ -0,0 +1,41 @@
+import type { Job, JobId } from '../../domain/types/job';
+import type { DlqEntry, DlqFilter, DlqStats } from '../../domain/types/dlq';
+import { QueueManagerControl } from './control';
+export declare class QueueManagerLimits extends QueueManagerControl {
+    getCountsPerPriority(queue: string): Record<number, number>;
+    getJobs(queue: string, options?: {
+        state?: string | string[];
+        start?: number;
+        end?: number;
+        asc?: boolean;
+    }): Job[];
+    getDlq(queue: string, count?: number): Job[];
+    getDlqEntries(queue: string, filter?: DlqFilter): DlqEntry[];
+    getDlqCount(queue: string): number;
+    getDlqStats(queue: string): DlqStats;
+    retryDlq(queue: string, jobId?: JobId, limit?: number): number;
+    retryDlqByFilter(queue: string, filter: DlqFilter): number;
+    purgeDlq(queue: string): number;
+    retryCompleted(queue: string, jobId?: JobId, options?: {
+        limit?: number;
+        timestamp?: number;
+    }): number;
+    setRateLimit(queue: string, limit: number, durationMs?: number, ttlMs?: number): void;
+    clearRateLimit(queue: string): void;
+    setConcurrency(queue: string, limit: number): void;
+    clearConcurrency(queue: string): void;
+    protected persistQueueState(queue: string): void;
+    getQueueLimits(queue: string): {
+        rateLimit: number | null;
+        concurrencyLimit: number | null;
+    };
+    getQueueLimitStatus(queue: string, maxJobs?: number): {
+        rateLimit: {
+            max: number;
+            duration: number;
+        } | null;
+        rateLimitTtl: number;
+        concurrencyLimit: number | null;
+        maxed: boolean;
+    };
+}

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

@@ -0,0 +1,108 @@
+import { DEFAULT_DLQ_CONFIG } from '../../domain/types/dlq';
+import { DEFAULT_STALL_CONFIG } from '../../domain/types/stall';
+import { shardIndex, SHARD_COUNT } from '../../shared/hash';
+import * as dlqOps from '../dlqManager';
+import * as queryOps from '../operations/queryOperations';
+import { QueueManagerControl } from './control';
+export class QueueManagerLimits extends QueueManagerControl {
+    getCountsPerPriority(queue) {
+        const counts = this.shards[shardIndex(queue)].getCountsPerPriority(queue);
+        return Object.fromEntries(counts);
+    }
+    getJobs(queue, options = {}) {
+        const index = shardIndex(queue);
+        return queryOps.getJobs(queue, index, options, {
+            ...this.contextFactory.getQueryContext(),
+            shardCount: SHARD_COUNT,
+        });
+    }
+    getDlq(queue, count) {
+        return dlqOps.getDlqJobs(queue, this.contextFactory.getDlqContext(), count);
+    }
+    getDlqEntries(queue, filter) {
+        return dlqOps.getDlqEntries(queue, this.contextFactory.getDlqContext(), filter);
+    }
+    getDlqCount(queue) {
+        return this.shards[shardIndex(queue)].getDlqCount(queue);
+    }
+    getDlqStats(queue) {
+        return dlqOps.getDlqStats(queue, this.contextFactory.getDlqContext());
+    }
+    retryDlq(queue, jobId, limit) {
+        return dlqOps.retryDlqJobs(queue, this.contextFactory.getDlqContext(), jobId, limit);
+    }
+    retryDlqByFilter(queue, filter) {
+        return dlqOps.retryDlqByFilter(queue, this.contextFactory.getDlqContext(), filter);
+    }
+    purgeDlq(queue) {
+        return dlqOps.purgeDlqJobs(queue, this.contextFactory.getDlqContext());
+    }
+    retryCompleted(queue, jobId, options) {
+        return dlqOps.retryCompletedJobs(queue, this.contextFactory.getRetryCompletedContext(), jobId, options);
+    }
+    setRateLimit(queue, limit, durationMs, ttlMs) {
+        this.shards[shardIndex(queue)].setRateLimit(queue, limit, durationMs, ttlMs);
+        this.persistQueueState(queue);
+    }
+    clearRateLimit(queue) {
+        this.shards[shardIndex(queue)].clearRateLimit(queue);
+        this.persistQueueState(queue);
+    }
+    setConcurrency(queue, limit) {
+        this.shards[shardIndex(queue)].setConcurrency(queue, limit);
+        this.persistQueueState(queue);
+    }
+    clearConcurrency(queue) {
+        this.shards[shardIndex(queue)].clearConcurrency(queue);
+        this.persistQueueState(queue);
+    }
+    persistQueueState(queue) {
+        if (!this.storage)
+            return;
+        const shard = this.shards[shardIndex(queue)];
+        const state = shard.getState(queue);
+        const stallConfig = shard.getStallConfig(queue);
+        const dlqConfig = shard.getDlqConfig(queue);
+        const hasCustomStallConfig = stallConfig.enabled !== DEFAULT_STALL_CONFIG.enabled ||
+            stallConfig.stallInterval !== DEFAULT_STALL_CONFIG.stallInterval ||
+            stallConfig.maxStalls !== DEFAULT_STALL_CONFIG.maxStalls ||
+            stallConfig.gracePeriod !== DEFAULT_STALL_CONFIG.gracePeriod;
+        const hasCustomDlqConfig = dlqConfig.autoRetry !== DEFAULT_DLQ_CONFIG.autoRetry ||
+            dlqConfig.autoRetryInterval !== DEFAULT_DLQ_CONFIG.autoRetryInterval ||
+            dlqConfig.maxAutoRetries !== DEFAULT_DLQ_CONFIG.maxAutoRetries ||
+            dlqConfig.maxAge !== DEFAULT_DLQ_CONFIG.maxAge ||
+            dlqConfig.maxEntries !== DEFAULT_DLQ_CONFIG.maxEntries;
+        if (!state.paused &&
+            state.rateLimit === null &&
+            state.concurrencyLimit === null &&
+            !hasCustomStallConfig &&
+            !hasCustomDlqConfig) {
+            this.storage.deleteQueueState(queue);
+            return;
+        }
+        this.storage.saveQueueState(queue, {
+            paused: state.paused,
+            rateLimit: state.rateLimit,
+            concurrencyLimit: state.concurrencyLimit,
+            rateLimitDuration: state.rateLimitDuration,
+            rateLimitExpiresAt: state.rateLimitExpiresAt,
+            stallConfig,
+            dlqConfig,
+        });
+    }
+    getQueueLimits(queue) {
+        const shard = this.shards[shardIndex(queue)];
+        shard.expireRateLimitIfNeeded(queue);
+        const state = shard.getState(queue);
+        return { rateLimit: state.rateLimit, concurrencyLimit: state.concurrencyLimit };
+    }
+    getQueueLimitStatus(queue, maxJobs) {
+        const shard = this.shards[shardIndex(queue)];
+        return {
+            rateLimit: shard.getRateLimit(queue),
+            rateLimitTtl: shard.getRateLimitTtl(queue, maxJobs),
+            concurrencyLimit: shard.getConcurrency(queue),
+            maxed: shard.isConcurrencyMaxed(queue),
+        };
+    }
+}

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

@@ -0,0 +1,21 @@
+import type { JobId, JobLock, LockToken } from '../../domain/types/job';
+import { QueueManagerAck } from './ack';
+export declare class QueueManagerLocks extends QueueManagerAck {
+    jobHeartbeat(jobId: JobId, token?: string): boolean;
+    jobHeartbeatBatch(jobIds: JobId[], tokens?: string[]): number;
+    removeLock(jobId: JobId): void;
+    createLock(jobId: JobId, owner: string, ttl?: number): LockToken | null;
+    verifyLock(jobId: JobId, token: string): boolean;
+    renewJobLock(jobId: JobId, token: string, newTtl?: number): boolean;
+    renewJobLockBatch(items: Array<{
+        id: JobId;
+        token: string;
+        ttl?: number;
+    }>): string[];
+    releaseLock(jobId: JobId, token?: string): boolean;
+    getLockInfo(jobId: JobId): JobLock | null;
+    registerClientJob(clientId: string, jobId: JobId): void;
+    unregisterClientJob(clientId: string | undefined, jobId: JobId): void;
+    releaseClientJobs(clientId: string): Promise<number>;
+    forceReleaseClientJobs(clientId: string): number;
+}

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

@@ -0,0 +1,59 @@
+import { DEFAULT_LOCK_TTL } from '../../domain/types/job';
+import * as lockMgr from '../lockManager';
+import { QueueManagerAck } from './ack';
+export class QueueManagerLocks extends QueueManagerAck {
+    jobHeartbeat(jobId, token) {
+        const location = this.jobIndex.get(jobId);
+        if (location?.type !== 'processing')
+            return false;
+        if (token) {
+            return lockMgr.renewJobLock(jobId, token, this.contextFactory.getLockContext());
+        }
+        const job = this.processingShards[location.shardIdx].get(jobId);
+        if (!job)
+            return false;
+        job.lastHeartbeat = Date.now();
+        return true;
+    }
+    jobHeartbeatBatch(jobIds, tokens) {
+        let count = 0;
+        for (let index = 0; index < jobIds.length; index++) {
+            if (this.jobHeartbeat(jobIds[index], tokens?.[index]))
+                count++;
+        }
+        return count;
+    }
+    removeLock(jobId) {
+        this.contextFactory.getLockContext().jobLocks.delete(jobId);
+    }
+    createLock(jobId, owner, ttl = DEFAULT_LOCK_TTL) {
+        return lockMgr.createLock(jobId, owner, this.contextFactory.getLockContext(), ttl);
+    }
+    verifyLock(jobId, token) {
+        return lockMgr.verifyLock(jobId, token, this.contextFactory.getLockContext());
+    }
+    renewJobLock(jobId, token, newTtl) {
+        return lockMgr.renewJobLock(jobId, token, this.contextFactory.getLockContext(), newTtl);
+    }
+    renewJobLockBatch(items) {
+        return lockMgr.renewJobLockBatch(items, this.contextFactory.getLockContext());
+    }
+    releaseLock(jobId, token) {
+        return lockMgr.releaseLock(jobId, this.contextFactory.getLockContext(), token);
+    }
+    getLockInfo(jobId) {
+        return lockMgr.getLockInfo(jobId, this.contextFactory.getLockContext());
+    }
+    registerClientJob(clientId, jobId) {
+        lockMgr.registerClientJob(clientId, jobId, this.contextFactory.getLockContext());
+    }
+    unregisterClientJob(clientId, jobId) {
+        lockMgr.unregisterClientJob(clientId, jobId, this.contextFactory.getLockContext());
+    }
+    releaseClientJobs(clientId) {
+        return lockMgr.releaseClientJobs(clientId, this.contextFactory.getLockContext());
+    }
+    forceReleaseClientJobs(clientId) {
+        return lockMgr.forceReleaseClientJobs(clientId, this.contextFactory.getLockContext());
+    }
+}

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

@@ -0,0 +1,16 @@
+import type { JobId } from '../../domain/types/job';
+import type { JobLogEntry } from '../../domain/types/worker';
+import { type OperationalMetrics } from '../metricsExporter';
+import * as statsMgr from '../statsManager';
+import type { QueueMetricType } from '../../domain/types/metrics';
+import { QueueManagerStats } from './stats';
+export declare class QueueManagerObservability extends QueueManagerStats {
+    getQueueMetrics(queue: string, type: QueueMetricType, start?: number, end?: number): import("../../client").QueueMetrics;
+    trimQueueEvents(queue: string, maxLength: number): number;
+    addLog(jobId: JobId, message: string, level?: 'info' | 'warn' | 'error'): boolean;
+    getLogs(jobId: JobId): JobLogEntry[];
+    clearLogs(jobId: JobId, keepLogs?: number): void;
+    getPerQueueStats(): Map<string, statsMgr.PerQueueStats>;
+    getPrometheusMetrics(): string;
+    setOperationalMetricsProvider(provider: () => OperationalMetrics): void;
+}

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

@@ -0,0 +1,44 @@
+import * as logsOps from '../jobLogsManager';
+import { generatePrometheusMetrics } from '../metricsExporter';
+import { selectPrometheusQueues } from '../prometheusOperationalMetrics';
+import * as statsMgr from '../statsManager';
+import { QueueManagerStats } from './stats';
+export class QueueManagerObservability extends QueueManagerStats {
+    getQueueMetrics(queue, type, start = 0, end = -1) {
+        return this.telemetryJournal.getMetrics(queue, type, start, end);
+    }
+    trimQueueEvents(queue, maxLength) {
+        return this.telemetryJournal.trimEvents(queue, maxLength);
+    }
+    addLog(jobId, message, level = 'info') {
+        return logsOps.addJobLog(jobId, message, this.contextFactory.getLogsContext(), level);
+    }
+    getLogs(jobId) {
+        return logsOps.getJobLogs(jobId, this.contextFactory.getLogsContext());
+    }
+    clearLogs(jobId, keepLogs) {
+        logsOps.clearJobLogs(jobId, this.contextFactory.getLogsContext(), keepLogs);
+    }
+    getPerQueueStats() {
+        return statsMgr.getPerQueueStats(this.contextFactory.getStatsContext(), this.queueNamesCache);
+    }
+    getPrometheusMetrics() {
+        const storageStatus = this.getStorageStatus();
+        const memory = process.memoryUsage();
+        const queueSelection = selectPrometheusQueues(this.queueNamesCache, this.config.maxPrometheusQueues);
+        return generatePrometheusMetrics(this.getStats(), this.workerManager, this.webhookManager, statsMgr.getPerQueueStats(this.contextFactory.getStatsContext(), queueSelection.selected), {
+            storageDegraded: storageStatus.diskFull,
+            storageDiskFull: storageStatus.diskFull,
+            ...(this.storage && { sqliteDatabaseSizeBytes: this.storage.getSize() }),
+            processHeapUsedBytes: memory.heapUsed,
+            processHeapTotalBytes: memory.heapTotal,
+            processResidentMemoryBytes: memory.rss,
+            perQueueMetricsExported: queueSelection.selected.size,
+            perQueueMetricsOmitted: queueSelection.omitted,
+            operational: this.operationalMetricsProvider?.(),
+        });
+    }
+    setOperationalMetricsProvider(provider) {
+        this.operationalMetricsProvider = provider;
+    }
+}

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

@@ -0,0 +1,17 @@
+import type { Job, JobId } from '../../domain/types/job';
+import { QueueManagerLocks } from './locks';
+export declare class QueueManagerQueries extends QueueManagerLocks {
+    getJob(jobId: JobId): Promise<Job | null>;
+    getJobState(jobId: JobId): Promise<string>;
+    getResult(jobId: JobId): unknown;
+    getChildrenValues(parentJobId: JobId): Promise<Record<string, unknown>>;
+    updateJobParent(childJobId: JobId, parentJobId: JobId): Promise<void>;
+    getJobByCustomId(customId: string): Job | null;
+    getProgress(jobId: JobId): {
+        progress: number;
+        message: string | null;
+    } | null;
+    count(queue: string): number;
+    protected moveParentToFailed(_parentId: JobId, _childJob: Job, _error: string | undefined): Promise<void>;
+    protected onChildDependencyOption(_childJob: Job, _error: string | undefined): Promise<void>;
+}

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

@@ -0,0 +1,118 @@
+import { processingShardIndex, shardIndex } from '../../shared/hash';
+import * as queueControl from '../operations/queueControl';
+import * as queryOps from '../operations/queryOperations';
+import { assertFlowParentOwnership, backpatchDeclaredFlowChild, canAcceptRemovedFlowChild, flowChildFailureError, isDeclaredFlowChild, } from '../flowParentBackpatch';
+import { commitParentLink, parentLinkState, prepareParentLink } from '../operations/parentLink';
+import { QueueManagerLocks } from './locks';
+export class QueueManagerQueries extends QueueManagerLocks {
+    async getJob(jobId) {
+        return queryOps.getJob(jobId, this.contextFactory.getQueryContext());
+    }
+    async getJobState(jobId) {
+        return queryOps.getJobState(jobId, this.contextFactory.getQueryContext());
+    }
+    getResult(jobId) {
+        return queryOps.getJobResult(jobId, this.contextFactory.getQueryContext());
+    }
+    async getChildrenValues(parentJobId) {
+        const job = await this.getJob(parentJobId);
+        if (!job?.childrenIds || job.childrenIds.length === 0)
+            return {};
+        const ctx = this.contextFactory.getQueryContext();
+        const results = {};
+        for (const childId of job.childrenIds) {
+            const result = queryOps.getJobResult(childId, ctx);
+            if (result !== undefined) {
+                const childJob = await this.getJob(childId);
+                results[childJob ? `${childJob.queue}:${childId}` : childId] = result;
+            }
+        }
+        return results;
+    }
+    async updateJobParent(childJobId, parentJobId) {
+        if (childJobId === parentJobId)
+            throw new Error('A flow job cannot be its own parent');
+        let childJob = await this.getJob(childJobId);
+        const parentJob = await this.getJob(parentJobId);
+        if (!childJob) {
+            if (canAcceptRemovedFlowChild(parentJob, childJobId, this.depCompletions))
+                return;
+            throw new Error(`Child job not found: ${String(childJobId)}`);
+        }
+        if (!parentJob)
+            throw new Error(`Parent job not found: ${String(parentJobId)}`);
+        assertFlowParentOwnership(childJob, parentJobId);
+        if (isDeclaredFlowChild(parentJob, childJobId)) {
+            childJob = await backpatchDeclaredFlowChild(childJob, parentJob, {
+                storage: this.storage,
+                customIdLock: this.customIdLock,
+                shards: this.shards,
+                shardLocks: this.shardLocks,
+                processingShards: this.processingShards,
+                processingLocks: this.processingLocks,
+                jobIndex: this.jobIndex,
+                completedJobsData: this.completedJobsData,
+                depCompletions: this.depCompletions,
+            });
+        }
+        else {
+            const parentLocation = this.jobIndex.get(parentJobId);
+            if (parentLocation?.type !== 'queue') {
+                throw new Error(`Parent job ${String(parentJobId)} is not linkable`);
+            }
+            const childLocation = this.jobIndex.get(childJobId);
+            const shardIndexes = [
+                ...new Set([shardIndex(childJob.queue), shardIndex(parentJob.queue)]),
+            ].sort((a, b) => a - b);
+            const processingIndexes = childLocation?.type === 'processing' ? [processingShardIndex(childJobId)] : [];
+            const guards = [await this.customIdLock.acquireWrite()];
+            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(parentJobId)?.type !== 'queue') {
+                    throw new Error(`Parent job ${String(parentJobId)} changed state while linking`);
+                }
+                const childFinished = this.completedJobs.has(childJobId) || this.depCompletions.has(childJobId);
+                const pushContext = this.contextFactory.getPushContext();
+                const plan = prepareParentLink(childJob, pushContext, childFinished, parentJobId);
+                this.storage?.updateFlowLink(plan.linkedChild, plan.linkedParent, parentLinkState(plan));
+                commitParentLink(plan, pushContext);
+            }
+            finally {
+                for (let index = guards.length - 1; index >= 0; index--)
+                    guards[index].release();
+            }
+        }
+        const childLocation = this.jobIndex.get(childJobId);
+        const childFailureError = childLocation?.type === 'dlq'
+            ? (flowChildFailureError(childJob, this.shards) ?? 'Child job failed')
+            : 'Child job failed';
+        if (childLocation?.type === 'dlq' && childJob.failParentOnFailure) {
+            await this.moveParentToFailed(parentJobId, childJob, childFailureError);
+        }
+        if (childLocation?.type === 'dlq' &&
+            (childJob.removeDependencyOnFailure ||
+                childJob.ignoreDependencyOnFailure ||
+                childJob.continueParentOnFailure)) {
+            await this.onChildDependencyOption(childJob, childFailureError);
+        }
+    }
+    getJobByCustomId(customId) {
+        return queryOps.getJobByCustomId(customId, this.contextFactory.getQueryContext());
+    }
+    getProgress(jobId) {
+        return queryOps.getJobProgress(jobId, this.contextFactory.getQueryContext());
+    }
+    count(queue) {
+        return queueControl.getQueueCount(queue, this.contextFactory.getQueueControlContext());
+    }
+    async moveParentToFailed(_parentId, _childJob, _error) {
+        throw new Error('QueueManager flow module is not initialized');
+    }
+    async onChildDependencyOption(_childJob, _error) {
+        throw new Error('QueueManager flow options module is not initialized');
+    }
+}

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

@@ -0,0 +1,4 @@
+import type { Job } from '../../domain/types/job';
+import type { QueueManagerRuntime } from '../types';
+/** Schedule one successor after a successful repeat generation. */
+export declare function handleRepeat(runtime: QueueManagerRuntime, job: Job): void;

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

@@ -0,0 +1,26 @@
+import { queueLog } from '../../shared/logger';
+import { buildRepeatSuccessor } from '../repeatJobs';
+/** Schedule one successor after a successful repeat generation. */
+export function handleRepeat(runtime, job) {
+    const input = buildRepeatSuccessor(job);
+    if (!input)
+        return;
+    const oldId = job.id;
+    void runtime
+        .push(job.queue, input)
+        .then((newJob) => {
+        runtime.repeatChain.set(oldId, newJob.id);
+        if (runtime.repeatChain.size > 10_000) {
+            const first = runtime.repeatChain.keys().next().value;
+            if (first !== undefined)
+                runtime.repeatChain.delete(first);
+        }
+    })
+        .catch((error) => {
+        queueLog.error('Failed to create repeat successor', {
+            jobId: String(oldId),
+            queue: job.queue,
+            error: String(error),
+        });
+    });
+}

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

@@ -0,0 +1,19 @@
+import type { CronJob, CronJobInput } from '../../domain/types/cron';
+import type { JobId } from '../../domain/types/job';
+import type { JobEvent } from '../../domain/types/queue';
+import type { CreateWorkerOptions } from '../../domain/types/worker';
+import { QueueManagerObservability } from './observability';
+export declare class QueueManagerServices extends QueueManagerObservability {
+    addCron(input: CronJobInput): CronJob;
+    protected removeOrphanedCronJob(queue: string, uniqueKey: string): void;
+    removeCron(name: string): boolean;
+    getCron(name: string): CronJob | undefined;
+    listCrons(): CronJob[];
+    setDashboardEmit(fn: (event: string, data: Record<string, unknown>) => void): void;
+    emitDashboardEvent(event: string, data: Record<string, unknown>): void;
+    subscribe(callback: (event: JobEvent) => void): () => void;
+    waitForJobCompletion(jobId: JobId, timeoutMs: number): Promise<boolean>;
+    registerWorker(name: string, queues: string[], concurrency?: number, options?: CreateWorkerOptions): import("../../domain/types/worker").Worker;
+    unregisterWorker(workerId: string): boolean;
+    unregisterWorkersByClientId(clientId: string): number;
+}