@tstdl/base 0.93.92 → 0.93.94

package/task-queue/task-queue.d.ts

@@ -4,43 +4,18 @@ import type { Resolvable, resolveArgumentType } from '../injector/interfaces.js'
 import { Logger } from '../logger/logger.js';
 import type { Transaction } from '../orm/server/transaction.js';
 import { Transactional } from '../orm/server/transactional.js';
-import type { OneOrMany, UndefinableJson } from '../types/types.js';
+import type { OneOrMany, Record, UndefinableJson } from '../types/types.js';
 import { TaskQueueEnqueueBatch } from './enqueue-batch.js';
-import { BatchTaskContext, type TaskContext } from './task-context.js';
-type TaskResultPayload<Result> = {
-    action: 'complete';
-    result: Result | undefined;
-} | {
-    action: 'fail';
-    error: any;
-    fatal: boolean;
-} | {
-    action: 'reschedule';
-    timestamp: number;
-};
-export declare class TaskResult<Result = unknown> {
-    readonly payload: TaskResultPayload<Result>;
+import type { ProcessBatchWorker, ProcessWorker, TaskData, TaskDefinitionMap, TaskOfType, TaskProcessResultPayload, TaskResult, TaskState, TaskTypes, TasksResults, TasksStates } from './types.js';
+export declare class TaskProcessResult<Result = unknown> {
+    readonly payload: TaskProcessResultPayload<Result>;
     private constructor();
-    static Complete<Result>(result?: Result): TaskResult<Result>;
-    static Fail(error: any, fatal?: boolean): TaskResult;
-    static RescheduleTo(timestamp: number): TaskResult;
-    static RescheduleBy(milliseconds: number): TaskResult;
-}
-export interface ProcessWorker<Data, State, Result> {
-    /**
-     * A worker function that processes a single task.
-     * @param context The task context providing data, logger, and orchestration helpers.
-     */
-    (context: TaskContext<Data, State, Result>): TaskResult<Result> | Promise<TaskResult<Result>>;
-}
-export interface ProcessBatchWorker<Data, State, Result> {
-    /**
-     * A worker function that processes a batch of tasks.
-     * @param context The batch context providing tasks and helpers.
-     */
-    (context: BatchTaskContext<Data, State, Result>): TaskResult<Result>[] | Promise<TaskResult<Result>[]>;
+    static Complete<Result>(result?: Result): TaskProcessResult<Result>;
+    static Fail(error: unknown, fatal?: boolean): TaskProcessResult;
+    static RescheduleTo(timestamp: number): TaskProcessResult;
+    static RescheduleBy(milliseconds: number): TaskProcessResult;
 }
-export declare const TaskState: {
+export declare const TaskStatus: {
     /**
      * The task is waiting to be processed.
      */
@@ -66,59 +41,65 @@ export declare const TaskState: {
      */
     readonly Dead: "dead";
 };
-export type TaskState = EnumType<typeof TaskState>;
+export type TaskStatus = EnumType<typeof TaskStatus>;
 export declare const DependencyJoinMode: {
     readonly And: "and";
     readonly Or: "or";
 };
 export type DependencyJoinMode = EnumType<typeof DependencyJoinMode>;
-export type Task<Data = unknown, State = unknown, Result = unknown> = {
-    id: string;
-    namespace: string;
-    type: string;
-    status: TaskState;
-    token: string | null;
-    /**
-     * The lower the number, the higher the priority.
-     * @default 1000
-     */
-    priority: number;
-    idempotencyKey: string | null;
-    traceId: string | null;
-    tags: string[];
-    completeAfterTags: string[];
-    scheduleAfterTags: string[];
-    failFast: boolean;
-    dependencyJoinMode: DependencyJoinMode;
-    dependencyTriggerStates: TaskState[];
-    data: Data | null;
-    parentId: string | null;
-    tries: number;
-    creationTimestamp: number;
-    priorityAgeTimestamp: number;
-    scheduleTimestamp: number;
-    /**
-     * Timestamp when the task most recently switched to Running state.
-     * Used for Hard Execution Timeouts.
-     */
-    startTimestamp: number | null;
-    /**
-     * Timestamp after which the task is considered expired if it hasn't started Running.
-     * If null, the task never expires in the queue.
-     */
-    timeToLive: number | null;
-    /**
-     * Token expiration (Soft Timeout).
-     */
-    visibilityDeadline: number | null;
-    completeTimestamp: number | null;
-    /** A number between 0 and 1 indicating the progress of the task. */
-    progress: number;
-    /** A snapshot of the current state of the task. */
-    state: State | null;
-    result: Result | null;
-    error: UndefinableJson | null;
-};
+export type Task<Definitions extends TaskDefinitionMap = Record<string, {
+    data: unknown;
+    state: unknown;
+    result: unknown;
+}>> = {
+    [Type in TaskTypes<Definitions>]: {
+        id: string;
+        namespace: string;
+        type: Type;
+        status: TaskStatus;
+        token: string | null;
+        /**
+         * The lower the number, the higher the priority.
+         * @default 1000
+         */
+        priority: number;
+        idempotencyKey: string | null;
+        traceId: string | null;
+        tags: string[];
+        completeAfterTags: string[];
+        scheduleAfterTags: string[];
+        failFast: boolean;
+        dependencyJoinMode: DependencyJoinMode;
+        dependencyTriggerStatuses: TaskStatus[];
+        data: TaskData<Definitions, Type>;
+        parentId: string | null;
+        tries: number;
+        creationTimestamp: number;
+        priorityAgeTimestamp: number;
+        scheduleTimestamp: number;
+        /**
+         * Timestamp when the task most recently switched to Running state.
+         * Used for Hard Execution Timeouts.
+         */
+        startTimestamp: number | null;
+        /**
+         * Timestamp after which the task is considered expired if it hasn't started Running.
+         * If null, the task never expires in the queue.
+         */
+        timeToLive: number | null;
+        /**
+         * Token expiration (Soft Timeout).
+         */
+        visibilityDeadline: number | null;
+        completeTimestamp: number | null;
+        /** A number between 0 and 1 indicating the progress of the task. */
+        progress: number;
+        /** A snapshot of the current state of the task. */
+        state: TaskState<Definitions, Type> | null;
+        result: TaskResult<Definitions, Type> | null;
+        error: UndefinableJson | null;
+    };
+}[Extract<keyof Definitions, string>];
 export declare const defaultTaskPriority = 1000;
 export type EnqueueOptions = {
     priority?: number;
@@ -130,16 +111,18 @@ export type EnqueueOptions = {
     scheduleAfterTags?: string[];
     failFast?: boolean;
     dependencyJoinMode?: DependencyJoinMode;
-    dependencyTriggerStates?: TaskState[];
+    dependencyTriggerStatuses?: TaskStatus[];
     scheduleTimestamp?: number;
     timeToLive?: number;
     transaction?: Transaction;
 };
 export type EnqueueOneOptions = EnqueueOptions;
-export type EnqueueManyItem<T> = EnqueueOptions & {
-    type: string;
-    data: T;
-};
+export type EnqueueManyItem<Definitions extends TaskDefinitionMap = TaskDefinitionMap, Type extends TaskTypes<Definitions> = TaskTypes<Definitions>> = {
+    [Type in TaskTypes<Definitions>]: {
+        type: Type;
+        data: TaskData<Definitions, Type>;
+    } & EnqueueOptions;
+}[Type];
 export type EnqueueManyOptions = {
     replace?: boolean;
     returnTasks?: boolean;
@@ -192,7 +175,7 @@ export type TaskQueueArgument = string | (QueueConfig & {
     namespace: string;
 });
 export declare const defaultQueueConfig: Required<QueueConfig>;
-export declare abstract class TaskQueue<Data, State = unknown, Result = unknown> extends Transactional implements Resolvable<TaskQueueArgument> {
+export declare abstract class TaskQueue<Definitions extends TaskDefinitionMap = TaskDefinitionMap> extends Transactional implements Resolvable<TaskQueueArgument> {
     readonly [resolveArgumentType]: TaskQueueArgument;
     protected readonly config: QueueConfig & {
         namespace: string;
@@ -200,82 +183,127 @@ export declare abstract class TaskQueue<Data, State = unknown, Result = unknown>
     protected readonly logger: Logger;
     abstract readonly visibilityTimeout: number;
     abstract readonly maxTries: number;
-    batch(): TaskQueueEnqueueBatch<Data, State, Result>;
-    abstract enqueue(type: string, data: Data, options?: EnqueueOneOptions): Promise<Task<Data, State, Result>>;
-    abstract enqueueMany(items: EnqueueManyItem<Data>[], options?: EnqueueManyOptions & {
+    batch(): TaskQueueEnqueueBatch<Definitions>;
+    abstract enqueue<Type extends TaskTypes<Definitions>>(type: Type, data: TaskData<Definitions, Type>, options?: EnqueueOneOptions): Promise<TaskOfType<Definitions, Type>>;
+    abstract enqueueMany<Type extends TaskTypes<Definitions>>(items: EnqueueManyItem<Definitions, Type>[], options?: EnqueueManyOptions & {
         returnTasks?: false;
     }): Promise<void>;
-    abstract enqueueMany(items: EnqueueManyItem<Data>[], options: EnqueueManyOptions & {
+    abstract enqueueMany<Type extends TaskTypes<Definitions>>(items: EnqueueManyItem<Definitions, Type>[], options: EnqueueManyOptions & {
         returnTasks: true;
-    }): Promise<Task<Data, State, Result>[]>;
-    abstract enqueueMany(items: EnqueueManyItem<Data>[], options?: EnqueueManyOptions): Promise<Task<Data, State, Result>[] | undefined>;
-    abstract has(id: string): Promise<boolean>;
-    abstract getTask(id: string): Promise<Task<Data, State, Result> | undefined>;
-    abstract getManyByTags(tags: OneOrMany<string>): Promise<Task<Data, State, Result>[]>;
-    abstract countByTags(tags: OneOrMany<string>): Promise<number>;
-    abstract getTree(rootId: string | string[]): Promise<Task<unknown, unknown, unknown>[]>;
-    abstract cancel(id: string): Promise<void>;
-    abstract cancelMany(ids: string[]): Promise<void>;
-    abstract cancelManyByTags(tags: OneOrMany<string>): Promise<void>;
+    }): Promise<TaskOfType<Definitions, Type>[]>;
+    abstract enqueueMany<Type extends TaskTypes<Definitions>>(items: EnqueueManyItem<Definitions, Type>[], options?: EnqueueManyOptions): Promise<TaskOfType<Definitions, Type>[] | undefined>;
+    abstract has(id: string, options?: {
+        transaction?: Transaction;
+    }): Promise<boolean>;
+    abstract getTask(id: string, options?: {
+        transaction?: Transaction;
+    }): Promise<Task<Definitions> | undefined>;
+    abstract getManyByTags(tags: OneOrMany<string>, options?: {
+        transaction?: Transaction;
+    }): Promise<Task<Definitions>[]>;
+    abstract countByTags(tags: OneOrMany<string>, options?: {
+        transaction?: Transaction;
+    }): Promise<number>;
+    abstract getTree(rootId: string | string[], options?: {
+        transaction?: Transaction;
+    }): Promise<Task[]>;
+    abstract cancel(id: string, options?: {
+        transaction?: Transaction;
+    }): Promise<void>;
+    abstract cancelMany(ids: string[], options?: {
+        transaction?: Transaction;
+    }): Promise<void>;
+    abstract cancelManyByTags(tags: OneOrMany<string>, options?: {
+        transaction?: Transaction;
+    }): Promise<void>;
     /** Clears all tasks from the queue. Use with caution! */
-    abstract clear(): Promise<void>;
-    abstract dequeue(): Promise<Task<Data, State, Result> | undefined>;
-    abstract dequeueMany(count: number, options?: {
+    abstract clear(options?: {
+        transaction?: Transaction;
+    }): Promise<void>;
+    abstract dequeue<Type extends TaskTypes<Definitions>>(options?: {
         forceDequeue?: boolean;
-        types?: string[];
-    }): Promise<Task<Data, State, Result>[]>;
+        types?: Type[];
+        transaction?: Transaction;
+    }): Promise<TaskOfType<Definitions, Type> | undefined>;
+    abstract dequeueMany<Type extends TaskTypes<Definitions>>(count: number, options?: {
+        forceDequeue?: boolean;
+        types?: Type[];
+        transaction?: Transaction;
+    }): Promise<TaskOfType<Definitions, Type>[]>;
     /**
      * Reschedules a task to run at a specific time.
      * NOTE: If the task is currently running, its retry count is decremented (refunded) so this attempt doesn't count against maxTries.
      */
-    abstract reschedule(id: string, timestamp: number, transaction?: Transaction): Promise<void>;
-    abstract rescheduleMany(ids: string[], timestamp: number, transaction?: Transaction): Promise<void>;
-    abstract rescheduleManyByTags(tags: OneOrMany<string>, timestamp: number, transaction?: Transaction): Promise<void>;
+    abstract reschedule(id: string, timestamp: number, options?: {
+        transaction?: Transaction;
+    }): Promise<void>;
+    abstract rescheduleMany(ids: string[], timestamp: number, options?: {
+        transaction?: Transaction;
+    }): Promise<void>;
+    abstract rescheduleManyByTags(tags: OneOrMany<string>, timestamp: number, options?: {
+        transaction?: Transaction;
+    }): Promise<void>;
     /**
      * Updates task progress, state and lock.
      * Returns the updated task if successful, `undefined` if task is lost/cancelled/timed out.
      */
-    abstract touch(task: Task, options?: {
+    abstract touch<Type extends TaskTypes<Definitions>>(task: TaskOfType<Definitions, Type>, options?: {
         progress?: number;
-        state?: State;
+        state?: TaskState<Definitions, Type>;
         transaction?: Transaction;
-    }): Promise<Task<Data, State, Result> | undefined>;
+    }): Promise<TaskOfType<Definitions, Type> | undefined>;
     /**
      * Updates multiple tasks' progress, state and lock.
      * Returns the IDs of the successfully updated tasks.
      */
-    abstract touchMany(tasks: Task[], progresses?: number[], states?: State[], transaction?: Transaction): Promise<string[]>;
-    abstract complete<R>(task: Task<any, any, R>, result?: R, transaction?: Transaction): Promise<void>;
-    abstract completeMany<R>(tasks: Task<any, any, R>[], results?: R[], transaction?: Transaction): Promise<void>;
-    abstract fail(task: Task, error: any, fatal?: boolean, transaction?: Transaction): Promise<void>;
-    abstract failMany(tasks: Task[], error: any, transaction?: Transaction): Promise<void>;
-    abstract maintenance(): Promise<void>;
+    abstract touchMany<Tasks extends Task<Definitions>[]>(tasks: Tasks, options?: {
+        progresses?: number[];
+        states?: TasksStates<Tasks>;
+        transaction?: Transaction;
+    }): Promise<string[]>;
+    abstract complete<Type extends TaskTypes<Definitions>>(task: TaskOfType<Definitions, Type>, options?: {
+        result?: TaskResult<Definitions, Type>;
+        transaction?: Transaction;
+    }): Promise<void>;
+    abstract completeMany<Tasks extends Task<Definitions>[]>(tasks: Tasks, options?: {
+        results?: TasksResults<Tasks>;
+        transaction?: Transaction;
+    }): Promise<void>;
+    abstract fail(task: Task<Definitions>, error: unknown, options?: {
+        fatal?: boolean;
+        transaction?: Transaction;
+    }): Promise<void>;
+    abstract failMany(tasks: Task<Definitions>[], errors: unknown[], options?: {
+        transaction?: Transaction;
+    }): Promise<void>;
+    abstract maintenance(options?: {
+        transaction?: Transaction;
+    }): Promise<void>;
     abstract restart(id: string, options?: {
         resetState?: boolean;
         transaction?: Transaction;
     }): Promise<void>;
-    abstract getConsumer(cancellationSignal: CancellationSignal, options?: {
+    abstract getConsumer<Type extends TaskTypes<Definitions>>(cancellationSignal: CancellationSignal, options?: {
         forceDequeue?: boolean;
-        types?: string[];
-    }): AsyncIterableIterator<Task<Data, State, Result>>;
-    abstract getBatchConsumer(size: number, cancellationSignal: CancellationSignal, options?: {
+        types?: Type[];
+    }): AsyncIterableIterator<TaskOfType<Definitions, Type>>;
+    abstract getBatchConsumer<Type extends TaskTypes<Definitions>>(size: number, cancellationSignal: CancellationSignal, options?: {
         forceDequeue?: boolean;
-        types?: string[];
-    }): AsyncIterableIterator<Task<Data, State, Result>[]>;
-    process({ concurrency, cancellationSignal, types, forceDequeue }: {
+        types?: Type[];
+    }): AsyncIterableIterator<TaskOfType<Definitions, Type>[]>;
+    process<Type extends TaskTypes<Definitions>>({ concurrency, cancellationSignal, types, forceDequeue }: {
         concurrency?: number;
         cancellationSignal: CancellationSignal;
-        types?: string[];
+        types?: Type[];
         forceDequeue?: boolean;
-    }, handler: ProcessWorker<Data, State, Result>): void;
-    processBatch({ batchSize, concurrency, cancellationSignal, types, forceDequeue }: {
+    }, handler: ProcessWorker<Definitions, Type>): void;
+    processBatch<Type extends TaskTypes<Definitions>>({ batchSize, concurrency, cancellationSignal, types, forceDequeue }: {
         batchSize?: number;
         concurrency?: number;
         cancellationSignal: CancellationSignal;
-        types?: string[];
+        types?: Type[];
         forceDequeue?: boolean;
-    }, handler: ProcessBatchWorker<Data, State, Result>): void;
+    }, handler: ProcessBatchWorker<Definitions, Type>): void;
     private processWorker;
     private processBatchWorker;
 }
-export {};

package/task-queue/task-queue.js

@@ -9,26 +9,26 @@ import { isDefined, isString } from '../utils/type-guards.js';
 import { millisecondsPerDay, millisecondsPerMinute, millisecondsPerSecond } from '../utils/units.js';
 import { TaskQueueEnqueueBatch } from './enqueue-batch.js';
 import { BatchTaskContext } from './task-context.js';
-export class TaskResult {
+export class TaskProcessResult {
     payload;
     constructor(payload) {
         this.payload = payload;
     }
     static Complete(result) {
-        return new TaskResult({ action: 'complete', result });
+        return new TaskProcessResult({ action: 'complete', result });
     }
     static Fail(error, fatal = false) {
-        return new TaskResult({ action: 'fail', error, fatal });
+        return new TaskProcessResult({ action: 'fail', error, fatal });
     }
     static RescheduleTo(timestamp) {
-        return new TaskResult({ action: 'reschedule', timestamp });
+        return new TaskProcessResult({ action: 'reschedule', timestamp });
     }
     static RescheduleBy(milliseconds) {
         const timestamp = currentTimestamp() + milliseconds;
         return this.RescheduleTo(timestamp);
     }
 }
-export const TaskState = defineEnum('TaskState', {
+export const TaskStatus = defineEnum('TaskStatus', {
     /**
      * The task is waiting to be processed.
      */
@@ -152,7 +152,7 @@ export class TaskQueue extends Transactional {
                         const result = results[i];
                         switch (result.payload.action) {
                             case 'complete':
-                                completions.push({ task, result: result.payload });
+                                completions.push({ task, result: result.payload.result });
                                 break;
                             case 'fail':
                                 failures.push({ task, error: result.payload.error, fatal: result.payload.fatal });
@@ -166,12 +166,12 @@ export class TaskQueue extends Transactional {
                     }
                     if (completions.length > 0) {
                         context.logger.verbose(`Completing ${completions.length} tasks`);
-                        await this.completeMany(completions.map((c) => c.task), completions.map((c) => c.result));
+                        await this.completeMany(completions.map((c) => c.task), { results: completions.map((c) => c.result) });
                     }
                     if (failures.length > 0) {
                         context.logger.verbose(`Failing ${failures.length} tasks`);
                         for (const item of failures) {
-                            await this.fail(item.task, item.error, item.fatal);
+                            await this.fail(item.task, item.error, { fatal: item.fatal });
                         }
                     }
                     if (reschedules.length > 0) {

package/task-queue/tests/complex.test.js

@@ -1,5 +1,5 @@
 import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it } from 'vitest';
-import { DependencyJoinMode, TaskQueueProvider, TaskState } from '../../task-queue/index.js';
+import { DependencyJoinMode, TaskQueueProvider, TaskStatus } from '../../task-queue/index.js';
 import { setupIntegrationTest } from '../../unit-test/index.js';
 import { currentTimestamp } from '../../utils/date-time.js';
 import { timeout } from '../../utils/timing.js';
@@ -50,15 +50,15 @@ describe('Complex Queue Scenarios', () => {
             const taskC = await queue.enqueue('C', {}, { tags: ['tag-c'], scheduleAfterTags: ['tag-a'] });
             // A runs first
             const taskA = await queue.enqueue('A', {}, { tags: ['tag-a'] });
-            expect(taskD.status).toBe(TaskState.Waiting);
-            expect(taskB.status).toBe(TaskState.Waiting);
-            expect(taskC.status).toBe(TaskState.Waiting);
-            expect(taskA.status).toBe(TaskState.Pending);
+            expect(taskD.status).toBe(TaskStatus.Waiting);
+            expect(taskB.status).toBe(TaskStatus.Waiting);
+            expect(taskC.status).toBe(TaskStatus.Waiting);
+            expect(taskA.status).toBe(TaskStatus.Pending);
             // Process A
             const dA = await queue.dequeue({ types: ['A'] });
             await queue.complete(dA);
-            await waitForStatus(taskB.id, TaskState.Pending);
-            await waitForStatus(taskC.id, TaskState.Pending);
+            await waitForStatus(taskB.id, TaskStatus.Pending);
+            await waitForStatus(taskC.id, TaskStatus.Pending);
             // Process B
             const dB = await queue.dequeue({ types: ['B'] });
             await queue.complete(dB);
@@ -66,14 +66,14 @@ describe('Complex Queue Scenarios', () => {
             await queue.processPendingFanIn();
             // D still waiting (needs C)
             const uD2 = await queue.getTask(taskD.id);
-            expect(uD2?.status).toBe(TaskState.Waiting);
+            expect(uD2?.status).toBe(TaskStatus.Waiting);
             // Process C
             const dC = await queue.dequeue({ types: ['C'] });
             await queue.complete(dC);
-            await waitForStatus(taskD.id, TaskState.Pending);
+            await waitForStatus(taskD.id, TaskStatus.Pending);
             // D should be Pending
             const uD3 = await queue.getTask(taskD.id);
-            expect(uD3?.status).toBe(TaskState.Pending);
+            expect(uD3?.status).toBe(TaskStatus.Pending);
         });
         it('should handle Deep Chain (A -> B -> C -> D)', async () => {
             const D = await queue.enqueue('D', {}, { scheduleAfterTags: ['C'] });
@@ -82,14 +82,14 @@ describe('Complex Queue Scenarios', () => {
             const A = await queue.enqueue('A', {}, { tags: ['A'] });
             // Run A
             await queue.complete((await queue.dequeue({ types: ['A'] })));
-            await waitForStatus(B.id, TaskState.Pending);
+            await waitForStatus(B.id, TaskStatus.Pending);
             // Run B
             await queue.complete((await queue.dequeue({ types: ['B'] })));
-            await waitForStatus(C.id, TaskState.Pending);
+            await waitForStatus(C.id, TaskStatus.Pending);
             // Run C
             await queue.complete((await queue.dequeue({ types: ['C'] })));
-            await waitForStatus(D.id, TaskState.Pending);
-            expect((await queue.getTask(D.id))?.status).toBe(TaskState.Pending);
+            await waitForStatus(D.id, TaskStatus.Pending);
+            expect((await queue.getTask(D.id))?.status).toBe(TaskStatus.Pending);
         });
         it('should propagate cancellation down the dependency tree', async () => {
             // Use parentId for explicit tree structure which `cancel` supports
@@ -97,9 +97,9 @@ describe('Complex Queue Scenarios', () => {
             const child = await queue.enqueue('child', {}, { parentId: root.id });
             const grandChild = await queue.enqueue('grand', {}, { parentId: child.id });
             await queue.cancel(root.id);
-            expect((await queue.getTask(root.id))?.status).toBe(TaskState.Cancelled);
-            expect((await queue.getTask(child.id))?.status).toBe(TaskState.Cancelled);
-            expect((await queue.getTask(grandChild.id))?.status).toBe(TaskState.Cancelled);
+            expect((await queue.getTask(root.id))?.status).toBe(TaskStatus.Cancelled);
+            expect((await queue.getTask(child.id))?.status).toBe(TaskStatus.Cancelled);
+            expect((await queue.getTask(grandChild.id))?.status).toBe(TaskStatus.Cancelled);
         });
     });
     describe('Scheduling & Priorities', () => {
@@ -129,7 +129,7 @@ describe('Complex Queue Scenarios', () => {
             const u2 = await queue.getTask(task.id);
             expect(u2?.tries).toBe(2);
             const now = currentTimestamp();
-            expect(u2.scheduleTimestamp).toBeGreaterThan(now + 300);
+            expect(u2.scheduleTimestamp > now + 300).toBe(true);
         });
     });
     describe('Rate Limiting & Concurrency', () => {
@@ -177,15 +177,15 @@ describe('Complex Queue Scenarios', () => {
             // Verify it is in main table
             const before = await archiveQueue.getTask(task.id);
             expect(before).toBeDefined();
-            expect(before?.status).toBe(TaskState.Completed);
-            expect(before?.completeTimestamp).toBeGreaterThan(0);
+            expect(before?.status).toBe(TaskStatus.Completed);
+            expect(before.completeTimestamp > 0).toBe(true);
             // Wait for retention (100ms).
             await timeout(500);
             await archiveQueue.maintenance();
             // Should move from main table to archive
             const loaded = await archiveQueue.getTask(task.id);
             expect(loaded).toBeDefined();
-            expect(loaded?.status).toBe(TaskState.Completed);
+            expect(loaded?.status).toBe(TaskStatus.Completed);
             await archiveQueue.clear();
         });
         it('should prune expired pending tasks', async () => {
@@ -194,8 +194,8 @@ describe('Complex Queue Scenarios', () => {
             await timeout(150);
             await queue.maintenance();
             const updated = await queue.getTask(task.id);
-            expect(updated?.status).toBe(TaskState.Dead);
-            expect(updated?.error?.code).toBe('Expired');
+            expect(updated?.status).toBe(TaskStatus.Dead);
+            expect((updated?.error)['code']).toBe('Expired');
         });
         it('should retrieve task from archive', async () => {
             // Manually insert into archive? We can't access archiveRepository directly.
@@ -211,7 +211,7 @@ describe('Complex Queue Scenarios', () => {
             // Verify retrieval
             const fromArchive = await queue.getTask(task.id);
             expect(fromArchive).toBeDefined();
-            expect(fromArchive?.status).toBe(TaskState.Completed);
+            expect(fromArchive?.status).toBe(TaskStatus.Completed);
         });
         it('should defer archival of parent tasks until children are archived', async () => {
             const qProvider = injector.resolve(TaskQueueProvider);
@@ -267,7 +267,7 @@ describe('Complex Queue Scenarios', () => {
             expect(t1.id).toBe(t2.id); // Deduplicated
             const t3 = await queue.enqueue('t', { v: 3 }, { idempotencyKey: key, replace: true });
             expect(t3.id).not.toBe(t1.id); // Replaced
-            expect(t3.data.v).toBe(3);
+            expect(t3.data['v']).toBe(3);
         });
     });
     describe('Edge Cases', () => {
@@ -277,8 +277,15 @@ describe('Complex Queue Scenarios', () => {
             const d = await queue.dequeue({ types: ['pre'] });
             await queue.fail(d, new Error('fail'));
             await queue.processPendingFanIn();
-            const u = await queue.getTask(dependent.id);
-            expect(u?.status).toBe(TaskState.Waiting); // Should still be waiting because dependency didn't Complete
+            // Retry check because fan-in might be processed by background worker asynchronously
+            let u = await queue.getTask(dependent.id);
+            for (let i = 0; i < 5; i++) {
+                if (u?.status == TaskStatus.Waiting)
+                    break;
+                await timeout(50);
+                u = await queue.getTask(dependent.id);
+            }
+            expect(u?.status).toBe(TaskStatus.Waiting); // Should still be waiting because dependency didn't Complete
         });
         it('should handle mixed AND/OR dependencies', async () => {
             const dep = await queue.enqueue('dep', {}, {
@@ -287,8 +294,8 @@ describe('Complex Queue Scenarios', () => {
             });
             const A = await queue.enqueue('A', {}, { tags: ['A'] });
             await queue.complete((await queue.dequeue({ types: ['A'] })));
-            await waitForStatus(dep.id, TaskState.Pending);
-            expect((await queue.getTask(dep.id))?.status).toBe(TaskState.Pending);
+            await waitForStatus(dep.id, TaskStatus.Pending);
+            expect((await queue.getTask(dep.id))?.status).toBe(TaskStatus.Pending);
         });
         it('should not reschedule if task is not running', async () => {
             const task = await queue.enqueue('t', {});