@tstdl/base 0.93.140 → 0.93.142

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

@@ -0,0 +1,395 @@
+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-${crypto.randomUUID()}`;
+        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 }, () => 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 }, () => 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 touchMany to throw once
+        const originalTouchMany = queue.touchMany.bind(queue);
+        let thrown = false;
+        vi.spyOn(queue, 'touchMany').mockImplementation(async (t, o) => {
+            if (!thrown) {
+                thrown = true;
+                throw new Error('touch error');
+            }
+            return originalTouchMany(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 touchMany to return empty array (stolen/lost)
+        vi.spyOn(queue, 'touchMany').mockResolvedValue([]);
+        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 queue.enqueue('t1', {});
+        await queue.maintenance();
+        const count = await queue.count({ status: TaskStatus.Pending });
+        expect(count).toBe(1);
+    });
+    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: crypto.randomUUID(), token: crypto.randomUUID() };
+        // Should not throw and should not affect existing tasks
+        await queue.enqueue('t1', {});
+        await queue.complete(fakeTask);
+        const count = await queue.count();
+        expect(count).toBe(1);
+    });
+    it('should handle dequeueMany with forceDequeue', async () => {
+        await queue.enqueue('force', {});
+        const tasks = await queue.dequeueMany(1, { forceDequeue: true });
+        expect(tasks).toHaveLength(1);
+        expect(tasks[0]?.status).toBe(TaskStatus.Running);
+    });
+    it('should handle cancelMany with empty ids', async () => {
+        await queue.enqueue('t1', {});
+        await queue.cancelMany([]);
+        const count = await queue.count({ status: TaskStatus.Pending });
+        expect(count).toBe(1);
+    });
+    it('should handle touch with progress and state', async () => {
+        const task = await queue.enqueue('touch-data', {});
+        const dequeued = await queue.dequeue();
+        const result = await queue.touch(dequeued, { progress: 0.7, state: { ok: true } });
+        expect(result).toBeDefined();
+        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 getTask including archived tasks', async () => {
+        const archQueue = injector.resolve(TaskQueueProvider).get(`arch-${crypto.randomUUID()}`, { 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.enqueue('t1', {});
+        await queue.maintenance();
+        const count = await queue.count({ status: TaskStatus.Pending });
+        expect(count).toBe(1);
+    });
+    it('should handle task TTL failure in maintenance', async () => {
+        // retention=0 to allow maintenance to process immediately
+        const ttlQueue = injector.resolve(TaskQueueProvider).get(`ttl-${crypto.randomUUID()}`, { 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.Expired);
+        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-${crypto.randomUUID()}`, { 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-${crypto.randomUUID()}`;
+        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-${crypto.randomUUID()}`;
+        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-${crypto.randomUUID()}`, { 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.TimedOut);
+    });
+    it('should handle enqueueMany with parentId and waitForCompletion false', async () => {
+        const parent = await queue.enqueue('p', {});
+        const tasks = await queue.enqueueMany([{ type: 'child', data: {}, parentId: parent.id, waitForCompletion: false }], { returnTasks: true });
+        expect(tasks).toHaveLength(1);
+        expect(tasks[0]?.parentId).toBe(parent.id);
+        const updatedParent = await queue.getTask(parent.id);
+        expect(updatedParent?.unresolvedCompleteDependencies).toBe(0);
+    });
+    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.Retrying);
+        expect(updated?.tries).toBe(1);
+    });
+    it('should handle failMany reaching max tries (Dead state)', async () => {
+        const isolatedQueue = injector.resolve(TaskQueueProvider).get(`exhaust-${crypto.randomUUID()}`, { 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-${crypto.randomUUID()}`;
+        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-${crypto.randomUUID()}`, { 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,150 @@
+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();
+    });
+    describe('TaskContext', () => {
+        it('should correctly report basic properties', async () => {
+            const queue = queueProvider.get(`context-prop-${crypto.randomUUID()}`);
+            const task = await queue.enqueue('test', { foo: 'bar' }, { tags: ['tag1'], priority: 500 });
+            const context = new TaskContext(queue, task, new CancellationToken(), injector.resolve(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);
+        });
+        it('should spawn children for other queues', async () => {
+            const queue = queueProvider.get(`context-spawn-${crypto.randomUUID()}`);
+            const otherQueue = queueProvider.get(`other-spawn-${crypto.randomUUID()}`);
+            const task = await queue.enqueue('parent', {});
+            const context = new TaskContext(queue, task, new CancellationToken(), injector.resolve(Logger));
+            const spawned = await context.spawn(otherQueue, 'spawned', { x: 1 });
+            expect(spawned.type).toBe('spawned');
+            expect(spawned.parentId).toBe(task.id);
+            expect(spawned.namespace).toBe(otherQueue.namespace);
+            const spawnedMany = await context.spawnMany(otherQueue, [{ type: 'm1', data: {} }, { type: 'm2', data: {} }]);
+            expect(spawnedMany).toHaveLength(2);
+            expect(spawnedMany.every(s => s.parentId == task.id)).toBe(true);
+        });
+        it('should handle checkpoint and reschedule', async () => {
+            const queue = queueProvider.get(`context-flow-${crypto.randomUUID()}`);
+            const task = await queue.enqueue('test', {});
+            const dTask = await queue.dequeue();
+            const context = new TaskContext(queue, dTask, new CancellationToken(), injector.resolve(Logger));
+            await context.checkpoint({ progress: 0.5, state: { step: 1 } });
+            const midTask = await queue.getTask(task.id);
+            expect(midTask?.progress).toBe(0.5);
+            expect(midTask?.state).toEqual({ step: 1 });
+            await context.reschedule({ delay: 10000 });
+            const finalTask = await queue.getTask(task.id);
+            expect(finalTask?.status).toBe(TaskStatus.Pending);
+        });
+        it('should handle checkpoint lease loss', async () => {
+            const queue = queueProvider.get(`checkpoint-loss-${crypto.randomUUID()}`);
+            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 context = new TaskContext(queue, dTask, signal, injector.resolve(Logger));
+            await context.checkpoint({ progress: 0.9 });
+            expect(signal.isSet).toBe(true);
+        });
+    });
+    describe('TaskQueue Utilities', () => {
+        it('should check for task existence', async () => {
+            const queue = queueProvider.get(`has-test-${crypto.randomUUID()}`);
+            expect(await queue.has(crypto.randomUUID())).toBe(false);
+            const t = await queue.enqueue('t', {});
+            expect(await queue.has(t.id)).toBe(true);
+        });
+        it('should count and retrieve tasks by tags', async () => {
+            const queue = queueProvider.get(`tags-test-${crypto.randomUUID()}`);
+            await queue.enqueue('t1', {}, { tags: ['tag1'] });
+            await queue.enqueue('t2', {}, { tags: ['tag1', 'tag2'] });
+            expect(await queue.countByTags(['tag1'])).toBe(2);
+            expect(await queue.countByTags(['tag2'])).toBe(1);
+            const tagged = await queue.getManyByTags(['tag2']);
+            expect(tagged).toHaveLength(1);
+            expect(tagged[0]?.type).toBe('t2');
+        });
+        it('should clear all tasks in namespace', async () => {
+            const queue = queueProvider.get(`clear-test-${crypto.randomUUID()}`);
+            await queue.enqueue('t', {});
+            await queue.clear();
+            expect(await queue.count()).toBe(0);
+        });
+        it('should load task from archive in getTask', async () => {
+            const archiveQueue = queueProvider.get(`archive-test-${crypto.randomUUID()}`, { 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?.status).toBe(TaskStatus.Completed);
+        });
+        it('should handle batch touch and fail', async () => {
+            const isolatedQueue = queueProvider.get(`batch-util-${crypto.randomUUID()}`);
+            const t1 = await isolatedQueue.enqueue('t1', {});
+            const t2 = await isolatedQueue.enqueue('t2', {});
+            const dTasks = await isolatedQueue.dequeueMany(2);
+            const touched = await isolatedQueue.touchMany(dTasks, { progresses: [0.5, 0.8] });
+            expect(touched).toHaveLength(2);
+            await isolatedQueue.failMany(dTasks, [new Error('e1'), new Error('e2')]);
+            const u1 = await isolatedQueue.getTask(t1.id);
+            expect(u1?.status).toBe(TaskStatus.Retrying);
+            expect(u1?.tries).toBe(1);
+        });
+        it('should handle idempotency collisions in enqueueMany', async () => {
+            const queue = queueProvider.get(`idem-coll-${crypto.randomUUID()}`);
+            const key = `key-${crypto.randomUUID()}`;
+            await queue.enqueue('t1', { val: 1 }, { idempotencyKey: key });
+            const tasks = await queue.enqueueMany([
+                { type: 't1', data: { val: 2 }, idempotencyKey: key },
+                { type: 't2', data: { val: 3 } },
+            ], { returnTasks: true });
+            expect(tasks).toHaveLength(2);
+            expect(tasks.find(t => t.idempotencyKey == key)?.data).toEqual({ val: 1 });
+        });
+        it('should purge archive in maintenance', async () => {
+            const purgeQueue = queueProvider.get(`purge-test-${crypto.randomUUID()}`, { 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();
+            const purgedTask = await purgeQueue.getTask(task.id);
+            expect(purgedTask).toBeUndefined();
+        });
+    });
+});

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

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