@tstdl/base 0.93.139 → 0.93.141

package/task-queue/tests/coverage-branch.test.js

@@ -0,0 +1,407 @@
+import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it, vi } from 'vitest';
+import { CancellationToken } from '../../cancellation/index.js';
+import { CircuitBreaker, CircuitBreakerState } from '../../circuit-breaker/index.js';
+import { runInInjectionContext } from '../../injector/index.js';
+import { injectRepository } from '../../orm/server/index.js';
+import { TaskProcessResult, TaskQueueProvider, TaskStatus } from '../../task-queue/index.js';
+import { PostgresTask } from '../../task-queue/postgres/index.js';
+import { setupIntegrationTest } from '../../testing/index.js';
+import { currentTimestamp } from '../../utils/date-time.js';
+import { timeout } from '../../utils/timing.js';
+describe('Task Queue Branch Coverage Enhancement', () => {
+    let injector;
+    let queue;
+    let token;
+    beforeAll(async () => {
+        ({ injector } = await setupIntegrationTest({ modules: { taskQueue: true } }));
+    });
+    beforeEach(() => {
+        const queueProvider = injector.resolve(TaskQueueProvider);
+        const queueName = `branch-coverage-queue-${Date.now()}-${Math.random()}`;
+        queue = queueProvider.get(queueName, {
+            visibilityTimeout: 200,
+        });
+        token = new CancellationToken();
+    });
+    afterEach(async () => {
+        token.set();
+        await queue.clear();
+    });
+    afterAll(async () => {
+        await injector?.dispose();
+    });
+    it('should handle TaskProcessResult.RescheduleTo in worker', async () => {
+        const task = await queue.enqueue('reschedule-test', {});
+        const future = currentTimestamp() + 5000;
+        queue.process({ cancellationSignal: token }, async () => {
+            return TaskProcessResult.RescheduleTo(future);
+        });
+        await timeout(500);
+        token.set();
+        const updated = await queue.getTask(task.id);
+        expect(updated?.status).toBe(TaskStatus.Pending);
+        expect(updated?.scheduleTimestamp).toBe(future);
+    });
+    it('should handle TaskProcessResult.Fail(fatal: true) in worker', async () => {
+        const task = await queue.enqueue('fail-fatal-test', {});
+        queue.process({ cancellationSignal: token }, async () => {
+            return TaskProcessResult.Fail(new Error('fatal error'), true);
+        });
+        await timeout(500);
+        token.set();
+        const updated = await queue.getTask(task.id);
+        expect(updated?.status).toBe(TaskStatus.Dead);
+    });
+    it('should handle errors in touch during background lease extension', async () => {
+        const task = await queue.enqueue('touch-error-test', {});
+        // Mock touch to throw once
+        const originalTouch = queue.touch.bind(queue);
+        let thrown = false;
+        vi.spyOn(queue, 'touch').mockImplementation(async (t, o) => {
+            if (!thrown) {
+                thrown = true;
+                throw new Error('touch error');
+            }
+            return originalTouch(t, o);
+        });
+        queue.process({ cancellationSignal: token }, async () => {
+            await timeout(300); // Wait for background touch to trigger
+            return TaskProcessResult.Complete();
+        });
+        await timeout(600);
+        token.set();
+        const updated = await queue.getTask(task.id);
+        expect(updated?.status).toBe(TaskStatus.Completed);
+        expect(thrown).toBe(true);
+    });
+    it('should handle background lease loss during processing', async () => {
+        // visibilityTimeout is 200ms. Background touch is every 100ms.
+        const task = await queue.enqueue('lease-loss-test', {});
+        let workerFinished = false;
+        // Mock touch to return undefined (stolen/lost)
+        vi.spyOn(queue, 'touch').mockResolvedValue(undefined);
+        queue.process({ cancellationSignal: token }, async (context) => {
+            // Wait for background touch to discover lease loss
+            for (let i = 0; i < 20; i++) {
+                if (context.signal.isSet)
+                    break;
+                await timeout(50);
+            }
+            workerFinished = true;
+            return TaskProcessResult.Complete();
+        });
+        await timeout(500);
+        token.set();
+        expect(workerFinished).toBe(true);
+    });
+    it('should handle enqueueMany with empty items', async () => {
+        const result = await queue.enqueueMany([], { returnTasks: true });
+        expect(result).toEqual([]);
+        const result2 = await queue.enqueueMany([]);
+        expect(result2).toBeUndefined();
+    });
+    it('should handle getTask with non-existent id', async () => {
+        const task = await queue.getTask('00000000-0000-0000-0000-000000000000');
+        expect(task).toBeUndefined();
+    });
+    it('should handle dequeue with specific types', async () => {
+        await queue.enqueue('type1', { val: 1 });
+        await queue.enqueue('type2', { val: 2 });
+        const d1 = await queue.dequeue({ types: ['type2'] });
+        expect(d1?.type).toBe('type2');
+        const d2 = await queue.dequeue({ types: ['type1'] });
+        expect(d2?.type).toBe('type1');
+    });
+    it('should handle maintenance when no tasks need maintenance', async () => {
+        await expect(queue.maintenance()).resolves.toBeUndefined();
+    });
+    it('should handle multiple workers competing for tasks', async () => {
+        await queue.enqueue('compete', {});
+        // Dequeue in one worker
+        const d1 = await queue.dequeue();
+        expect(d1).toBeDefined();
+        // Try to dequeue again - should be empty because it is locked
+        const d2 = await queue.dequeue();
+        expect(d2).toBeUndefined();
+    });
+    it('should handle reschedule by milliseconds', async () => {
+        const task = await queue.enqueue('reschedule-by', {});
+        const dequeued = await queue.dequeue();
+        const future = currentTimestamp() + 5000;
+        await queue.reschedule(dequeued.id, future);
+        const updated = await queue.getTask(task.id);
+        expect(updated?.scheduleTimestamp).toBe(future);
+    });
+    it('should handle touch with no tasks', async () => {
+        const result = await queue.touchMany([]);
+        expect(result).toEqual([]);
+    });
+    it('should handle touch with no task token', async () => {
+        const task = await queue.enqueue('no-token', {});
+        // Task is Pending, token is null
+        const result = await queue.touch(task);
+        expect(result).toBeUndefined();
+    });
+    it('should handle complete with non-existent task', async () => {
+        const fakeTask = { id: '00000000-0000-0000-0000-000000000000', token: '00000000-0000-0000-0000-000000000000' };
+        // Should not throw
+        await queue.complete(fakeTask);
+    });
+    it('should handle dequeueMany with forceDequeue', async () => {
+        await queue.enqueue('force', {});
+        const tasks = await queue.dequeueMany(1, { forceDequeue: true });
+        expect(tasks).toHaveLength(1);
+    });
+    it('should handle dequeueMany with globalConcurrency limit', async () => {
+        const limitedQueue = injector.resolve(TaskQueueProvider).get(`limited-${Date.now()}`, { globalConcurrency: 1 });
+        await limitedQueue.enqueue('t1', {});
+        await limitedQueue.enqueue('t2', {});
+        const d1 = await limitedQueue.dequeue();
+        expect(d1).toBeDefined();
+        const d2 = await limitedQueue.dequeue();
+        expect(d2).toBeUndefined(); // Limited by globalConcurrency
+    });
+    it('should handle waitForTasks timeout', async () => {
+        const task = await queue.enqueue('wait-timeout', {});
+        await expect(queue.waitForTasks([task.id], { timeout: 100, interval: 50 })).rejects.toThrow('Timeout');
+    });
+    it('should handle cancelMany with empty ids', async () => {
+        // Should not throw
+        await queue.cancelMany([]);
+    });
+    it('should handle touch with progress and state', async () => {
+        const task = await queue.enqueue('touch-data', {});
+        const dequeued = await queue.dequeue();
+        await queue.touch(dequeued, { progress: 0.7, state: { ok: true } });
+        const updated = await queue.getTask(task.id);
+        expect(updated?.progress).toBe(0.7);
+        expect(updated?.state).toEqual({ ok: true });
+    });
+    it('should handle touchMany with multiple tasks', async () => {
+        const t1 = await queue.enqueue('tm1', {});
+        const t2 = await queue.enqueue('tm2', {});
+        const d1 = await queue.dequeue();
+        const d2 = await queue.dequeue();
+        const result = await queue.touchMany([d1, d2], { progresses: [0.1, 0.2] });
+        expect(result).toHaveLength(2);
+    });
+    it('should handle enqueue with only completeAfter (isWaiting=false in DB, but has dependencies)', async () => {
+        // line 116 in pg task-queue: const isWaiting = scheduleAfterCount > 0;
+        // status: isWaiting ? TaskStatus.Waiting : TaskStatus.Pending
+        const prereq = await queue.enqueue('p', {});
+        const dependent = await queue.enqueue('d', {}, { completeAfter: [prereq.id] });
+        expect(dependent.status).toBe(TaskStatus.Pending); // Because scheduleAfterCount is 0
+        expect(dependent.unresolvedCompleteDependencies).toBe(1);
+    });
+    it('should handle maintenance recovering zombie tasks', async () => {
+        const isolatedQueue = injector.resolve(TaskQueueProvider).get(`zombie-${Date.now()}`, { visibilityTimeout: 100 });
+        await isolatedQueue.enqueue('z', {});
+        const d1 = await isolatedQueue.dequeue();
+        expect(d1).toBeDefined();
+        // Wait for visibility timeout to expire
+        await timeout(200);
+        await isolatedQueue.maintenance();
+        const updated = await isolatedQueue.getTask(d1.id);
+        expect(updated?.status).toBe(TaskStatus.Pending);
+        expect(updated?.token).toBeNull();
+    });
+    it('should handle getTask including archived tasks', async () => {
+        const archQueue = injector.resolve(TaskQueueProvider).get(`arch-${Date.now()}`, { retention: 0, archiveRetention: 3600000 });
+        const t = await archQueue.enqueue('t', {});
+        const d = await archQueue.dequeue();
+        await archQueue.complete(d);
+        await timeout(50);
+        await archQueue.maintenance(); // Should archive
+        const archived = await archQueue.getTask(t.id);
+        expect(archived).toBeDefined();
+        expect(archived?.id).toBe(t.id);
+    });
+    it('should handle maintenance with no work to do', async () => {
+        await queue.maintenance(); // Should not throw
+    });
+    it('should handle task TTL failure in maintenance', async () => {
+        // retention=0 to allow maintenance to process immediately
+        const ttlQueue = injector.resolve(TaskQueueProvider).get(`ttl-${Date.now()}`, { retention: 0 });
+        // Enqueue with TTL in the past
+        const task = await ttlQueue.enqueue('ttl-fail', {}, { timeToLive: currentTimestamp() - 1000 });
+        await timeout(100);
+        await ttlQueue.maintenance();
+        const updated = await ttlQueue.getTask(task.id);
+        expect(updated?.status).toBe(TaskStatus.Dead);
+        expect(updated?.error?.message).toContain('Task expired');
+    });
+    it('should handle cancelMany with multiple valid IDs', async () => {
+        const t1 = await queue.enqueue('c1', {});
+        const t2 = await queue.enqueue('c2', {});
+        await queue.cancelMany([t1.id, t2.id]);
+        const u1 = await queue.getTask(t1.id);
+        const u2 = await queue.getTask(t2.id);
+        expect(u1?.status).toBe(TaskStatus.Cancelled);
+        expect(u2?.status).toBe(TaskStatus.Cancelled);
+    });
+    it('should handle pruning long expired tasks', async () => {
+        // archiveRetention = 0
+        const pruneQueue = injector.resolve(TaskQueueProvider).get(`prune-long-${Date.now()}`, { retention: 0, archiveRetention: 0 });
+        const task = await pruneQueue.enqueue('p1', {});
+        const d1 = await pruneQueue.dequeue();
+        await pruneQueue.complete(d1);
+        await timeout(100);
+        await pruneQueue.maintenance();
+        const updated = await pruneQueue.getTask(task.id);
+        expect(updated).toBeUndefined();
+    });
+    it('should handle complete with token mismatch', async () => {
+        const task = await queue.enqueue('token-mismatch', {});
+        const dequeued = await queue.dequeue();
+        // Create a fake task with wrong token
+        const fakeTask = { ...dequeued, token: '00000000-0000-0000-0000-000000000000' };
+        // Should not throw and should not complete
+        await queue.complete(fakeTask);
+        const updated = await queue.getTask(task.id);
+        expect(updated?.status).toBe(TaskStatus.Running);
+    });
+    it('should handle rescheduleManyByTags for running tasks', async () => {
+        const task = await queue.enqueue('tag-resched', {}, { tags: ['t1'] });
+        await queue.dequeue(); // Now Running
+        const future = currentTimestamp() + 10000;
+        await queue.rescheduleManyByTags('t1', future);
+        const updated = await queue.getTask(task.id);
+        expect(updated?.status).toBe(TaskStatus.Pending);
+        expect(updated?.tries).toBe(0); // Refunded
+    });
+    it('should handle dequeueMany shortfall refund', async () => {
+        // We need to trigger tasks.length < rateLimitAcquired
+        // This happens if rate limiter allows N, but only M < N are actually available/dequeuable
+        await queue.enqueue('shortfall', {});
+        // rateLimit is 5 by default in our setup.
+        // If we try to dequeue 5, but only 1 exists, it should refund 4.
+        const tasks = await queue.dequeueMany(5);
+        expect(tasks).toHaveLength(1);
+    });
+    it('should handle CircuitBreaker Half-Open state in dequeue', async () => {
+        const namespace = `cb-half-${Date.now()}`;
+        const cbQueue = injector.resolve(TaskQueueProvider).get(namespace, { circuitBreakerThreshold: 1 });
+        const cb = injector.resolve(CircuitBreaker, namespace);
+        // Mock CB to be Half-Open
+        vi.spyOn(cb, 'check').mockResolvedValue({ allowed: true, state: CircuitBreakerState.HalfOpen, isProbe: true });
+        await cbQueue.enqueue('cb', {});
+        const tasks = await cbQueue.dequeue();
+        expect(tasks).toBeDefined();
+    });
+    it('should handle CircuitBreaker Half-Open state blocking when already probing', async () => {
+        const namespace = `cb-block-${Date.now()}`;
+        const cbQueue = injector.resolve(TaskQueueProvider).get(namespace, { circuitBreakerThreshold: 1 });
+        const cb = injector.resolve(CircuitBreaker, namespace);
+        // Mock CB to be Half-Open but NOT a probe (already probing)
+        vi.spyOn(cb, 'check').mockResolvedValue({ allowed: true, state: CircuitBreakerState.HalfOpen, isProbe: false });
+        await cbQueue.enqueue('cb', {});
+        await cbQueue.enqueue('cb2', {});
+        // 1. Mock one task as already running in this namespace
+        // Actually, we can just enqueue and dequeue one normally first
+        const d1 = await cbQueue.dequeue({ forceDequeue: true });
+        expect(d1).toBeDefined();
+        // 2. Now the "normal" dequeue should see a running task and block because it's half-open and not a probe
+        const d2 = await cbQueue.dequeue();
+        expect(d2).toBeUndefined();
+    });
+    it('should handle complete when task has active children', async () => {
+        const parent = await queue.enqueue('parent', {});
+        await queue.enqueue('child', {}, { parentId: parent.id });
+        const dParent = await queue.dequeue();
+        await queue.complete(dParent);
+        const updated = await queue.getTask(parent.id);
+        expect(updated?.status).toBe(TaskStatus.WaitingChildren);
+    });
+    it('should handle maintenance recovering zombie tasks via touchMany logic in prune', async () => {
+        const pruneQueue = injector.resolve(TaskQueueProvider).get(`prune-fail-${Date.now()}`, { maxExecutionTime: 50, retention: 0 });
+        const task = await pruneQueue.enqueue('p1', {});
+        await pruneQueue.dequeue();
+        await timeout(100);
+        await pruneQueue.maintenance();
+        const updated = await pruneQueue.getTask(task.id);
+        expect(updated?.status).toBe(TaskStatus.Dead);
+    });
+    it('should handle enqueueMany with parentId and waitForCompletion false', async () => {
+        const parent = await queue.enqueue('p', {});
+        await queue.enqueueMany([{ type: 'child', data: {}, parentId: parent.id, waitForCompletion: false }]);
+    });
+    it('should handle failMany for running tasks', async () => {
+        const t1 = await queue.enqueue('t1', {});
+        const d1 = await queue.dequeue();
+        await queue.failMany([d1], [new Error('fail')]);
+        const updated = await queue.getTask(t1.id);
+        expect(updated?.status).toBe(TaskStatus.Pending);
+        expect(updated?.tries).toBe(1);
+    });
+    it('should handle failMany reaching max tries (Dead state)', async () => {
+        const isolatedQueue = injector.resolve(TaskQueueProvider).get(`exhaust-${Date.now()}`, { maxTries: 1 });
+        const t1 = await isolatedQueue.enqueue('t1', {});
+        const d1 = await isolatedQueue.dequeue();
+        await isolatedQueue.failMany([d1], [new Error('fatal')]);
+        const updated = await isolatedQueue.getTask(t1.id);
+        expect(updated?.status).toBe(TaskStatus.Dead);
+    });
+    it('should handle rescheduleMany with mixed statuses', async () => {
+        const t1 = await queue.enqueue('t1', {}); // Pending
+        const t2 = await queue.enqueue('t2', {});
+        await queue.dequeue(); // t2 is now Running
+        const future = currentTimestamp() + 10000;
+        await queue.rescheduleMany([t1.id, t2.id], future);
+        const u1 = await queue.getTask(t1.id);
+        const u2 = await queue.getTask(t2.id);
+        expect(u1?.status).toBe(TaskStatus.Pending);
+        expect(u1?.tries).toBe(0);
+        expect(u2?.status).toBe(TaskStatus.Pending);
+        expect(u2?.tries).toBe(0); // Refunded because it was Running
+    });
+    it('should handle restart with resetState', async () => {
+        const task = await queue.enqueue('t', { initial: 1 });
+        // Keep it Pending
+        await queue.restart(task.id, { resetState: true });
+        const updated = await queue.getTask(task.id);
+        expect(updated?.status).toBe(TaskStatus.Pending);
+        expect(updated?.state).toBeNull();
+    });
+    it('should handle clear with active tasks', async () => {
+        const t = await queue.enqueue('t', {});
+        await queue.clear();
+        expect(await queue.has(t.id)).toBe(false);
+    });
+    it('should handle countByTags with tags', async () => {
+        await queue.enqueue('t', {}, { tags: ['tag1', 'tag2'] });
+        expect(await queue.countByTags(['tag1'])).toBe(1);
+        expect(await queue.countByTags(['tag3'])).toBe(0);
+    });
+    it('should handle rescheduleManyByTags with mixed statuses', async () => {
+        const t1 = await queue.enqueue('t1', {}, { tags: ['tag-m'] });
+        const t2 = await queue.enqueue('t2', {}, { tags: ['tag-m'] });
+        await queue.dequeue(); // one is running
+        await queue.rescheduleManyByTags('tag-m', currentTimestamp() + 5000);
+        const u1 = await queue.getTask(t1.id);
+        const u2 = await queue.getTask(t2.id);
+        expect(u1?.tries).toBe(0);
+        expect(u2?.tries).toBe(0);
+    });
+    it('should handle touchMany with mismatched status/token', async () => {
+        const t1 = await queue.enqueue('t1', {});
+        const d1 = await queue.dequeue();
+        // Wrong token
+        const result = await queue.touchMany([{ ...d1, token: '00000000-0000-0000-0000-000000000000' }]);
+        expect(result).toHaveLength(0);
+    });
+    it('should handle large batch maintenance (> 1000 tasks)', async () => {
+        const namespace = `aging-batch-${Date.now()}`;
+        const agingQueue = injector.resolve(TaskQueueProvider).get(namespace, { priorityAgingInterval: 60000, priorityAgingStep: 1 });
+        const items = Array.from({ length: 1001 }, (_, i) => ({ type: 'batch', data: { i } }));
+        await agingQueue.enqueueMany(items);
+        // Manually push timestamps into the past to qualify for aging without waiting
+        const repository = runInInjectionContext(injector, () => injectRepository(PostgresTask));
+        const twoMinutesAgo = currentTimestamp() - 120000;
+        await repository.updateManyByQuery({ namespace }, { priorityAgeTimestamp: twoMinutesAgo });
+        await agingQueue.maintenance();
+    });
+    it('should handle maintenance with empty archive and active tables', async () => {
+        const emptyQueue = injector.resolve(TaskQueueProvider).get(`empty-${Date.now()}`, { retention: 0, archiveRetention: 0 });
+        await emptyQueue.maintenance();
+    });
+});

