@tstdl/base 0.93.86 → 0.93.89

package/queue/postgres/queue.js

@@ -1,681 +0,0 @@
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-import { and, asc, eq, gt, inArray, lt, lte, or, sql, isNull as sqlIsNull } from 'drizzle-orm';
-import { merge } from 'rxjs';
-import { CancellationSignal } from '../../cancellation/index.js';
-import { CircuitBreaker, CircuitBreakerState } from '../../circuit-breaker/index.js';
-import { Enumerable } from '../../enumerable/enumerable.js';
-import { inject, injectArgument, provide, Singleton } from '../../injector/index.js';
-import { MessageBus } from '../../message-bus/index.js';
-import { coalesce, interval, RANDOM_UUID_V4, TRANSACTION_TIMESTAMP } from '../../orm/index.js';
-import { DatabaseConfig, injectRepository } from '../../orm/server/index.js';
-import { toArray } from '../../utils/array/array.js';
-import { currentTimestamp } from '../../utils/date-time.js';
-import { serializeError } from '../../utils/format-error.js';
-import { cancelableTimeout } from '../../utils/timing.js';
-import { isDefined, isNotNull, isNull, isString, isUndefined } from '../../utils/type-guards.js';
-import { millisecondsPerSecond } from '../../utils/units.js';
-import { defaultQueueConfig, Queue, TaskState, UniqueTagStrategy } from '../queue.js';
-import { PostgresQueueModuleConfig } from './module.js';
-import { task as taskTable } from './schemas.js';
-import { PostgresTask } from './task.model.js';
-let PostgresQueue = class PostgresQueue extends Queue {
-    #repository = injectRepository(PostgresTask);
-    #config = injectArgument(this);
-    #queueName = isString(this.#config) ? this.#config : this.#config.name;
-    #messageBus = inject((MessageBus), `PostgresQueue:${this.#queueName}`);
-    #circuitBreaker = inject(CircuitBreaker, {
-        key: this.#queueName,
-        threshold: (isString(this.#config) ? undefined : this.#config.circuitBreakerThreshold) ?? defaultQueueConfig.circuitBreakerThreshold,
-        resetTimeout: (isString(this.#config) ? undefined : this.#config.circuitBreakerResetTimeout) ?? defaultQueueConfig.circuitBreakerResetTimeout,
-    });
-    processTimeout = (isString(this.#config) ? undefined : this.#config.processTimeout) ?? defaultQueueConfig.processTimeout;
-    executionTimeout = (isString(this.#config) ? undefined : this.#config.executionTimeout) ?? defaultQueueConfig.executionTimeout;
-    maxTries = (isString(this.#config) ? undefined : this.#config.maxTries) ?? defaultQueueConfig.maxTries;
-    retryDelayMinimum = (isString(this.#config) ? undefined : this.#config.retryDelayMinimum) ?? defaultQueueConfig.retryDelayMinimum;
-    retryDelayMaximum = (isString(this.#config) ? undefined : this.#config.retryDelayMaximum) ?? defaultQueueConfig.retryDelayMaximum;
-    retryDelayGrowth = (isString(this.#config) ? undefined : this.#config.retryDelayGrowth) ?? defaultQueueConfig.retryDelayGrowth;
-    retentionPeriod = (isString(this.#config) ? undefined : this.#config.retentionPeriod) ?? defaultQueueConfig.retentionPeriod;
-    globalConcurrency = (isString(this.#config) ? undefined : this.#config.globalConcurrency) ?? defaultQueueConfig.globalConcurrency;
-    // -- Updates --
-    #keepOldUpdate = { id: sql `${taskTable.id}` };
-    #takeNewUpdate = {
-        id: RANDOM_UUID_V4,
-        queue: this.#queueName,
-        priority: sql `excluded.priority`,
-        tag: sql `excluded.tag`,
-        status: TaskState.Pending,
-        lease: null,
-        tries: 0,
-        progress: 0,
-        enqueueTimestamp: TRANSACTION_TIMESTAMP,
-        scheduleTimestamp: sql `excluded.schedule_timestamp`,
-        startTimestamp: null,
-        expirationTimestamp: sql `excluded.expiration_timestamp`,
-        lockExpirationTimestamp: null,
-        data: sql `excluded.data`,
-        state: null,
-        error: null,
-        result: null,
-    };
-    async enqueue(data, options) {
-        const tasks = await this.enqueueMany([{ data, ...options }], { uniqueTag: options?.uniqueTag, returnTasks: true, transaction: options?.transaction });
-        return tasks[0];
-    }
-    async enqueueMany(items, options) {
-        if (items.length == 0) {
-            return (options?.returnTasks == true) ? [] : undefined;
-        }
-        const newEntities = items.map((item) => ({
-            queue: this.#queueName,
-            status: TaskState.Pending,
-            lease: null,
-            priority: item.priority ?? 1000,
-            tag: item.tag ?? null,
-            parentId: item.parentId ?? null,
-            tries: 0,
-            progress: 0,
-            enqueueTimestamp: TRANSACTION_TIMESTAMP,
-            scheduleTimestamp: item.scheduleTimestamp ?? TRANSACTION_TIMESTAMP,
-            startTimestamp: null,
-            expirationTimestamp: item.expirationTimestamp ?? null,
-            lockExpirationTimestamp: null,
-            completeTimestamp: null,
-            data: item.data,
-            state: null,
-            result: null,
-            error: null,
-        }));
-        const update = (options?.uniqueTag == UniqueTagStrategy.TakeNew)
-            ? this.#takeNewUpdate
-            : (options?.uniqueTag == UniqueTagStrategy.KeepOld)
-                ? this.#keepOldUpdate
-                : undefined;
-        const repository = this.#repository.withOptionalTransaction(options?.transaction);
-        const tasks = isUndefined(update)
-            ? await repository.insertMany(newEntities)
-            : await repository.upsertMany(['queue', 'tag'], newEntities, update);
-        this.#messageBus.publishAndForget();
-        if (options?.returnTasks == true) {
-            return tasks;
-        }
-        return undefined;
-    }
-    async has(id) {
-        return await this.#repository.hasByQuery({ queue: this.#queueName, id });
-    }
-    async countByTag(tag) {
-        return await this.#repository.countByQuery({ queue: this.#queueName, tag });
-    }
-    async get(id) {
-        return await this.#repository.tryLoadByQuery({ queue: this.#queueName, id });
-    }
-    async getByTag(tag) {
-        return await this.#repository.loadManyByQuery({ queue: this.#queueName, tag });
-    }
-    async getByTags(tags) {
-        return await this.#repository.loadManyByQuery({ queue: this.#queueName, tag: { $in: tags } });
-    }
-    async getTree(idOrIds, transaction) {
-        const ids = toArray(idOrIds);
-        return await this.getTreeByQuery({ id: { $in: ids } }, transaction);
-    }
-    async getTreeByQuery(query, transaction) {
-        return await this.#repository.useTransaction(transaction, async (tx) => {
-            const repositoryWithTransaction = this.#repository.withTransaction(tx);
-            const tasks = await repositoryWithTransaction.loadManyByQuery(query);
-            if (tasks.length == 0) {
-                return [];
-            }
-            let currentLevelIds = tasks.map((task) => task.id);
-            let depth = 0;
-            while (true) {
-                if (depth++ > 100) {
-                    throw new Error('Possible cyclic task parent-child relationship detected in queue "' + this.#queueName + '"');
-                }
-                const childTasks = await repositoryWithTransaction.loadManyByQuery({ parentId: { $in: currentLevelIds } });
-                if (childTasks.length == 0) {
-                    break;
-                }
-                currentLevelIds = childTasks.map((task) => task.id);
-                tasks.push(...childTasks);
-            }
-            return tasks;
-        });
-    }
-    async cancel(id, transaction) {
-        await this.cancelMany([id], transaction);
-    }
-    async cancelMany(ids, transaction) {
-        await this.#repository.useTransaction(transaction, async (tx) => {
-            const tree = await this.getTree(ids, tx);
-            const treeIds = tree.map((task) => task.id);
-            if (treeIds.length == 0) {
-                return;
-            }
-            await this.#repository.withTransaction(tx).updateMany(treeIds, {
-                status: TaskState.Cancelled,
-                lease: null,
-                completeTimestamp: TRANSACTION_TIMESTAMP,
-            });
-            const uniqueParents = new Set();
-            for (const t of tree) {
-                const task = t;
-                if (isNotNull(task.parentId)) {
-                    uniqueParents.add(task.parentId);
-                }
-            }
-            for (const parentId of uniqueParents) {
-                await this.#triggerParentFanIn(parentId, tx);
-            }
-        });
-    }
-    async cancelByTag(tag) {
-        await this.cancelManyByTag([tag]);
-    }
-    async cancelManyByTag(tags) {
-        await this.#repository.transaction(async (tx) => {
-            const task = await this.getByTags(tags);
-            const ids = task.map((t) => t.id);
-            await this.cancelMany(ids, tx);
-        });
-    }
-    async clear() {
-        await this.#repository.hardDeleteManyByQuery({ queue: this.#queueName });
-    }
-    async dequeue() {
-        const tasks = await this.dequeueMany(1);
-        if (tasks.length == 0) {
-            return undefined;
-        }
-        return tasks[0];
-    }
-    async dequeueMany(count) {
-        return await this.#repository.transaction(async (tx) => {
-            let effectiveCount = count;
-            // 1. Check Circuit Breaker
-            const result = await this.#circuitBreaker.check();
-            if (!result.allowed) {
-                return [];
-            }
-            if (result.state == CircuitBreakerState.HalfOpen) {
-                // If we are probing (HalfOpen), we must ensure no other tasks are running locally.
-                // NOTE: PostgresCircuitBreakerService.check() handles the "one probe per timeout" via the DB state transition.
-                // However, we still might want to limit this batch to 1 task if we are the probe.
-                if (result.isProbe != true) {
-                    const runningCount = await this.#repository.withTransaction(tx).countByQuery({ queue: this.#queueName, status: TaskState.Running });
-                    if (runningCount > 0) {
-                        return [];
-                    }
-                }
-                effectiveCount = 1;
-            }
-            // 2. Check Global Concurrency
-            if (isNotNull(this.globalConcurrency)) {
-                const runningCount = await this.#repository.withTransaction(tx).countByQuery({ queue: this.#queueName, status: TaskState.Running });
-                if (runningCount >= this.globalConcurrency) {
-                    return [];
-                }
-            }
-            /*
-             * Materialization required for LIMIT clause
-             * https://stackoverflow.com/questions/73966670/select-for-update-subquery-not-respecting-limit-clause-under-load
-             * https://dba.stackexchange.com/questions/69471/postgres-update-limit-1
-             */
-            const selection = this.#repository.session.$with('selection').as((qb) => qb
-                .select({ id: taskTable.id })
-                .from(taskTable)
-                .where(and(eq(taskTable.queue, this.#queueName), lte(taskTable.scheduleTimestamp, TRANSACTION_TIMESTAMP), or(sqlIsNull(taskTable.expirationTimestamp), lt(TRANSACTION_TIMESTAMP, taskTable.expirationTimestamp)), or(eq(taskTable.status, TaskState.Pending), and(eq(taskTable.status, TaskState.Running), lt(taskTable.lockExpirationTimestamp, TRANSACTION_TIMESTAMP), // Zombie detection (only non-exhausted ones)
-            lt(taskTable.tries, this.maxTries))), sql `pg_sleep(0) IS NOT NULL` // Materialization hack until drizzle implements https://github.com/drizzle-team/drizzle-orm/issues/2318
-            ))
-                .orderBy(asc(taskTable.priority), asc(taskTable.scheduleTimestamp), asc(taskTable.tries))
-                .limit(effectiveCount)
-                .for('update', { skipLocked: true }));
-            const rows = await this.#repository.session
-                .with(selection)
-                .update(taskTable)
-                .set({
-                status: TaskState.Running,
-                lease: RANDOM_UUID_V4,
-                lockExpirationTimestamp: sql `${TRANSACTION_TIMESTAMP} + ${interval(this.processTimeout, 'milliseconds')}`,
-                startTimestamp: TRANSACTION_TIMESTAMP,
-                // If it was PENDING, it's the first try (tries=0) -> tries=1.
-                // If it was RUNNING (Zombie), previous try failed -> increment tries.
-                tries: sql `${taskTable.tries} + 1`,
-            })
-                .where(inArray(taskTable.id, this.#repository.session.select().from(selection)))
-                .returning();
-            return await this.#repository.mapManyToEntity(rows);
-        });
-    }
-    async reschedule(id, timestamp, transaction) {
-        await this.rescheduleMany([id], timestamp, transaction);
-    }
-    async rescheduleMany(ids, timestamp, transaction) {
-        await this.#repository.withOptionalTransaction(transaction).updateMany(ids, {
-            status: TaskState.Pending,
-            lease: null,
-            scheduleTimestamp: timestamp,
-            lockExpirationTimestamp: null,
-            tries: sql `CASE
-        WHEN ${taskTable.status} = ${TaskState.Running} THEN GREATEST(0, ${taskTable.tries} - 1)
-        ELSE ${taskTable.tries}
-      END`,
-        });
-    }
-    async rescheduleByTag(tag, timestamp, transaction) {
-        await this.rescheduleManyByTag([tag], timestamp, transaction);
-    }
-    async rescheduleManyByTag(tags, timestamp, transaction) {
-        await this.#repository.withOptionalTransaction(transaction).updateManyByQuery({
-            queue: this.#queueName,
-            tag: { $in: tags },
-        }, {
-            status: TaskState.Pending,
-            lease: null,
-            scheduleTimestamp: timestamp,
-            lockExpirationTimestamp: null,
-            tries: sql `CASE
-        WHEN ${taskTable.status} = ${TaskState.Running} THEN GREATEST(0, ${taskTable.tries} - 1)
-        ELSE ${taskTable.tries}
-      END`,
-        });
-    }
-    async touch(task, options) {
-        if (isNull(task.lease)) {
-            return undefined;
-        }
-        return await this.#repository.useTransaction(options?.transaction, async (tx) => {
-            const update = {
-                lockExpirationTimestamp: sql `${TRANSACTION_TIMESTAMP} + ${interval(this.processTimeout, 'milliseconds')}`,
-            };
-            if (isDefined(options?.progress)) {
-                update.progress = options.progress;
-            }
-            if (isDefined(options?.state)) {
-                update.state = options.state;
-            }
-            // Attempt to update lease.
-            // FAILS (returns undefined) if lease has changed (timeout/cancel/stolen)
-            // OR if hard execution timeout has passed.
-            const result = await this.#repository.withTransaction(tx).tryUpdateByQuery({
-                queue: this.#queueName,
-                id: task.id,
-                status: TaskState.Running,
-                lease: task.lease,
-                startTimestamp: { $gt: sql `${TRANSACTION_TIMESTAMP} - ${interval(this.executionTimeout, 'milliseconds')}` },
-            }, update);
-            return result;
-        });
-    }
-    async touchMany(tasks, progresses, states, transaction) {
-        if (tasks.length == 0) {
-            return [];
-        }
-        const rows = tasks.map((t, i) => {
-            const progress = progresses?.[i] ?? null;
-            const state = states?.[i] ?? null;
-            return sql `(${t.id}::uuid, ${t.lease}::uuid, ${progress}::numeric, ${state}::jsonb)`;
-        });
-        const updates = this.#repository.session.$with('updates').as((qb) => qb
-            .select({
-            updateId: sql `(id)::uuid`.as('update_id'),
-            updateLease: sql `(lease)::uuid`.as('update_lease'),
-            updateProgress: sql `(progress)::numeric`.as('update_progress'),
-            updateState: sql `(state)::jsonb`.as('update_state'),
-        })
-            .from(sql `(VALUES ${sql.join(rows, sql `, `)}) AS t(id, lease, progress, state)`));
-        const updated = this.#repository.session.$with('updated').as(() => this.#repository.session
-            .update(taskTable)
-            .set({
-            lockExpirationTimestamp: sql `${TRANSACTION_TIMESTAMP} + ${interval(this.processTimeout, 'milliseconds')}`,
-            progress: coalesce(updates.updateProgress, taskTable.progress),
-            state: coalesce(updates.updateState, taskTable['state']),
-        })
-            .from(updates)
-            .where(and(eq(taskTable.id, updates.updateId), eq(taskTable.queue, this.#queueName), eq(taskTable.lease, updates.updateLease), eq(taskTable.status, TaskState.Running), gt(taskTable.startTimestamp, sql `${TRANSACTION_TIMESTAMP} - ${interval(this.executionTimeout, 'milliseconds')}`)))
-            .returning({ id: taskTable.id }));
-        const result = await this.#repository.withOptionalTransaction(transaction).session
-            .with(updates, updated)
-            .select({ id: updated.id })
-            .from(updated)
-            .execute();
-        return result.map((r) => r.id);
-    }
-    async acknowledge(task, result, transaction, { skipFanIn = false } = {}) {
-        await this.#repository.useTransaction(transaction, async (tx) => {
-            const repository = this.#repository.withTransaction(tx);
-            // 1. Fan-Out Check: Does this task have active children?
-            // If yes, this is a Parent task that has spawned children.
-            // It should enter 'Waiting' instead of 'Completed'.
-            const activeChildrenCount = await repository.countByQuery({
-                parentId: task.id,
-                status: { $nin: [TaskState.Completed, TaskState.Cancelled, TaskState.Dead] },
-            });
-            let updatedTask;
-            if (activeChildrenCount > 0) {
-                updatedTask = await repository.tryUpdateByQuery({
-                    id: task.id,
-                    lease: task.lease,
-                }, {
-                    status: TaskState.Waiting,
-                    lease: null,
-                    lockExpirationTimestamp: null,
-                    state: result,
-                });
-            }
-            else {
-                updatedTask = await repository.tryUpdateByQuery({
-                    id: task.id,
-                    lease: task.lease,
-                }, {
-                    status: TaskState.Completed,
-                    lease: null,
-                    result: result,
-                    progress: 1,
-                    completeTimestamp: TRANSACTION_TIMESTAMP,
-                    lockExpirationTimestamp: null,
-                });
-            }
-            if (isUndefined(updatedTask)) {
-                return;
-            }
-            // 2. Reset Circuit Breaker (Success detected)
-            await this.#circuitBreaker.recordSuccess();
-            // 3. Fan-In: Wake up parent if all siblings are done
-            if (!skipFanIn && isNotNull(task.parentId)) {
-                await this.#triggerParentFanIn(task.parentId, tx);
-            }
-        });
-    }
-    async acknowledgeMany(tasks, results, transaction) {
-        if (tasks.length == 0) {
-            return;
-        }
-        await this.#repository.useTransaction(transaction, async (tx) => {
-            // 1. Bulk Check for Active Children
-            const taskIds = tasks.map((task) => task.id);
-            const parentsWithChildrenRows = await this.#repository.withTransaction(tx).session
-                .selectDistinct({ id: taskTable.parentId }) // Distinct is cleaner
-                .from(taskTable)
-                .where(and(inArray(taskTable.parentId, taskIds), inArray(taskTable.status, [TaskState.Pending, TaskState.Running, TaskState.Waiting])))
-                .execute();
-            const allParentIds = parentsWithChildrenRows.map((row) => row.id);
-            const distinctParentIds = new Set(allParentIds);
-            // 2. Separate tasks
-            const tasksToWait = [];
-            const tasksToComplete = [];
-            const resultsToComplete = [];
-            const resultsToWait = [];
-            for (let i = 0; i < tasks.length; i++) {
-                const task = tasks[i];
-                if (distinctParentIds.has(task.id)) {
-                    tasksToWait.push(task);
-                    if (isDefined(results)) {
-                        resultsToWait.push(results[i]);
-                    }
-                }
-                else {
-                    tasksToComplete.push(task);
-                    if (isDefined(results)) {
-                        resultsToComplete.push(results[i]);
-                    }
-                }
-            }
-            // 3. Update 'Waiting' tasks
-            if (tasksToWait.length > 0) {
-                const rows = tasksToWait.map((task, i) => {
-                    const result = isDefined(results) ? resultsToWait[i] : null;
-                    return sql `(${task.id}::uuid, ${task.lease}::uuid, ${result}::jsonb)`;
-                });
-                const updates = this.#repository.session.$with('updates').as((qb) => qb
-                    .select({
-                    updateId: sql `(id)::uuid`.as('update_id'),
-                    updateLease: sql `(lease)::uuid`.as('update_lease'),
-                    updateResult: sql `(result)::jsonb`.as('update_result'),
-                })
-                    .from(sql `(VALUES ${sql.join(rows, sql `, `)}) AS t(id, lease, result)`));
-                const updated = this.#repository.session.$with('updated').as(() => this.#repository.session
-                    .update(taskTable)
-                    .set({
-                    status: TaskState.Waiting,
-                    lease: null,
-                    lockExpirationTimestamp: null,
-                    result: updates.updateResult,
-                })
-                    .from(updates)
-                    .where(and(eq(taskTable.id, updates.updateId), eq(taskTable.lease, updates.updateLease), eq(taskTable.queue, this.#queueName)))
-                    .returning({ id: taskTable.id }));
-                await this.#repository.withTransaction(tx).session
-                    .with(updates, updated)
-                    .select({ id: updated.id })
-                    .from(updated)
-                    .execute();
-            }
-            // 4. Update 'Completed' tasks
-            if (tasksToComplete.length > 0) {
-                const rows = tasksToComplete.map((t, i) => {
-                    const result = isDefined(results) ? resultsToComplete[i] : null;
-                    return sql `(${t.id}::uuid, ${t.lease}::uuid, ${result}::jsonb)`;
-                });
-                const updates = this.#repository.session.$with('updates').as((qb) => qb
-                    .select({
-                    updateId: sql `(id)::uuid`.as('update_id'),
-                    updateLease: sql `(lease)::uuid`.as('update_lease'),
-                    updateResult: sql `(result)::jsonb`.as('update_result'),
-                })
-                    .from(sql `(VALUES ${sql.join(rows, sql `, `)}) AS t(id, lease, result)`));
-                const updated = this.#repository.session.$with('updated').as(() => this.#repository.session
-                    .update(taskTable)
-                    .set({
-                    status: TaskState.Completed,
-                    lease: null,
-                    result: updates.updateResult,
-                    progress: 1,
-                    completeTimestamp: TRANSACTION_TIMESTAMP,
-                    lockExpirationTimestamp: null,
-                })
-                    .from(updates)
-                    .where(and(eq(taskTable.id, updates.updateId), eq(taskTable.lease, updates.updateLease), eq(taskTable.queue, this.#queueName)))
-                    .returning({ id: taskTable.id }));
-                await this.#repository.withTransaction(tx).session
-                    .with(updates, updated)
-                    .select({ id: updated.id })
-                    .from(updated)
-                    .execute();
-                // Reset circuit breaker
-                await this.#circuitBreaker.recordSuccess();
-            }
-            // 5. Fan-In
-            const parentIds = Enumerable.from(tasks)
-                .filter((task) => isNotNull(task.parentId))
-                .map((task) => task.parentId)
-                .distinct();
-            for (const parentId of parentIds) {
-                await this.#triggerParentFanIn(parentId, tx);
-            }
-        });
-    }
-    async fail(task, error, fatal = false, transaction, { skipFanIn = false } = {}) {
-        const isRetryable = !fatal && (task.tries < this.maxTries);
-        const nextStatus = isRetryable ? TaskState.Pending : TaskState.Dead;
-        const delay = isRetryable
-            ? Math.min(this.retryDelayMaximum, this.retryDelayMinimum * (this.retryDelayGrowth ** task.tries))
-            : 0;
-        const nextSchedule = currentTimestamp() + delay;
-        await this.#repository.useTransaction(transaction, async (tx) => {
-            const updatedTask = await this.#repository.withTransaction(tx).tryUpdateByQuery({
-                queue: this.#queueName,
-                id: task.id,
-                lease: task.lease,
-                tries: task.tries,
-            }, {
-                status: nextStatus,
-                lease: null,
-                error: serializeError(error),
-                lockExpirationTimestamp: null,
-                scheduleTimestamp: nextSchedule,
-                startTimestamp: null,
-                completeTimestamp: (nextStatus == TaskState.Dead) ? TRANSACTION_TIMESTAMP : null,
-            });
-            if (isUndefined(updatedTask)) {
-                return;
-            }
-            await this.#circuitBreaker.recordFailure();
-            if (!skipFanIn && (nextStatus == TaskState.Dead) && isNotNull(task.parentId)) {
-                await this.#triggerParentFanIn(task.parentId, tx);
-            }
-        });
-    }
-    async #triggerParentFanIn(parentId, transaction) {
-        await this.#repository.useTransaction(transaction, async (tx) => {
-            // 1. Lock Parent
-            const [parent] = await this.#repository.withTransaction(tx).session
-                .select({ id: taskTable.id, status: taskTable.status })
-                .from(taskTable)
-                .where(eq(taskTable.id, parentId))
-                .for('update')
-                .execute();
-            if (parent?.status != TaskState.Waiting) {
-                return;
-            }
-            // 2. Check Children
-            const hasActiveChildren = await this.#repository.withTransaction(tx).hasByQuery({
-                parentId,
-                status: { $in: [TaskState.Pending, TaskState.Running, TaskState.Waiting] },
-            });
-            if (!hasActiveChildren) {
-                // 3. Update Parent
-                await this.#repository.withTransaction(tx).updateByQuery({ id: parentId }, {
-                    status: TaskState.Pending,
-                    scheduleTimestamp: TRANSACTION_TIMESTAMP,
-                });
-            }
-        });
-    }
-    async failMany(tasks, errors, transaction) {
-        if (tasks.length == 0) {
-            return;
-        }
-        await this.#repository.useTransaction(transaction, async (tx) => {
-            await Promise.all(tasks.map(async (task, index) => await this.fail(task, errors[index], false, tx, { skipFanIn: true })));
-            const parentIds = Enumerable.from(tasks)
-                .filter((task) => isNotNull(task.parentId))
-                .map((task) => task.parentId)
-                .distinct();
-            for (const parentId of parentIds) {
-                await this.#triggerParentFanIn(parentId, tx);
-            }
-        });
-    }
-    async prune() {
-        // 1. Clean up old finished tasks
-        await this.#repository.deleteManyByQuery({
-            queue: this.#queueName,
-            status: { $in: [TaskState.Completed, TaskState.Cancelled, TaskState.Dead] },
-            completeTimestamp: { $lt: sql `${TRANSACTION_TIMESTAMP} - ${interval(this.retentionPeriod, 'milliseconds')}` },
-        });
-        await this.#repository.transaction(async (tx) => {
-            // 2. Fail tasks that sat in Pending state past their expiration
-            const expiredTasks = await this.#repository.updateManyByQuery({
-                queue: this.#queueName,
-                status: TaskState.Pending,
-                expirationTimestamp: { $lt: TRANSACTION_TIMESTAMP },
-            }, {
-                status: TaskState.Dead,
-                lease: null,
-                error: { message: 'Queue Timeout: Task expired before processing' },
-                completeTimestamp: TRANSACTION_TIMESTAMP,
-            });
-            // 3. Fail "Rotting Zombies" (Tasks that crashed workers and exceeded max retries)
-            // These were excluded from dequeueMany to prevent infinite loops, so we capture them here.
-            const zombieTasks = await this.#repository.updateManyByQuery({
-                queue: this.#queueName,
-                status: TaskState.Running,
-                lockExpirationTimestamp: { $lt: TRANSACTION_TIMESTAMP },
-                tries: { $gte: this.maxTries },
-            }, {
-                status: TaskState.Dead,
-                lease: null,
-                error: { message: 'Zombie Task: Exceeded max retries after repeated crashes' },
-                completeTimestamp: TRANSACTION_TIMESTAMP,
-                lockExpirationTimestamp: null,
-            });
-            // 4. Fail tasks that exceeded hard execution timeout
-            const hardTimedoutTasks = await this.#repository.updateManyByQuery({
-                queue: this.#queueName,
-                status: TaskState.Running,
-                startTimestamp: { $lt: sql `${TRANSACTION_TIMESTAMP} - ${interval(this.executionTimeout, 'milliseconds')}` },
-            }, {
-                status: TaskState.Dead,
-                lease: null,
-                error: { message: `Hard Execution Timeout: Task ran longer than ${this.executionTimeout}ms` },
-                completeTimestamp: TRANSACTION_TIMESTAMP,
-                lockExpirationTimestamp: null,
-            });
-            const distinctParentTaskIds = Enumerable
-                .from(expiredTasks)
-                .concat(zombieTasks, hardTimedoutTasks)
-                .filter((task) => isNotNull(task.parentId))
-                .map((task) => task.parentId)
-                .distinct();
-            // 3. Trigger Fan-In for all affected parents
-            for (const parentId of distinctParentTaskIds) {
-                await this.#triggerParentFanIn(parentId, tx);
-            }
-        });
-    }
-    async restart(id, transaction) {
-        await this.#repository.withOptionalTransaction(transaction).updateByQuery({
-            id,
-            $or: [
-                { status: { $ne: TaskState.Running } },
-                { lockExpirationTimestamp: { $lt: TRANSACTION_TIMESTAMP } },
-            ],
-        }, {
-            status: TaskState.Pending,
-            lease: null,
-            error: null,
-            scheduleTimestamp: TRANSACTION_TIMESTAMP,
-            tries: 0,
-            progress: 0,
-            result: null,
-            completeTimestamp: null,
-        });
-    }
-    async *getConsumer(cancellationSignal) {
-        const continue$ = merge(this.#messageBus.allMessages$, cancellationSignal);
-        while (cancellationSignal.isUnset) {
-            const task = await this.dequeue();
-            if (isDefined(task)) {
-                yield task;
-                continue;
-            }
-            await cancelableTimeout(5 * millisecondsPerSecond, continue$);
-        }
-    }
-    async *getBatchConsumer(size, cancellationSignal) {
-        const continue$ = merge(this.#messageBus.allMessages$, cancellationSignal);
-        while (cancellationSignal.isUnset) {
-            const tasks = await this.dequeueMany(size);
-            if (tasks.length > 0) {
-                yield tasks;
-                continue;
-            }
-            await cancelableTimeout(5 * millisecondsPerSecond, continue$);
-        }
-    }
-};
-PostgresQueue = __decorate([
-    Singleton({
-        argumentIdentityProvider: JSON.stringify,
-        providers: [
-            provide(DatabaseConfig, { useFactory: (_, context) => context.resolve(PostgresQueueModuleConfig).database ?? context.resolve(DatabaseConfig, undefined, { skipSelf: 2 }) }),
-        ],
-    })
-], PostgresQueue);
-export { PostgresQueue };

package/queue/postgres/queue.provider.d.ts

@@ -1,7 +0,0 @@
-import { QueueProvider, type QueueConfig } from '../../queue/index.js';
-import type { ObjectLiteral } from '../../types/index.js';
-import { PostgresQueue } from './queue.js';
-export declare class PostgresQueueProvider extends QueueProvider {
-    #private;
-    get<Data extends ObjectLiteral, State extends ObjectLiteral, Result extends ObjectLiteral>(name: string, config?: QueueConfig): PostgresQueue<Data, State, Result>;
-}