@tstdl/base 0.93.92 → 0.93.93

package/task-queue/postgres/task-queue.js

@@ -73,11 +73,12 @@ 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, DependencyJoinMode, TaskQueue, TaskResult, TaskState } from '../task-queue.js';
+import { defaultQueueConfig, DependencyJoinMode, TaskProcessResult, TaskQueue, TaskStatus } from '../task-queue.js';
 import { PostgresTaskQueueModuleConfig } from './module.js';
-import { taskArchive as taskArchiveTable, taskState, task as taskTable } from './schemas.js';
+import { taskArchive as taskArchiveTable, taskStatus, task as taskTable } from './schemas.js';
 import { PostgresTask, PostgresTaskArchive } from './task.model.js';
-let PostgresQueue = class PostgresQueue extends TaskQueue {
+let PostgresTaskQueue = class PostgresTaskQueue extends TaskQueue {
+    #internalThis = this;
     #repository = injectRepository(PostgresTask);
     #archiveRepository = injectRepository(PostgresTaskArchive);
     #config = this.config;
@@ -114,7 +115,7 @@ let PostgresQueue = class PostgresQueue extends TaskQueue {
         id: RANDOM_UUID_V4,
         namespace: this.#namespace,
         type: sql `excluded.type`,
-        status: TaskState.Pending,
+        status: TaskStatus.Pending,
         token: null,
         priority: sql `excluded.priority`,
         idempotencyKey: sql `excluded.idempotency_key`,
@@ -124,7 +125,7 @@ let PostgresQueue = class PostgresQueue extends TaskQueue {
         scheduleAfterTags: sql `excluded.schedule_after_tags`,
         failFast: sql `excluded.fail_fast`,
         dependencyJoinMode: sql `excluded.dependency_join_mode`,
-        dependencyTriggerStates: sql `excluded.dependency_trigger_states`,
+        dependencyTriggerStatuses: sql `excluded.dependency_trigger_statuses`,
         tries: 0,
         creationTimestamp: TRANSACTION_TIMESTAMP,
         priorityAgeTimestamp: TRANSACTION_TIMESTAMP,
@@ -160,7 +161,7 @@ let PostgresQueue = class PostgresQueue extends TaskQueue {
                 return {
                     namespace: this.#namespace,
                     type: item.type,
-                    status: hasDependencies ? TaskState.Waiting : TaskState.Pending,
+                    status: hasDependencies ? TaskStatus.Waiting : TaskStatus.Pending,
                     token: null,
                     priority: item.priority ?? 1000,
                     idempotencyKey: item.idempotencyKey ?? null,
@@ -170,7 +171,7 @@ let PostgresQueue = class PostgresQueue extends TaskQueue {
                     scheduleAfterTags: item.scheduleAfterTags ?? [],
                     failFast: item.failFast ?? false,
                     dependencyJoinMode: item.dependencyJoinMode ?? DependencyJoinMode.And,
-                    dependencyTriggerStates: item.dependencyTriggerStates ?? [TaskState.Completed],
+                    dependencyTriggerStatuses: item.dependencyTriggerStatuses ?? [TaskStatus.Completed],
                     parentId: item.parentId ?? null,
                     tries: 0,
                     progress: 0,
@@ -218,10 +219,10 @@ let PostgresQueue = class PostgresQueue extends TaskQueue {
             }
             await newTransaction?.commit();
             this.#messageBus.publishAndForget();
-            const anyWaiting = tasks.some((t) => t.status == TaskState.Waiting);
+            const anyWaiting = tasks.some((t) => t.status == TaskStatus.Waiting);
             if (anyWaiting) {
-                const tagsToTrigger = distinct(tasks.filter((t) => t.status == TaskState.Waiting).flatMap((t) => [...t.completeAfterTags, ...t.scheduleAfterTags]));
-                await this.triggerTagFanIn(tagsToTrigger, transaction);
+                const tagsToTrigger = distinct(tasks.filter((t) => t.status == TaskStatus.Waiting).flatMap((t) => [...t.completeAfterTags, ...t.scheduleAfterTags]));
+                await this.triggerTagFanIn(tagsToTrigger, { transaction });
             }
             if (options?.returnTasks == true) {
                 return tasks;
@@ -238,46 +239,46 @@ let PostgresQueue = class PostgresQueue extends TaskQueue {
                 await result_1;
         }
     }
-    async has(id) {
-        return await this.#repository.hasByQuery({ namespace: this.#namespace, id });
+    async has(id, options) {
+        return await this.#repository.withOptionalTransaction(options?.transaction).hasByQuery({ namespace: this.#namespace, id });
     }
-    async countByTags(tags) {
+    async countByTags(tags, options) {
         const tagArray = toArray(tags);
         if (tagArray.length == 0) {
             return 0;
         }
-        const [result] = await this.#repository.session
+        const [result] = await this.#repository.withOptionalTransaction(options?.transaction).session
             .select({ count: count() })
             .from(taskTable)
             .where(and(eq(taskTable.namespace, this.#namespace), arrayOverlaps(taskTable.tags, tagArray)))
             .execute();
         return result?.count ?? 0;
     }
-    async getTask(id) {
-        const active = await this.#repository.tryLoadByQuery({ namespace: this.#namespace, id });
+    async getTask(id, options) {
+        const active = await this.#repository.withOptionalTransaction(options?.transaction).tryLoadByQuery({ namespace: this.#namespace, id });
         if (isDefined(active)) {
             return active;
         }
-        return await this.#archiveRepository.tryLoadByQuery({ namespace: this.#namespace, id });
+        return await this.#archiveRepository.withOptionalTransaction(options?.transaction).tryLoadByQuery({ namespace: this.#namespace, id });
     }
-    async getManyByTags(tags) {
+    async getManyByTags(tags, options) {
         const tagArray = toArray(tags);
         if (tagArray.length == 0) {
             return [];
         }
-        const rows = await this.#repository.session
+        const rows = await this.#repository.withOptionalTransaction(options?.transaction).session
             .select()
             .from(taskTable)
             .where(and(eq(taskTable.namespace, this.#namespace), arrayOverlaps(taskTable.tags, tagArray)))
             .execute();
-        return await this.#repository.mapManyToEntity(rows);
+        return await this.#repository.withOptionalTransaction(options?.transaction).mapManyToEntity(rows);
     }
-    async getTree(idOrIds, transaction) {
-        const ids = toArray(idOrIds);
-        return await this.getTreeByQuery({ id: { $in: ids } }, transaction);
+    async getTree(rootId, options) {
+        const ids = toArray(rootId);
+        return await this.getTreeByQuery({ id: { $in: ids } }, options);
     }
-    async getTreeByQuery(query, transaction) {
-        return await this.#repository.useTransaction(transaction, async (tx) => {
+    async getTreeByQuery(query, options) {
+        return await this.#repository.useTransaction(options?.transaction, async (tx) => {
             const repositoryWithTransaction = this.#repository.withTransaction(tx);
             const roots = await repositoryWithTransaction.loadManyByQuery(query);
             if (roots.length == 0) {
@@ -299,38 +300,38 @@ let PostgresQueue = class PostgresQueue extends TaskQueue {
         )
         SELECT * FROM task_tree
       `);
-            const rows = rawResult.rows ?? rawResult;
+            const rows = rawResult.rows;
             return await repositoryWithTransaction.mapManyToEntity(rows);
         });
     }
-    async cancel(id, transaction) {
-        await this.cancelMany([id], transaction);
+    async cancel(id, options) {
+        await this.cancelMany([id], options);
     }
-    async cancelMany(ids, transaction) {
-        await this.#repository.useTransaction(transaction, async (tx) => {
-            const tree = await this.getTree(ids, tx);
+    async cancelMany(ids, options) {
+        await this.#repository.useTransaction(options?.transaction, async (tx) => {
+            const tree = await this.getTree(ids, { transaction: tx });
             const treeIds = tree.map((task) => task.id);
             if (treeIds.length == 0) {
                 return;
             }
             await this.#repository.withTransaction(tx).updateMany(treeIds, {
-                status: TaskState.Cancelled,
+                status: TaskStatus.Cancelled,
                 token: null,
                 completeTimestamp: TRANSACTION_TIMESTAMP,
             });
             const tags = tree.flatMap((t) => t.tags);
-            await this.triggerTagFanIn(tags, tx);
+            await this.triggerTagFanIn(tags, { transaction: tx });
         });
     }
-    async cancelManyByTags(tags) {
-        await this.#repository.transaction(async (tx) => {
-            const tasks = await this.getManyByTags(tags);
+    async cancelManyByTags(tags, options) {
+        await this.#repository.useTransaction(options?.transaction, async (tx) => {
+            const tasks = await this.getManyByTags(tags, { transaction: tx });
             const ids = tasks.map((t) => t.id);
-            await this.cancelMany(ids, tx);
+            await this.cancelMany(ids, { transaction: tx });
         });
     }
-    async clear() {
-        await this.#repository.transaction(async (tx) => {
+    async clear(options) {
+        await this.#repository.useTransaction(options?.transaction, async (tx) => {
             const repository = this.#repository.withTransaction(tx);
             const parentIds = repository.session
                 .select({ id: taskTable.id })
@@ -365,12 +366,12 @@ let PostgresQueue = class PostgresQueue extends TaskQueue {
                 return [];
             }
         }
-        const tasks = await this.#repository.transaction(async (tx) => {
+        const tasks = await this.#repository.useTransaction(options?.transaction, async (tx) => {
             const repository = this.#repository.withTransaction(tx);
             let effectiveCount = count;
             if (!forceDequeue && circuitBreakerResult?.state == CircuitBreakerState.HalfOpen) {
                 if (circuitBreakerResult.isProbe != true) {
-                    const runningCount = await repository.countByQuery({ namespace: this.#namespace, status: TaskState.Running });
+                    const runningCount = await repository.countByQuery({ namespace: this.#namespace, status: TaskStatus.Running });
                     if (runningCount > 0) {
                         return [];
                     }
@@ -381,7 +382,7 @@ let PostgresQueue = class PostgresQueue extends TaskQueue {
             if (!forceDequeue && isNotNull(this.globalConcurrency)) {
                 // WARN: This is a check-then-act race condition.
                 // A distributed lock or an atomic update strategy is needed for strict enforcement.
-                const runningCount = await repository.countByQuery({ namespace: this.#namespace, status: TaskState.Running });
+                const runningCount = await repository.countByQuery({ namespace: this.#namespace, status: TaskStatus.Running });
                 if (runningCount >= this.globalConcurrency) {
                     return [];
                 }
@@ -395,7 +396,7 @@ let PostgresQueue = class PostgresQueue extends TaskQueue {
             const selection = repository.session.$with('selection').as((qb) => qb
                 .select({ id: taskTable.id })
                 .from(taskTable)
-                .where(and(eq(taskTable.namespace, this.#namespace), lte(taskTable.scheduleTimestamp, TRANSACTION_TIMESTAMP), eq(taskTable.status, TaskState.Pending), or(sqlIsNull(taskTable.timeToLive), lt(TRANSACTION_TIMESTAMP, taskTable.timeToLive)), isDefined(options?.types) ? inArray(taskTable.type, options.types) : undefined, sql `pg_sleep(0) IS NOT NULL` // Materialization hack until drizzle implements https://github.com/drizzle-team/drizzle-orm/issues/2318
+                .where(and(eq(taskTable.namespace, this.#namespace), lte(taskTable.scheduleTimestamp, TRANSACTION_TIMESTAMP), eq(taskTable.status, TaskStatus.Pending), or(sqlIsNull(taskTable.timeToLive), lt(TRANSACTION_TIMESTAMP, taskTable.timeToLive)), isDefined(options?.types) ? inArray(taskTable.type, options.types) : undefined, 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))
                 .limit(effectiveCount)
@@ -404,7 +405,7 @@ let PostgresQueue = class PostgresQueue extends TaskQueue {
                 .with(selection)
                 .update(taskTable)
                 .set({
-                status: TaskState.Running,
+                status: TaskStatus.Running,
                 token: RANDOM_UUID_V4,
                 visibilityDeadline: sql `${TRANSACTION_TIMESTAMP} + ${interval(this.visibilityTimeout, 'milliseconds')}`,
                 startTimestamp: TRANSACTION_TIMESTAMP,
@@ -423,29 +424,29 @@ let PostgresQueue = class PostgresQueue extends TaskQueue {
         }
         return tasks;
     }
-    async reschedule(id, timestamp, transaction) {
-        await this.rescheduleMany([id], timestamp, transaction);
+    async reschedule(id, timestamp, options) {
+        await this.rescheduleMany([id], timestamp, options);
     }
-    async rescheduleMany(ids, timestamp, transaction) {
-        await this.#repository.withOptionalTransaction(transaction).updateMany(ids, {
-            status: TaskState.Pending,
+    async rescheduleMany(ids, timestamp, options) {
+        await this.#repository.withOptionalTransaction(options?.transaction).updateMany(ids, {
+            status: TaskStatus.Pending,
             token: null,
             scheduleTimestamp: timestamp,
             visibilityDeadline: null,
             tries: sql `CASE
-        WHEN ${taskTable.status} = ${TaskState.Running} THEN GREATEST(0, ${taskTable.tries} - 1)
+        WHEN ${taskTable.status} = ${TaskStatus.Running} THEN GREATEST(0, ${taskTable.tries} - 1)
         ELSE ${taskTable.tries}
       END`,
         });
     }
-    async rescheduleManyByTags(tags, timestamp, transaction) {
-        await this.#repository.withOptionalTransaction(transaction).updateManyByQuery(and(eq(taskTable.namespace, this.#namespace), arrayOverlaps(taskTable.tags, toArray(tags))), {
-            status: TaskState.Pending,
+    async rescheduleManyByTags(tags, timestamp, options) {
+        await this.#repository.withOptionalTransaction(options?.transaction).updateManyByQuery(and(eq(taskTable.namespace, this.#namespace), arrayOverlaps(taskTable.tags, toArray(tags))), {
+            status: TaskStatus.Pending,
             token: null,
             scheduleTimestamp: timestamp,
             visibilityDeadline: null,
             tries: sql `CASE
-          WHEN ${taskTable.status} = ${TaskState.Running} THEN GREATEST(0, ${taskTable.tries} - 1)
+          WHEN ${taskTable.status} = ${TaskStatus.Running} THEN GREATEST(0, ${taskTable.tries} - 1)
           ELSE ${taskTable.tries}
         END`,
         });
@@ -468,28 +469,28 @@ let PostgresQueue = class PostgresQueue extends TaskQueue {
             const result = await repository.tryUpdateByQuery({
                 namespace: this.#namespace,
                 id: task.id,
-                status: TaskState.Running,
+                status: TaskStatus.Running,
                 token: task.token,
                 startTimestamp: { $gt: sql `${TRANSACTION_TIMESTAMP} - ${interval(this.maxExecutionTime, 'milliseconds')}` },
             }, update);
             // TODO: reduce required DB roundtrips
             if (isUndefined(result)) {
-                const existing = await repository.tryLoadByQuery({ id: task.id, namespace: this.#namespace, status: TaskState.Running, token: task.token });
+                const existing = await repository.tryLoadByQuery({ id: task.id, namespace: this.#namespace, status: TaskStatus.Running, token: task.token });
                 if (isDefined(existing) && isNotNull(existing.startTimestamp) && (currentTimestamp() - existing.startTimestamp) > this.maxExecutionTime) {
-                    await this.fail(task, { message: 'Hard Execution Timeout' }, true, tx);
+                    await this.fail(task, { message: 'Hard Execution Timeout' }, { fatal: true, transaction: tx });
                 }
             }
             return result;
         });
     }
-    async touchMany(tasks, progresses, states, transaction) {
+    async touchMany(tasks, options) {
         if (tasks.length == 0) {
             return [];
         }
-        const repository = this.#repository.withOptionalTransaction(transaction);
+        const repository = this.#repository.withOptionalTransaction(options?.transaction);
         const rows = tasks.map((t, i) => {
-            const progress = progresses?.[i] ?? null;
-            const state = states?.[i] ?? null;
+            const progress = options?.progresses?.[i] ?? null;
+            const state = options?.states?.[i] ?? null;
             return sql `(${t.id}::uuid, ${t.token}::uuid, ${progress}::numeric, ${state}::jsonb)`;
         });
         const updates = repository.session.$with('updates').as((qb) => qb
@@ -508,7 +509,7 @@ let PostgresQueue = class PostgresQueue extends TaskQueue {
             state: coalesce(updates.updateState, taskTable.state),
         })
             .from(updates)
-            .where(and(eq(taskTable.id, updates.updateId), eq(taskTable.namespace, this.#namespace), eq(taskTable.token, updates.updateToken), eq(taskTable.status, TaskState.Running), gt(taskTable.startTimestamp, sql `${TRANSACTION_TIMESTAMP} - ${interval(this.maxExecutionTime, 'milliseconds')}`)))
+            .where(and(eq(taskTable.id, updates.updateId), eq(taskTable.namespace, this.#namespace), eq(taskTable.token, updates.updateToken), eq(taskTable.status, TaskStatus.Running), gt(taskTable.startTimestamp, sql `${TRANSACTION_TIMESTAMP} - ${interval(this.maxExecutionTime, 'milliseconds')}`)))
             .returning({ id: taskTable.id }));
         const result = await repository.session
             .with(updates, updated)
@@ -517,16 +518,16 @@ let PostgresQueue = class PostgresQueue extends TaskQueue {
             .execute();
         return result.map((r) => r.id);
     }
-    async complete(task, result, transaction) {
-        await this.#repository.useTransaction(transaction, async (tx) => {
+    async complete(task, options) {
+        await this.#repository.useTransaction(options?.transaction, async (tx) => {
             const repository = this.#repository.withTransaction(tx);
             const updatedTask = await repository.tryUpdateByQuery({
                 id: task.id,
                 token: task.token,
             }, {
-                status: TaskState.Completed,
+                status: TaskStatus.Completed,
                 token: null,
-                result: result,
+                result: options?.result,
                 progress: 1,
                 completeTimestamp: TRANSACTION_TIMESTAMP,
                 visibilityDeadline: null,
@@ -535,17 +536,17 @@ let PostgresQueue = class PostgresQueue extends TaskQueue {
                 return;
             }
             await this.#circuitBreaker.recordSuccess();
-            await this.triggerTagFanIn(task.tags, tx);
+            await this.triggerTagFanIn(task.tags, { transaction: tx });
         });
     }
-    async completeMany(tasks, results, transaction) {
+    async completeMany(tasks, options) {
         if (tasks.length == 0) {
             return;
         }
-        await this.#repository.useTransaction(transaction, async (tx) => {
+        await this.#repository.useTransaction(options?.transaction, async (tx) => {
             const repository = this.#repository.withTransaction(tx);
             const rows = tasks.map((t, i) => {
-                const result = isDefined(results) ? results[i] : null;
+                const result = options?.results?.[i] ?? null;
                 return sql `(${t.id}::uuid, ${t.token}::uuid, ${result}::jsonb)`;
             });
             const updates = repository.session.$with('updates').as((qb) => qb
@@ -558,7 +559,7 @@ let PostgresQueue = class PostgresQueue extends TaskQueue {
             const updated = repository.session.$with('updated').as(() => repository.session
                 .update(taskTable)
                 .set({
-                status: TaskState.Completed,
+                status: TaskStatus.Completed,
                 token: null,
                 result: updates.updateResult,
                 progress: 1,
@@ -576,18 +577,18 @@ let PostgresQueue = class PostgresQueue extends TaskQueue {
             if (updatedRows.length > 0) {
                 await this.#circuitBreaker.recordSuccess();
                 const tags = updatedRows.flatMap((t) => t.tags);
-                await this.triggerTagFanIn(tags, tx);
+                await this.triggerTagFanIn(tags, { transaction: tx });
             }
         });
     }
-    async fail(task, error, fatal = false, transaction) {
-        const isRetryable = !fatal && (task.tries < this.maxTries);
-        const nextStatus = isRetryable ? TaskState.Pending : TaskState.Dead;
+    async fail(task, error, options) {
+        const isRetryable = (options?.fatal != true) && (task.tries < this.maxTries);
+        const nextStatus = isRetryable ? TaskStatus.Pending : TaskStatus.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) => {
+        await this.#repository.useTransaction(options?.transaction, async (tx) => {
             const updatedTask = await this.#repository.withTransaction(tx).tryUpdateByQuery({
                 namespace: this.#namespace,
                 id: task.id,
@@ -600,46 +601,46 @@ let PostgresQueue = class PostgresQueue extends TaskQueue {
                 visibilityDeadline: null,
                 scheduleTimestamp: nextSchedule,
                 startTimestamp: null,
-                completeTimestamp: (nextStatus == TaskState.Dead) ? TRANSACTION_TIMESTAMP : null,
+                completeTimestamp: (nextStatus == TaskStatus.Dead) ? TRANSACTION_TIMESTAMP : null,
             });
             if (isUndefined(updatedTask)) {
                 return;
             }
             await this.#circuitBreaker.recordFailure();
-            if (nextStatus == TaskState.Dead) {
-                await this.triggerTagFanIn(task.tags, tx);
+            if (nextStatus == TaskStatus.Dead) {
+                await this.triggerTagFanIn(task.tags, { transaction: tx });
             }
         });
     }
-    async triggerTagFanIn(tags, transaction) {
+    async triggerTagFanIn(tags, options) {
         if (tags.length == 0) {
             return;
         }
         const distinctSortedTags = distinct(tags).toSorted();
         const hash = await digest('SHA-256', distinctSortedTags.join(',')).toHex();
         const idempotencyKey = `Sys:FanIn:${hash}`;
-        await this.enqueue('[SystemWorker]:FanIn', { targetTags: distinctSortedTags }, {
+        await this.#internalThis.enqueue('[SystemWorker]:FanIn', { targetTags: distinctSortedTags }, {
             priority: 0,
             idempotencyKey,
             replace: true,
-            transaction,
+            transaction: options?.transaction,
         });
     }
-    async failMany(tasks, errors, transaction) {
+    async failMany(tasks, errors, options) {
         if (tasks.length == 0) {
             return;
         }
-        await this.#repository.useTransaction(transaction, async (tx) => {
+        await this.#repository.useTransaction(options?.transaction, async (tx) => {
             const repository = this.#repository.withTransaction(tx);
             const rows = tasks.map((task, index) => {
                 const error = errors[index];
                 const isRetryable = (task.tries < this.maxTries);
-                const nextStatus = isRetryable ? TaskState.Pending : TaskState.Dead;
+                const nextStatus = isRetryable ? TaskStatus.Pending : TaskStatus.Dead;
                 const delay = isRetryable
                     ? Math.min(this.retryDelayMaximum, this.retryDelayMinimum * (this.retryDelayGrowth ** task.tries))
                     : 0;
                 const nextSchedule = new Date(currentTimestamp() + delay);
-                const completeTimestamp = (nextStatus == TaskState.Dead) ? new Date() : null;
+                const completeTimestamp = (nextStatus == TaskStatus.Dead) ? new Date() : null;
                 return sql `(${task.id}::uuid, ${task.token}::uuid, ${task.tries}::int, ${nextStatus}::text, ${serializeError(error)}::jsonb, ${nextSchedule}::timestamptz, ${completeTimestamp}::timestamptz)`;
             });
             const updates = repository.session.$with('updates').as((qb) => qb
@@ -656,7 +657,7 @@ let PostgresQueue = class PostgresQueue extends TaskQueue {
             const updated = repository.session.$with('updated').as(() => repository.session
                 .update(taskTable)
                 .set({
-                status: sql `${updates.updateStatus}::${taskState}`,
+                status: sql `${updates.updateStatus}::${taskStatus}`,
                 token: null,
                 error: sql `${updates.updateError}`,
                 visibilityDeadline: null,
@@ -675,9 +676,9 @@ let PostgresQueue = class PostgresQueue extends TaskQueue {
             if (result.length > 0) {
                 await Promise.all(createArray(result.length, async () => await this.#circuitBreaker.recordFailure()));
                 const deadTags = result
-                    .filter((r) => r.status == TaskState.Dead)
+                    .filter((r) => r.status == TaskStatus.Dead)
                     .flatMap((r) => r.tags);
-                await this.triggerTagFanIn(deadTags, tx);
+                await this.triggerTagFanIn(deadTags, { transaction: tx });
             }
         });
     }
@@ -688,7 +689,7 @@ let PostgresQueue = class PostgresQueue extends TaskQueue {
             const waiters = await repository.session
                 .select()
                 .from(taskTable)
-                .where(and(eq(taskTable.namespace, this.#namespace), eq(taskTable.status, TaskState.Waiting), or(arrayOverlaps(taskTable.completeAfterTags, targetTags), arrayOverlaps(taskTable.scheduleAfterTags, targetTags))))
+                .where(and(eq(taskTable.namespace, this.#namespace), eq(taskTable.status, TaskStatus.Waiting), or(arrayOverlaps(taskTable.completeAfterTags, targetTags), arrayOverlaps(taskTable.scheduleAfterTags, targetTags))))
                 .for('update', { skipLocked: true })
                 .execute();
             const entities = await repository.mapManyToEntity(waiters);
@@ -712,13 +713,13 @@ let PostgresQueue = class PostgresQueue extends TaskQueue {
                 }
                 tagStats.get(row.tag).set(row.status, row.count);
             }
-            const getCount = (tags, states) => {
+            const getCount = (tags, Statuses) => {
                 let sum = 0;
                 for (const tag of tags) {
                     const stats = tagStats.get(tag);
                     if (isDefined(stats)) {
-                        for (const state of states) {
-                            sum += stats.get(state) ?? 0;
+                        for (const status of Statuses) {
+                            sum += stats.get(status) ?? 0;
                         }
                     }
                 }
@@ -734,23 +735,28 @@ let PostgresQueue = class PostgresQueue extends TaskQueue {
                 let shouldFail = false;
                 // 1. Check Fail Fast
                 if (waiter.failFast) {
-                    if (getCount(requiredTags, [TaskState.Dead, TaskState.Cancelled]) > 0) {
+                    if (getCount(requiredTags, [TaskStatus.Dead, TaskStatus.Cancelled]) > 0) {
                         shouldFail = true;
                     }
                 }
                 // 2. Check Trigger Conditions
                 if (!shouldFail) {
                     if (waiter.dependencyJoinMode == DependencyJoinMode.Or) {
-                        if (getCount(requiredTags, waiter.dependencyTriggerStates) > 0) {
+                        if (getCount(requiredTags, waiter.dependencyTriggerStatuses) > 0) {
                             isReady = true;
                         }
                     }
                     else if (waiter.dependencyJoinMode == DependencyJoinMode.And) {
-                        // For AND, we need "No active tasks".
-                        // Active = Pending, Running, Waiting.
-                        if (getCount(requiredTags, [TaskState.Pending, TaskState.Running, TaskState.Waiting]) == 0) {
-                            isReady = true;
-                        }
+                        isReady = requiredTags.every((tag) => {
+                            const stats = tagStats.get(tag);
+                            if (isUndefined(stats)) {
+                                return false;
+                            }
+                            const activeCount = (stats.get(TaskStatus.Pending) ?? 0)
+                                + (stats.get(TaskStatus.Running) ?? 0)
+                                + (stats.get(TaskStatus.Waiting) ?? 0);
+                            return activeCount == 0;
+                        });
                     }
                 }
                 // 3. Transition
@@ -760,8 +766,9 @@ let PostgresQueue = class PostgresQueue extends TaskQueue {
                 else if (isReady) {
                     if (waiter.scheduleAfterTags.length > 0) {
                         idsToSchedule.push(waiter.id);
+                        fanInTags.push(...waiter.tags);
                     }
-                    else {
+                    else if (waiter.completeAfterTags.length > 0) {
                         idsToComplete.push(waiter.id);
                         fanInTags.push(...waiter.tags);
                     }
@@ -769,43 +776,43 @@ let PostgresQueue = class PostgresQueue extends TaskQueue {
             }
             if (idsToFail.length > 0) {
                 const rows = await repository.updateMany(idsToFail, {
-                    status: TaskState.Dead,
+                    status: TaskStatus.Dead,
                     error: { code: 'DependencyFailed' },
                     completeTimestamp: TRANSACTION_TIMESTAMP,
                 });
                 const tags = rows.flatMap((r) => r.tags);
-                await this.triggerTagFanIn(tags, tx);
+                await this.triggerTagFanIn(tags, { transaction: tx });
             }
             if (idsToSchedule.length > 0) {
                 await repository.updateMany(idsToSchedule, {
-                    status: TaskState.Pending,
+                    status: TaskStatus.Pending,
                     scheduleTimestamp: TRANSACTION_TIMESTAMP,
                 });
             }
             if (idsToComplete.length > 0) {
                 await repository.updateMany(idsToComplete, {
-                    status: TaskState.Completed,
+                    status: TaskStatus.Completed,
                     completeTimestamp: TRANSACTION_TIMESTAMP,
                     progress: 1,
                     token: null,
                 });
-                await this.triggerTagFanIn(fanInTags, tx);
+                await this.triggerTagFanIn(fanInTags, { transaction: tx });
             }
         });
     }
-    async maintenance() {
+    async maintenance(options) {
         const repository = this.#repository;
         const archiveRepository = this.#archiveRepository;
         // 1. Archival: Move old terminal tasks to archive
         while (true) {
-            const archivedCount = await repository.transaction(async (tx) => {
+            const archivedCount = await repository.useTransaction(options?.transaction, async (tx) => {
                 const repositoryWithTx = repository.withTransaction(tx);
                 const archiveRepositoryWithTx = archiveRepository.withTransaction(tx);
                 const tasksToArchive = await repositoryWithTx.loadManyByQuery({
                     $and: [
                         {
                             namespace: this.#namespace,
-                            status: { $in: [TaskState.Completed, TaskState.Dead, TaskState.Cancelled] },
+                            status: { $in: [TaskStatus.Completed, TaskStatus.Dead, TaskStatus.Cancelled] },
                             completeTimestamp: { $lt: sql `${TRANSACTION_TIMESTAMP} - ${interval(this.retention, 'milliseconds')}` },
                         },
                         notInArray(taskTable.id, repositoryWithTx.session
@@ -826,7 +833,7 @@ let PostgresQueue = class PostgresQueue extends TaskQueue {
         }
         // 2. Purge Archive: Remove very old archived tasks
         while (true) {
-            const deletedArchiveCount = await archiveRepository.transaction(async (tx) => {
+            const deletedArchiveCount = await archiveRepository.useTransaction(options?.transaction, async (tx) => {
                 const repositoryWithTx = archiveRepository.withTransaction(tx);
                 const selection = repositoryWithTx.session.$with('archive_purge_selection').as((qb) => qb
                     .select({ id: taskArchiveTable.id })
@@ -846,21 +853,21 @@ let PostgresQueue = class PostgresQueue extends TaskQueue {
         }
         // 3. Maintenance Loop
         while (true) {
-            const maintenanceCount = await repository.transaction(async (tx) => {
+            const maintenanceCount = await repository.useTransaction(options?.transaction, async (tx) => {
                 const repositoryWithTx = repository.withTransaction(tx);
                 let totalUpdated = 0;
                 // 3.1 Handle Pending Expiration
                 const expiredSelection = repositoryWithTx.session.$with('expired_selection').as((qb) => qb
                     .select({ id: taskTable.id })
                     .from(taskTable)
-                    .where(and(eq(taskTable.namespace, this.#namespace), eq(taskTable.status, TaskState.Pending), lt(taskTable.timeToLive, TRANSACTION_TIMESTAMP)))
+                    .where(and(eq(taskTable.namespace, this.#namespace), eq(taskTable.status, TaskStatus.Pending), lt(taskTable.timeToLive, TRANSACTION_TIMESTAMP)))
                     .limit(1000)
                     .for('update', { skipLocked: true }));
                 const expiredRows = await repositoryWithTx.session
                     .with(expiredSelection)
                     .update(taskTable)
                     .set({
-                    status: TaskState.Dead,
+                    status: TaskStatus.Dead,
                     token: null,
                     error: { code: 'Expired', message: 'Task expired before processing' },
                     completeTimestamp: TRANSACTION_TIMESTAMP,
@@ -869,20 +876,20 @@ let PostgresQueue = class PostgresQueue extends TaskQueue {
                     .returning({ tags: taskTable.tags });
                 totalUpdated += expiredRows.length;
                 if (expiredRows.length > 0) {
-                    await this.triggerTagFanIn(expiredRows.flatMap((r) => r.tags), tx);
+                    await this.triggerTagFanIn(expiredRows.flatMap((r) => r.tags), { transaction: tx });
                 }
                 // 3.2 Handle Zombie Tasks (Retry)
                 const zombieRetrySelection = repositoryWithTx.session.$with('zombie_retry_selection').as((qb) => qb
                     .select({ id: taskTable.id })
                     .from(taskTable)
-                    .where(and(eq(taskTable.namespace, this.#namespace), eq(taskTable.status, TaskState.Running), lt(taskTable.visibilityDeadline, TRANSACTION_TIMESTAMP), lt(taskTable.tries, this.maxTries)))
+                    .where(and(eq(taskTable.namespace, this.#namespace), eq(taskTable.status, TaskStatus.Running), lt(taskTable.visibilityDeadline, TRANSACTION_TIMESTAMP), lt(taskTable.tries, this.maxTries)))
                     .limit(1000)
                     .for('update', { skipLocked: true }));
                 const zombieRetryRows = await repositoryWithTx.session
                     .with(zombieRetrySelection)
                     .update(taskTable)
                     .set({
-                    status: TaskState.Pending,
+                    status: TaskStatus.Pending,
                     token: null,
                     visibilityDeadline: null,
                     scheduleTimestamp: sql `${TRANSACTION_TIMESTAMP} + ${interval(this.retryDelayMinimum, 'milliseconds')}`, // Simple backoff for zombies
@@ -895,14 +902,14 @@ let PostgresQueue = class PostgresQueue extends TaskQueue {
                 const zombieExhaustionSelection = repositoryWithTx.session.$with('zombie_exhaustion_selection').as((qb) => qb
                     .select({ id: taskTable.id })
                     .from(taskTable)
-                    .where(and(eq(taskTable.namespace, this.#namespace), eq(taskTable.status, TaskState.Running), lt(taskTable.visibilityDeadline, TRANSACTION_TIMESTAMP), gte(taskTable.tries, this.maxTries)))
+                    .where(and(eq(taskTable.namespace, this.#namespace), eq(taskTable.status, TaskStatus.Running), lt(taskTable.visibilityDeadline, TRANSACTION_TIMESTAMP), gte(taskTable.tries, this.maxTries)))
                     .limit(1000)
                     .for('update', { skipLocked: true }));
                 const exhaustionRows = await repositoryWithTx.session
                     .with(zombieExhaustionSelection)
                     .update(taskTable)
                     .set({
-                    status: TaskState.Dead,
+                    status: TaskStatus.Dead,
                     token: null,
                     visibilityDeadline: null,
                     completeTimestamp: TRANSACTION_TIMESTAMP,
@@ -912,20 +919,20 @@ let PostgresQueue = class PostgresQueue extends TaskQueue {
                     .returning({ tags: taskTable.tags });
                 totalUpdated += exhaustionRows.length;
                 if (exhaustionRows.length > 0) {
-                    await this.triggerTagFanIn(exhaustionRows.flatMap((r) => r.tags), tx);
+                    await this.triggerTagFanIn(exhaustionRows.flatMap((r) => r.tags), { transaction: tx });
                 }
                 // 3.4 Handle Hard Timeout
                 const timeoutSelection = repositoryWithTx.session.$with('timeout_selection').as((qb) => qb
                     .select({ id: taskTable.id })
                     .from(taskTable)
-                    .where(and(eq(taskTable.namespace, this.#namespace), eq(taskTable.status, TaskState.Running), lt(taskTable.startTimestamp, sql `${TRANSACTION_TIMESTAMP} - ${interval(this.maxExecutionTime, 'milliseconds')}`)))
+                    .where(and(eq(taskTable.namespace, this.#namespace), eq(taskTable.status, TaskStatus.Running), lt(taskTable.startTimestamp, sql `${TRANSACTION_TIMESTAMP} - ${interval(this.maxExecutionTime, 'milliseconds')}`)))
                     .limit(1000)
                     .for('update', { skipLocked: true }));
                 const timeoutRows = await repositoryWithTx.session
                     .with(timeoutSelection)
                     .update(taskTable)
                     .set({
-                    status: TaskState.Dead,
+                    status: TaskStatus.Dead,
                     token: null,
                     visibilityDeadline: null,
                     completeTimestamp: TRANSACTION_TIMESTAMP,
@@ -935,13 +942,13 @@ let PostgresQueue = class PostgresQueue extends TaskQueue {
                     .returning({ tags: taskTable.tags });
                 totalUpdated += timeoutRows.length;
                 if (timeoutRows.length > 0) {
-                    await this.triggerTagFanIn(timeoutRows.flatMap((r) => r.tags), tx);
+                    await this.triggerTagFanIn(timeoutRows.flatMap((r) => r.tags), { transaction: tx });
                 }
                 // 3.5 Promote Priority (Aging)
                 const agingSelection = repositoryWithTx.session.$with('aging_selection').as((qb) => qb
                     .select({ id: taskTable.id })
                     .from(taskTable)
-                    .where(and(eq(taskTable.namespace, this.#namespace), eq(taskTable.status, TaskState.Pending), lt(taskTable.priorityAgeTimestamp, sql `${TRANSACTION_TIMESTAMP} - ${interval(this.priorityAgingInterval, 'milliseconds')}`)))
+                    .where(and(eq(taskTable.namespace, this.#namespace), eq(taskTable.status, TaskStatus.Pending), lt(taskTable.priorityAgeTimestamp, sql `${TRANSACTION_TIMESTAMP} - ${interval(this.priorityAgingInterval, 'milliseconds')}`)))
                     .limit(1000)
                     .for('update', { skipLocked: true }));
                 const agingRows = await repositoryWithTx.session
@@ -966,7 +973,7 @@ let PostgresQueue = class PostgresQueue extends TaskQueue {
         await repository.session
             .update(taskTable)
             .set({
-            status: TaskState.Pending,
+            status: TaskStatus.Pending,
             token: null,
             error: null,
             result: null,
@@ -975,9 +982,9 @@ let PostgresQueue = class PostgresQueue extends TaskQueue {
             tries: 0,
             progress: 0,
             priorityAgeTimestamp: TRANSACTION_TIMESTAMP,
-            state: options?.resetState == true ? null : undefined,
+            state: (options?.resetState == true) ? null : undefined,
         })
-            .where(and(eq(taskTable.namespace, this.#namespace), eq(taskTable.id, id), or(eq(taskTable.status, TaskState.Pending), eq(taskTable.status, TaskState.Completed), eq(taskTable.status, TaskState.Cancelled), eq(taskTable.status, TaskState.Dead), lt(taskTable.visibilityDeadline, TRANSACTION_TIMESTAMP))))
+            .where(and(eq(taskTable.namespace, this.#namespace), eq(taskTable.id, id), or(eq(taskTable.status, TaskStatus.Pending), eq(taskTable.status, TaskStatus.Completed), eq(taskTable.status, TaskStatus.Cancelled), eq(taskTable.status, TaskStatus.Dead), lt(taskTable.visibilityDeadline, TRANSACTION_TIMESTAMP))))
             .execute();
     }
     async *getConsumer(cancellationSignal, options) {
@@ -1004,31 +1011,34 @@ let PostgresQueue = class PostgresQueue extends TaskQueue {
             }
         }
     }
-    async processPendingFanIn(transaction) {
+    /**
+     * @internal for internal unit test use only
+     * @param options
+     * @returns
+     */
+    async processPendingFanIn(options) {
         let processedCount = 0;
         while (true) {
-            const task = await this.dequeue({ types: ['[SystemWorker]:FanIn'], forceDequeue: true });
+            const task = await this.#internalThis.dequeue({ types: ['[SystemWorker]:FanIn'], forceDequeue: true, transaction: options?.transaction });
             if (isUndefined(task)) {
                 break;
             }
             try {
-                const data = task.data;
-                await this.resolveDependencies(data.targetTags);
-                await this.complete(task, undefined, transaction);
+                await this.resolveDependencies(task.data.targetTags);
+                await this.#internalThis.complete(task, { transaction: options?.transaction });
                 processedCount++;
             }
             catch (error) {
-                await this.fail(task, error, false, transaction);
+                await this.#internalThis.fail(task, error, { transaction: options?.transaction });
                 throw error;
             }
         }
         return processedCount;
     }
     startSystemWorker() {
-        this.process({ concurrency: 1, cancellationSignal: this.#cancellationSignal, forceDequeue: true, types: ['[SystemWorker]:FanIn'] }, async (context) => {
-            const data = context.data;
-            await this.resolveDependencies(data.targetTags);
-            return TaskResult.Complete();
+        this.#internalThis.process({ concurrency: 1, cancellationSignal: this.#cancellationSignal, forceDequeue: true, types: ['[SystemWorker]:FanIn'] }, async (context) => {
+            await this.resolveDependencies(context.data.targetTags);
+            return TaskProcessResult.Complete();
         });
     }
     async *getBatchConsumer(size, cancellationSignal, options) {
@@ -1043,12 +1053,12 @@ let PostgresQueue = class PostgresQueue extends TaskQueue {
         }
     }
 };
-PostgresQueue = __decorate([
+PostgresTaskQueue = __decorate([
     Singleton({
         argumentIdentityProvider: JSON.stringify,
         providers: [
             provide(DatabaseConfig, { useFactory: (_, context) => context.resolve(PostgresTaskQueueModuleConfig).database ?? context.resolve(DatabaseConfig, undefined, { skipSelf: 2 }) }),
         ],
     })
-], PostgresQueue);
-export { PostgresQueue };
+], PostgresTaskQueue);
+export { PostgresTaskQueue };