package/task-queue/tests/coverage-enhancement.test.d.ts

@@ -0,0 +1 @@
+export {};

package/task-queue/tests/coverage-enhancement.test.js

@@ -0,0 +1,144 @@
+import { eq } from 'drizzle-orm';
+import { afterAll, beforeAll, describe, expect, it } from 'vitest';
+import { CancellationToken } from '../../cancellation/index.js';
+import { runInInjectionContext } from '../../injector/index.js';
+import { Logger } from '../../logger/index.js';
+import { RANDOM_UUID_V4 } from '../../orm/index.js';
+import { injectRepository } from '../../orm/server/index.js';
+import { TaskQueueProvider, TaskStatus } from '../../task-queue/index.js';
+import { task as taskTable } from '../../task-queue/postgres/schemas.js';
+import { PostgresTask } from '../../task-queue/postgres/task.model.js';
+import { TaskContext } from '../../task-queue/task-context.js';
+import { setupIntegrationTest } from '../../testing/index.js';
+import { timeout } from '../../utils/timing.js';
+describe('Task Queue Coverage Enhancement', () => {
+    let injector;
+    let queueProvider;
+    beforeAll(async () => {
+        ({ injector } = await setupIntegrationTest({ modules: { taskQueue: true } }));
+        queueProvider = injector.resolve(TaskQueueProvider);
+    });
+    afterAll(async () => {
+        await injector?.dispose();
+    });
+    it('should exercise TaskContext getters and methods', async () => {
+        const queue = queueProvider.get(`context-test-${Date.now()}-${Math.random()}`);
+        const task = await queue.enqueue('test', { foo: 'bar' }, { tags: ['tag1'], priority: 500 });
+        const signal = new CancellationToken();
+        const logger = injector.resolve(Logger);
+        const context = new TaskContext(queue, task, signal, logger);
+        expect(context.id).toBe(task.id);
+        expect(context.type).toBe('test');
+        expect(context.parentId).toBeNull();
+        expect(context.tags).toContain('tag1');
+        expect(context.unresolvedScheduleDependencies).toBe(0);
+        expect(context.unresolvedCompleteDependencies).toBe(0);
+        expect(context.data).toEqual({ foo: 'bar' });
+        expect(context.state).toBeNull();
+        expect(context.attempt).toBe(0);
+        expect(context.triesLeft).toBe(queue.maxTries);
+        expect(context.isFinalAttempt).toBe(false);
+        expect(context.signal).toBe(signal);
+        expect(context.logger).toBeDefined();
+        // spawn for other queue
+        const otherQueue = queueProvider.get(`other-queue-${Date.now()}-${Math.random()}`);
+        const spawned = await context.spawn(otherQueue, 'spawned', { x: 1 });
+        expect(spawned.type).toBe('spawned');
+        const spawnedMany = await context.spawnMany(otherQueue, [{ type: 'm1', data: {} }, { type: 'm2', data: {} }]);
+        expect(spawnedMany).toHaveLength(2);
+        // checkpoint
+        await context.checkpoint({ progress: 0.5 });
+        // reschedule with delay
+        await context.reschedule({ delay: 10000 });
+        const uTask = await queue.getTask(task.id);
+        expect(uTask?.status).toBe(TaskStatus.Pending);
+    });
+    it('should handle checkpoint lease loss', async () => {
+        const queue = queueProvider.get(`checkpoint-loss-${Date.now()}-${Math.random()}`);
+        const task = await queue.enqueue('t', {});
+        const dTask = await queue.dequeue();
+        // Manually break the token in DB
+        const repository = runInInjectionContext(injector, () => injectRepository(PostgresTask));
+        await repository.useTransaction(undefined, async (tx) => {
+            await tx.pgTransaction.update(taskTable).set({ token: RANDOM_UUID_V4 }).where(eq(taskTable.id, task.id));
+        });
+        const signal = new CancellationToken();
+        const logger = injector.resolve(Logger);
+        const context = new TaskContext(queue, dTask, signal, logger);
+        await context.checkpoint({ progress: 0.9 });
+        expect(signal.isSet).toBe(true);
+    });
+    it('should exercise various TaskQueue methods', async () => {
+        const queue = queueProvider.get(`methods-test-${Date.now()}-${Math.random()}`);
+        // has
+        expect(await queue.has('00000000-0000-0000-0000-000000000000')).toBe(false);
+        const t = await queue.enqueue('t', {});
+        expect(await queue.has(t.id)).toBe(true);
+        // countByTags
+        expect(await queue.countByTags([])).toBe(0);
+        expect(await queue.countByTags(['tag1'])).toBe(0);
+        await queue.enqueue('t2', {}, { tags: ['tag1'] });
+        expect(await queue.countByTags(['tag1'])).toBe(1);
+        // getManyByTags
+        expect(await queue.getManyByTags([])).toEqual([]);
+        const tagged = await queue.getManyByTags(['tag1']);
+        expect(tagged).toHaveLength(1);
+        // clear
+        await queue.clear();
+        expect(await queue.countByTags(['tag1'])).toBe(0);
+    });
+    it('should load task from archive in getTask', async () => {
+        const archiveQueue = queueProvider.get(`archive-test-${Date.now()}-${Math.random()}`, { retention: 0, archiveRetention: 3600000 });
+        const task = await archiveQueue.enqueue('t', {});
+        const dTask = await archiveQueue.dequeue();
+        await archiveQueue.complete(dTask);
+        await timeout(10);
+        await archiveQueue.maintenance();
+        const archivedTask = await archiveQueue.getTask(task.id);
+        expect(archivedTask).toBeDefined();
+        expect(archivedTask?.id).toBe(task.id);
+        expect(archivedTask?.status).toBe(TaskStatus.Completed);
+    });
+    it('should exercise touchMany and failMany', async () => {
+        const isolatedQueue = queueProvider.get(`touch-fail-queue-${Date.now()}-${Math.random()}`);
+        const t1 = await isolatedQueue.enqueue('t1', {});
+        const t2 = await isolatedQueue.enqueue('t2', {});
+        const dTasks = await isolatedQueue.dequeueMany(2);
+        expect(dTasks).toHaveLength(2);
+        const touched = await isolatedQueue.touchMany(dTasks, { progresses: [0.5, 0.8] });
+        expect(touched).toHaveLength(2);
+        expect(touched).toContain(t1.id);
+        expect(touched).toContain(t2.id);
+        await isolatedQueue.failMany(dTasks, [new Error('e1'), new Error('e2')]);
+        const u1 = await isolatedQueue.getTask(t1.id);
+        const u2 = await isolatedQueue.getTask(t2.id);
+        expect(u1?.status).toBe(TaskStatus.Pending);
+        expect(u2?.status).toBe(TaskStatus.Pending);
+        expect(u1?.tries).toBe(1);
+    });
+    it('should handle idempotency collisions in enqueueMany', async () => {
+        const queue = queueProvider.get(`idempotency-test-${Date.now()}-${Math.random()}`);
+        const key = `idempotent-${Date.now()}-${Math.random()}`;
+        await queue.enqueue('t1', { val: 1 }, { idempotencyKey: key });
+        // Enqueue again with same key, returnTasks: true
+        const tasks = await queue.enqueueMany([
+            { type: 't1', data: { val: 2 }, idempotencyKey: key },
+            { type: 't2', data: { val: 3 } }
+        ], { returnTasks: true });
+        expect(tasks).toHaveLength(2);
+        const rt1 = tasks.find((t) => t.idempotencyKey == key);
+        const rt2 = tasks.find((t) => t.idempotencyKey == null);
+        expect(rt1?.data).toEqual({ val: 1 }); // Original data preserved
+        expect(rt2?.data).toEqual({ val: 3 }); // New task created
+    });
+    it('should purge archive in maintenance', async () => {
+        const purgeQueue = queueProvider.get(`purge-test-${Date.now()}-${Math.random()}`, { retention: 0, archiveRetention: 0 });
+        const task = await purgeQueue.enqueue('t', {});
+        const dTask = await purgeQueue.dequeue();
+        await purgeQueue.complete(dTask);
+        await timeout(10);
+        await purgeQueue.maintenance(); // Should archive AND purge
+        const purgedTask = await purgeQueue.getTask(task.id);
+        expect(purgedTask).toBeUndefined();
+    });
+});

package/task-queue/tests/dag-dependencies.test.d.ts

@@ -0,0 +1 @@
+export {};

package/task-queue/tests/dag-dependencies.test.js

@@ -0,0 +1,41 @@
+import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it } from 'vitest';
+import { TaskQueueProvider, TaskStatus } from '../../task-queue/index.js';
+import { setupIntegrationTest } from '../../testing/index.js';
+describe('DAG Dependencies', () => {
+    let injector;
+    let queue;
+    beforeAll(async () => {
+        ({ injector } = await setupIntegrationTest({ modules: { taskQueue: true } }));
+    });
+    beforeEach(() => {
+        const queueProvider = injector.resolve(TaskQueueProvider);
+        const queueName = `dag-queue-${Date.now()}-${Math.random()}`;
+        queue = queueProvider.get(queueName, {
+            visibilityTimeout: 1000,
+        });
+    });
+    afterEach(async () => {
+        await queue.clear();
+    });
+    afterAll(async () => {
+        await injector?.dispose();
+    });
+    it('should schedule a task only after dependency reaches required status (scheduleAfter)', async () => {
+        const prereq = await queue.enqueue('prereq', { val: 1 });
+        const dependent = await queue.enqueue('dependent', { foo: 'bar' }, {
+            scheduleAfter: [prereq.id],
+        });
+        expect(dependent.status).toBe(TaskStatus.Waiting);
+        const dequeued = await queue.dequeue({ types: ['prereq'] });
+        expect(dequeued?.id).toBe(prereq.id);
+        await queue.complete(dequeued);
+        // Dependent should transition to Pending.
+        // Let's dequeue and complete it to make it reaches a finalized state for waitForTasks
+        const dDependent = await queue.dequeue({ types: ['dependent'] });
+        expect(dDependent?.id).toBe(dependent.id);
+        await queue.complete(dDependent);
+        await queue.waitForTasks([dependent.id]);
+        const updatedDependent = await queue.getTask(dependent.id);
+        expect(updatedDependent?.status).toBe(TaskStatus.Completed);
+    });
+});