@tstdl/base 0.93.181 → 0.93.183

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

@@ -1,188 +0,0 @@
-import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it } from 'vitest';
-import { TaskQueueProvider, TaskStatus } from '../../task-queue/index.js';
-import { setupIntegrationTest } from '../../testing/index.js';
-import { timeout } from '../../utils/timing.js';
-describe('Extensive Task Queue Dependency Tests', () => {
-    let injector;
-    let queue;
-    beforeAll(async () => {
-        ({ injector } = await setupIntegrationTest({ modules: { taskQueue: true } }));
-    });
-    beforeEach(() => {
-        const queueProvider = injector.resolve(TaskQueueProvider);
-        const queueName = `extensive-dep-queue-${crypto.randomUUID()}`;
-        queue = queueProvider.get(queueName, {
-            visibilityTimeout: 1000,
-        });
-    });
-    afterEach(async () => {
-        await queue.clear();
-    });
-    afterAll(async () => {
-        await injector?.dispose();
-    });
-    async function completeTask(type) {
-        const dequeued = await queue.dequeue({ types: [type] });
-        if (!dequeued)
-            throw new Error(`Could not dequeue task of type ${type}`);
-        await queue.complete(dequeued);
-    }
-    it('should handle complex mixed chain: A -> (B -> D, C -> E) -> F', async () => {
-        // A is the root
-        const taskA = await queue.enqueue('A', {});
-        // B and C depend on A
-        const taskB = await queue.enqueue('B', {}, { scheduleAfter: [taskA.id] });
-        const taskC = await queue.enqueue('C', {}, { scheduleAfter: [taskA.id] });
-        // D depends on B, E depends on C
-        const taskD = await queue.enqueue('D', {}, { scheduleAfter: [taskB.id] });
-        const taskE = await queue.enqueue('E', {}, { scheduleAfter: [taskC.id] });
-        // F depends on D and E
-        const taskF = await queue.enqueue('F', {}, { scheduleAfter: [taskD.id, taskE.id] });
-        expect(taskA.status).toBe(TaskStatus.Pending);
-        expect(taskB.status).toBe(TaskStatus.Waiting);
-        expect(taskC.status).toBe(TaskStatus.Waiting);
-        expect(taskD.status).toBe(TaskStatus.Waiting);
-        expect(taskE.status).toBe(TaskStatus.Waiting);
-        expect(taskF.status).toBe(TaskStatus.Waiting);
-        // 1. Complete A
-        await completeTask('A');
-        await queue.waitForTasks([taskB.id, taskC.id], { statuses: [TaskStatus.Pending] });
-        // 2. Complete B
-        await completeTask('B');
-        await queue.waitForTasks([taskD.id], { statuses: [TaskStatus.Pending] });
-        // 3. Complete C
-        await completeTask('C');
-        await queue.waitForTasks([taskE.id], { statuses: [TaskStatus.Pending] });
-        // F should still be waiting
-        const uF = await queue.getTask(taskF.id);
-        expect(uF?.status).toBe(TaskStatus.Waiting);
-        // 4. Complete D
-        await completeTask('D');
-        // F still waiting for E
-        expect((await queue.getTask(taskF.id))?.status).toBe(TaskStatus.Waiting);
-        // 5. Complete E
-        await completeTask('E');
-        await queue.waitForTasks([taskF.id], { statuses: [TaskStatus.Pending] });
-    });
-    it('should respect abortOnDependencyFailure = false (continue other branches)', async () => {
-        const taskA = await queue.enqueue('A', {});
-        const taskB = await queue.enqueue('B', {}, { scheduleAfter: [taskA.id], abortOnDependencyFailure: false });
-        const taskC = await queue.enqueue('C', {}); // Independent
-        const dA = await queue.dequeue({ types: ['A'] });
-        await queue.fail(dA, new Error('fatal'), { fatal: true });
-        // taskB should stay Waiting (default requiredStatus is Completed)
-        // If abortOnDependencyFailure is false, it should transition to Pending once the dependency is terminal, even if it failed.
-        await timeout(100);
-        const uB = await queue.getTask(taskB.id);
-        expect(uB?.status).toBe(TaskStatus.Pending);
-        const dC = await queue.dequeue({ types: ['C'] });
-        expect(dC?.id).toBe(taskC.id);
-    });
-    it('should handle priority aging', async () => {
-        const agingQueue = injector.resolve(TaskQueueProvider).get(`aging-${crypto.randomUUID()}`, {
-            priorityAgingInterval: 50,
-            priorityAgingStep: 10,
-        });
-        const t1 = await agingQueue.enqueue('low', {}, { priority: 2000 });
-        const t2 = await agingQueue.enqueue('high', {}, { priority: 1000 });
-        // Wait for aging to trigger
-        await timeout(100);
-        await agingQueue.maintenance();
-        const u1 = await agingQueue.getTask(t1.id);
-        const u2 = await agingQueue.getTask(t2.id);
-        expect(u1.priority).toBeLessThan(2000);
-        expect(u2.priority).toBeLessThan(1000);
-    });
-    it('should handle rate limiting', async () => {
-        const rateQueue = injector.resolve(TaskQueueProvider).get(`rate-${crypto.randomUUID()}`, {
-            rateLimit: 5,
-            rateInterval: 200,
-        });
-        // Limit is 5 per 200ms
-        for (let i = 0; i < 10; i++) {
-            await rateQueue.enqueue('task', { i });
-        }
-        const batch1 = await rateQueue.dequeueMany(10);
-        expect(batch1.length).toBe(5);
-        await timeout(500);
-        const batch2 = await rateQueue.dequeueMany(10);
-        expect(batch2.length).toBe(5);
-    });
-    it('should handle Diamond Dependency (A -> B, A -> C, (B&C) -> D)', async () => {
-        const taskA = await queue.enqueue('A', {});
-        const taskB = await queue.enqueue('B', {}, { scheduleAfter: [taskA.id] });
-        const taskC = await queue.enqueue('C', {}, { scheduleAfter: [taskA.id] });
-        const taskD = await queue.enqueue('D', {}, { scheduleAfter: [taskB.id, taskC.id] });
-        await completeTask('A');
-        await queue.waitForTasks([taskB.id, taskC.id], { statuses: [TaskStatus.Pending] });
-        await completeTask('B');
-        expect((await queue.getTask(taskD.id))?.status).toBe(TaskStatus.Waiting);
-        await completeTask('C');
-        await queue.waitForTasks([taskD.id], { statuses: [TaskStatus.Pending] });
-    });
-    it('should handle Deep Chain (A -> B -> C -> D)', async () => {
-        const taskA = await queue.enqueue('A', {});
-        const taskB = await queue.enqueue('B', {}, { scheduleAfter: [taskA.id] });
-        const taskC = await queue.enqueue('C', {}, { scheduleAfter: [taskB.id] });
-        const taskD = await queue.enqueue('D', {}, { scheduleAfter: [taskC.id] });
-        await completeTask('A');
-        await queue.waitForTasks([taskB.id], { statuses: [TaskStatus.Pending] });
-        await completeTask('B');
-        await queue.waitForTasks([taskC.id], { statuses: [TaskStatus.Pending] });
-        await completeTask('C');
-        await queue.waitForTasks([taskD.id], { statuses: [TaskStatus.Pending] });
-    });
-    it('should handle wide fan-out (A -> [B1...B50] -> C)', async () => {
-        const taskA = await queue.enqueue('A', {});
-        const bTasks = await queue.enqueueMany(Array.from({ length: 50 }, (_, i) => ({ type: `B${i}`, data: {}, scheduleAfter: [taskA.id] })), { returnTasks: true });
-        const taskC = await queue.enqueue('C', {}, { scheduleAfter: bTasks.map(t => t.id) });
-        await completeTask('A');
-        for (let i = 0; i < 49; i++) {
-            await completeTask(`B${i}`);
-            expect((await queue.getTask(taskC.id))?.status).toBe(TaskStatus.Waiting);
-        }
-        await completeTask('B49');
-        await queue.waitForTasks([taskC.id], { statuses: [TaskStatus.Pending] });
-    });
-    it('should handle deep tree with branching and merging', async () => {
-        const taskA = await queue.enqueue('A', {});
-        const taskB1 = await queue.enqueue('B1', {}, { scheduleAfter: [taskA.id] });
-        const taskB2 = await queue.enqueue('B2', {}, { scheduleAfter: [taskA.id] });
-        const taskC = await queue.enqueue('C', {}, { scheduleAfter: [taskB1.id, taskB2.id] });
-        const taskD1 = await queue.enqueue('D1', {}, { scheduleAfter: [taskC.id] });
-        const taskD2 = await queue.enqueue('D2', {}, { scheduleAfter: [taskC.id] });
-        const taskE = await queue.enqueue('E', {}, { scheduleAfter: [taskD1.id, taskD2.id] });
-        await completeTask('A');
-        await completeTask('B1');
-        await completeTask('B2');
-        await queue.waitForTasks([taskC.id], { statuses: [TaskStatus.Pending] });
-        await completeTask('C');
-        await queue.waitForTasks([taskD1.id], { statuses: [TaskStatus.Pending] });
-        await queue.waitForTasks([taskD2.id], { statuses: [TaskStatus.Pending] });
-        await completeTask('D1');
-        await completeTask('D2');
-        await queue.waitForTasks([taskE.id], { statuses: [TaskStatus.Pending] });
-    });
-    it('should handle abort cascade', async () => {
-        const taskA = await queue.enqueue('A', {});
-        const taskB = await queue.enqueue('B', {}, { scheduleAfter: [taskA.id], abortOnDependencyFailure: true });
-        const taskC = await queue.enqueue('C', {}, { scheduleAfter: [taskB.id], abortOnDependencyFailure: true });
-        const taskD = await queue.enqueue('D', {}, { scheduleAfter: [taskA.id], abortOnDependencyFailure: true });
-        const taskE = await queue.enqueue('E', {}, { scheduleAfter: [taskC.id, taskD.id], abortOnDependencyFailure: true });
-        const dA = await queue.dequeue({ types: ['A'] });
-        await queue.fail(dA, new Error('fatal'), { fatal: true });
-        await queue.waitForTasks([taskB.id, taskC.id, taskD.id, taskE.id], { statuses: [TaskStatus.Skipped] });
-    });
-    it('should NOT schedule if only one of two dependencies is met (AND logic)', async () => {
-        const taskA = await queue.enqueue('A', {});
-        const taskB = await queue.enqueue('B', {});
-        const taskC = await queue.enqueue('C', {}, { scheduleAfter: [taskA.id, taskB.id] });
-        await completeTask('A');
-        expect((await queue.getTask(taskC.id))?.status).toBe(TaskStatus.Waiting);
-        // Still waiting even after some time
-        await timeout(100);
-        expect((await queue.getTask(taskC.id))?.status).toBe(TaskStatus.Waiting);
-        await completeTask('B');
-        await queue.waitForTasks([taskC.id], { statuses: [TaskStatus.Pending] });
-    });
-});

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

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

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

@@ -1,296 +0,0 @@
-import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it } from 'vitest';
-import { CancellationToken } from '../../cancellation/index.js';
-import { TaskQueueProvider, TaskStatus } from '../../task-queue/index.js';
-import { setupIntegrationTest } from '../../testing/index.js';
-describe('Queue Dependencies & Tree Tests', () => {
-    let injector;
-    let queue;
-    beforeAll(async () => {
-        ({ injector } = await setupIntegrationTest({ modules: { taskQueue: true } }));
-    });
-    beforeEach(() => {
-        const queueProvider = injector.resolve(TaskQueueProvider);
-        const queueName = `dep-queue-${crypto.randomUUID()}`;
-        queue = queueProvider.get(queueName, {
-            visibilityTimeout: 1000,
-        });
-    });
-    afterEach(async () => {
-        await queue.clear();
-    });
-    afterAll(async () => {
-        await injector?.dispose();
-    });
-    describe('Dependencies (DAG)', () => {
-        it('should schedule a task only after dependency completes (completeAfter)', async () => {
-            // 1. Prereq
-            const prereq = await queue.enqueue('prereq', { val: 1 });
-            // 2. Dependent (Waiting)
-            const dependent = await queue.enqueue('dependent', { foo: 'bar' }, {
-                completeAfter: [prereq.id],
-            });
-            expect(dependent.status).toBe(TaskStatus.Pending);
-            // 3. Complete prereq
-            const dequeued = await queue.dequeue({ types: ['prereq'] });
-            expect(dequeued?.id).toBe(prereq.id);
-            await queue.complete(dequeued);
-            // Complete dependent too so it reaches 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);
-        });
-        it('should schedule a task to run after dependency completes (scheduleAfter)', async () => {
-            // 1. Prereq
-            const prereq = await queue.enqueue('prereq', {});
-            // 2. Dependent task
-            const dependent = await queue.enqueue('dependent', { foo: 'bar' }, {
-                scheduleAfter: [prereq.id],
-            });
-            expect(dependent.status).toBe(TaskStatus.Waiting);
-            // 3. Complete prereq
-            const dequeued = await queue.dequeue({ types: ['prereq'] });
-            await queue.complete(dequeued);
-            await queue.waitForTasks([dependent.id], { statuses: [TaskStatus.Pending] });
-            // 5. Dependent should be Pending (ready to run)
-            const updatedDependent = await queue.getTask(dependent.id);
-            expect(updatedDependent?.status).toBe(TaskStatus.Pending);
-            // 6. Should be dequeueable
-            const d2 = await queue.dequeue({ types: ['dependent'] });
-            expect(d2?.id).toBe(dependent.id);
-        });
-        it('should abort if dependency fails', async () => {
-            const prereq = await queue.enqueue('prereq', {});
-            const dependent = await queue.enqueue('dependent', {}, {
-                scheduleAfter: [prereq.id],
-                abortOnDependencyFailure: true,
-            });
-            const dequeued = await queue.dequeue({ types: ['prereq'] });
-            // Fail fatally
-            await queue.fail(dequeued, new Error('boom'), { fatal: true });
-            await queue.waitForTasks([dependent.id]);
-            const updatedDependent = await queue.getTask(dependent.id);
-            expect(updatedDependent?.status).toBe(TaskStatus.Skipped);
-            expect(updatedDependent?.errors[0]?.code).toBe('DependencyFailed');
-        });
-        it('should NOT overwrite terminal states during cancellation (abortOnDependencyFailure + complete)', async () => {
-            const dep = await queue.enqueue('dep', {});
-            // completeAfter allows 'main' to be Running while 'dep' is not finished
-            const main = await queue.enqueue('main', {}, { completeAfter: [dep.id], abortOnDependencyFailure: true });
-            const runningDep = await queue.dequeue();
-            expect(runningDep?.id).toBe(dep.id);
-            const runningMain = await queue.dequeue();
-            expect(runningMain?.id).toBe(main.id);
-            expect(runningMain?.status).toBe(TaskStatus.Running);
-            // Fail 'dep' -> this should make 'main' Skipped
-            await queue.fail(runningDep, new Error('Dependency failed'), { fatal: true });
-            const skippedMain = await queue.getTask(main.id);
-            expect(skippedMain?.status).toBe(TaskStatus.Skipped);
-            expect(skippedMain?.token).toBeNull();
-            // Call complete() on the old task reference (which still has the token)
-            await queue.complete(runningMain);
-            const finalMain = await queue.getTask(main.id);
-            expect(finalMain?.status).toBe(TaskStatus.Skipped);
-        });
-        it('should resolve dependencies across namespaces', async () => {
-            const queueProvider = injector.resolve(TaskQueueProvider);
-            const queueA = queueProvider.get(`QueueA-${crypto.randomUUID()}`);
-            const queueB = queueProvider.get(`QueueB-${crypto.randomUUID()}`);
-            const taskA = await queueA.enqueue('test', { value: 'A' });
-            const taskB = await queueB.enqueue('test', { value: 'B' }, { scheduleAfter: [{ id: taskA.id }] });
-            expect(taskB.status).toBe(TaskStatus.Waiting);
-            const dequeuedA = await queueA.dequeue();
-            await queueA.complete(dequeuedA);
-            queueB.notify();
-            await queueB.waitForTasks([taskB.id], { statuses: [TaskStatus.Pending], timeout: 10000 });
-            const updatedB = await queueB.getTask(taskB.id);
-            expect(updatedB?.status).toBe(TaskStatus.Pending);
-            await queueA.clear();
-            await queueB.clear();
-        });
-        it('should correctly skip dependent tasks across namespaces when abortOnDependencyFailure is triggered', async () => {
-            const queueProvider = injector.resolve(TaskQueueProvider);
-            const queueA = queueProvider.get(`QueueA-${crypto.randomUUID()}`);
-            const queueB = queueProvider.get(`QueueB-${crypto.randomUUID()}`);
-            const taskA = await queueA.enqueue('test', { value: 'A' });
-            const taskB = await queueB.enqueue('test', { value: 'B' }, {
-                abortOnDependencyFailure: true,
-                scheduleAfter: [{ id: taskA.id }],
-            });
-            const dequeuedA = await queueA.dequeue();
-            await queueA.fail(dequeuedA, new Error('Failed'), { fatal: true });
-            queueB.notify();
-            await queueB.waitForTasks([taskB.id], { statuses: [TaskStatus.Skipped], timeout: 10000 });
-            const updatedB = await queueB.getTask(taskB.id);
-            expect(updatedB?.status).toBe(TaskStatus.Skipped);
-            await queueA.clear();
-            await queueB.clear();
-        });
-        it('should respect requiredStatuses', async () => {
-            const prereq = await queue.enqueue('prereq', {});
-            // Wait for prereq to be Dead or Completed
-            const dependent = await queue.enqueue('dependent', {}, {
-                scheduleAfter: [{ id: prereq.id, requiredStatuses: [TaskStatus.Dead, TaskStatus.Completed] }],
-            });
-            // Fail fatally -> Dead
-            const d1 = await queue.dequeue({ types: ['prereq'] });
-            await queue.fail(d1, new Error('boom'), { fatal: true });
-            await queue.waitForTasks([dependent.id], { statuses: [TaskStatus.Pending] });
-            const updated = await queue.getTask(dependent.id);
-            expect(updated?.status).toBe(TaskStatus.Pending);
-        });
-        it('should schedule a task immediately if dependency is already completed (Bug 1)', async () => {
-            // 1. Enqueue and complete task A
-            const taskA = await queue.enqueue('taskA', {});
-            const dequeuedA = await queue.dequeue({ types: ['taskA'] });
-            await queue.complete(dequeuedA);
-            const finishedA = await queue.getTask(taskA.id);
-            expect(finishedA?.status).toBe(TaskStatus.Completed);
-            // 2. Enqueue task B with scheduleAfter: [A.id]
-            const taskB = await queue.enqueue('taskB', {}, {
-                scheduleAfter: [taskA.id],
-            });
-            // Wait for proactive resolution to trigger
-            await queue.waitForTasks([taskB.id], { statuses: [TaskStatus.Pending] });
-            const updatedB = await queue.getTask(taskB.id);
-            expect(updatedB?.status).toBe(TaskStatus.Pending);
-        });
-        it('should transition to Pending even if duplicate dependencies are specified (Bug 2)', async () => {
-            // 1. Enqueue task A
-            const taskA = await queue.enqueue('taskA', {});
-            // 2. Enqueue task B with duplicate scheduleAfter: [A.id, A.id]
-            const taskB = await queue.enqueue('taskB', {}, {
-                scheduleAfter: [taskA.id, taskA.id],
-            });
-            expect(taskB.status).toBe(TaskStatus.Waiting);
-            // 3. Complete task A
-            const dequeuedA = await queue.dequeue({ types: ['taskA'] });
-            await queue.complete(dequeuedA);
-            await queue.waitForTasks([taskB.id], { statuses: [TaskStatus.Pending] });
-            const updatedB = await queue.getTask(taskB.id);
-            expect(updatedB?.status).toBe(TaskStatus.Pending);
-        });
-        it('should NOT resurrect terminal tasks when calling rescheduleMany (Issue 1)', async () => {
-            const task = await queue.enqueue('test', { val: 1 });
-            const dequeued = await queue.dequeue();
-            await queue.complete(dequeued);
-            const completedTask = await queue.getTask(task.id);
-            expect(completedTask?.status).toBe(TaskStatus.Completed);
-            // Attempt to reschedule
-            await queue.rescheduleMany([task.id], Date.now());
-            const stillCompletedTask = await queue.getTask(task.id);
-            expect(stillCompletedTask?.status).toBe(TaskStatus.Completed);
-            expect(stillCompletedTask?.completeTimestamp).toBeDefined();
-        });
-    });
-    describe('Tree Operations & Cancellation', () => {
-        it('should retrieve task tree and cancel hierarchy (multiple children)', async () => {
-            // Root
-            const root = await queue.enqueue('root', {});
-            // Children
-            const child1 = await queue.enqueue('child1', {}, { parentId: root.id });
-            const child2 = await queue.enqueue('child2', {}, { parentId: root.id });
-            // Grandchild
-            const grandchild = await queue.enqueue('grandchild', {}, { parentId: child1.id });
-            // Get Tree
-            const tree = await queue.getTree(root.id);
-            expect(tree.length).toBe(4);
-            expect(tree.map((t) => t.id)).toContain(grandchild.id);
-            expect(tree.map((t) => t.id)).toContain(child2.id);
-            // Cancel Root
-            await queue.cancel(root.id);
-            // Verify all cancelled
-            const tRoot = await queue.getTask(root.id);
-            const tChild1 = await queue.getTask(child1.id);
-            const tChild2 = await queue.getTask(child2.id);
-            const tGrand = await queue.getTask(grandchild.id);
-            expect(tRoot?.status).toBe(TaskStatus.Cancelled);
-            expect(tChild1?.status).toBe(TaskStatus.Cancelled);
-            expect(tChild2?.status).toBe(TaskStatus.Cancelled);
-            expect(tGrand?.status).toBe(TaskStatus.Cancelled);
-        });
-        it('should retrieve subtree via getTreeByQuery', async () => {
-            const root = await queue.enqueue('root', { val: 'root' });
-            const child = await queue.enqueue('child', { val: 'child' }, { parentId: root.id });
-            await queue.enqueue('other', { val: 'other' });
-            const tree = await queue.getTreeByQuery({ id: root.id });
-            expect(tree.length).toBe(2);
-            expect(tree.map(t => t.id)).toContain(root.id);
-            expect(tree.map(t => t.id)).toContain(child.id);
-        });
-        it('should cancel many by tags', async () => {
-            await queue.enqueue('t1', {}, { tags: ['group-a'] });
-            await queue.enqueue('t2', {}, { tags: ['group-a'] });
-            await queue.enqueue('t3', {}, { tags: ['group-b'] });
-            await queue.cancelManyByTags(['group-a']);
-            // Check status
-            const tasks = await queue.getManyByTags('group-a');
-            expect(tasks.length).toBe(2);
-            expect(tasks.every((t) => t.status === TaskStatus.Cancelled)).toBe(true);
-            const tasksB = await queue.getManyByTags('group-b');
-            expect(tasksB[0]?.status).toBe(TaskStatus.Pending);
-        });
-        it('should NOT resolve completed tasks as Cancelled when calling cancelMany (Issue 3)', async () => {
-            const taskA = await queue.enqueue('test', { name: 'A' });
-            const taskB = await queue.enqueue('test', { name: 'B' }, { scheduleAfter: [taskA.id], abortOnDependencyFailure: true });
-            const dequeuedA = await queue.dequeue();
-            await queue.complete(dequeuedA);
-            // B should have unresolvedScheduleDependencies = 0 and be Pending because A completed
-            const freshB = await queue.getTask(taskB.id);
-            expect(freshB?.unresolvedScheduleDependencies).toBe(0);
-            expect(freshB?.status).toBe(TaskStatus.Pending);
-            // Cancel A. Since A is Completed, it shouldn't be touched in DB.
-            // Importantly, it shouldn't trigger dependency resolution for B as 'Cancelled'.
-            // In the old code, this would have caused B to be transitioned to 'Skipped' because A was resolved as 'Cancelled' but B required 'Completed' (and abortOnDependencyFailure is true).
-            await queue.cancelMany([taskA.id]);
-            const stillFreshA = await queue.getTask(taskA.id);
-            expect(stillFreshA?.status).toBe(TaskStatus.Completed);
-            const stillFreshB = await queue.getTask(taskB.id);
-            expect(stillFreshB?.status).toBe(TaskStatus.Pending); // Should STILL be Pending
-            expect(stillFreshB?.unresolvedScheduleDependencies).toBe(0);
-        });
-    });
-    describe('Restart & Consumers', () => {
-        it('should restart a dead/cancelled task', async () => {
-            const task = await queue.enqueue('restart-test', {});
-            const d = await queue.dequeue({ types: ['restart-test'] });
-            await queue.fail(d, new Error('fatal'), { fatal: true }); // Dead
-            await queue.restart(task.id);
-            const updated = await queue.getTask(task.id);
-            expect(updated?.status).toBe(TaskStatus.Pending);
-            expect(updated?.tries).toBe(0);
-            expect(updated?.errors).toEqual([]);
-        });
-        it('should consume tasks via async iterator (getConsumer)', async () => {
-            await queue.enqueue('c1', { val: 1 });
-            await queue.enqueue('c2', { val: 2 });
-            const token = new CancellationToken();
-            const consumer = queue.getConsumer(token);
-            const t1 = (await consumer.next()).value;
-            expect(t1.data['val']).toBe(1);
-            const t2 = (await consumer.next()).value;
-            expect(t2.data['val']).toBe(2);
-            token.set(); // Stop consumer
-            const t3 = await consumer.next();
-            expect(t3.done).toBe(true);
-        });
-        it('should consume batches via async iterator (getBatchConsumer)', async () => {
-            await queue.enqueueMany([
-                { type: 'b', data: { val: 1 } },
-                { type: 'b', data: { val: 2 } },
-                { type: 'b', data: { val: 3 } },
-            ]);
-            const token = new CancellationToken();
-            const batchConsumer = queue.getBatchConsumer(2, token);
-            const b1 = (await batchConsumer.next()).value;
-            expect(b1.length).toBe(2);
-            const b2 = (await batchConsumer.next()).value;
-            expect(b2.length).toBe(1);
-            token.set();
-            const b3 = await batchConsumer.next();
-            expect(b3.done).toBe(true);
-        });
-    });
-});

package/task-queue/tests/enqueue-batch.test.d.ts

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

package/task-queue/tests/enqueue-batch.test.js

@@ -1,125 +0,0 @@
-import { eq, inArray } from 'drizzle-orm';
-import { afterAll, beforeAll, describe, expect, it, vi } from 'vitest';
-import { Database } from '../../orm/server/index.js';
-import { TaskQueueEnqueueBatch } from '../../task-queue/enqueue-batch.js';
-import { TaskQueueProvider } from '../../task-queue/index.js';
-import { taskDependency as taskDependencyTable } from '../../task-queue/postgres/schemas.js';
-import { setupIntegrationTest } from '../../testing/index.js';
-describe('TaskQueueEnqueueBatch', () => {
-    let injector;
-    let queue;
-    let database;
-    let queueProvider;
-    beforeAll(async () => {
-        ({ injector } = await setupIntegrationTest({ modules: { taskQueue: true } }));
-        queueProvider = injector.resolve(TaskQueueProvider);
-        queue = queueProvider.get(`batch-queue-${crypto.randomUUID()}`);
-        database = injector.resolve(Database);
-    });
-    afterAll(async () => {
-        await injector?.dispose();
-    });
-    it('should restore items if enqueueMany fails', async () => {
-        const batch = new TaskQueueEnqueueBatch(queue);
-        batch.add('t1', { val: 1 });
-        batch.add('t2', { val: 2 });
-        expect(batch.items.length).toBe(2);
-        // Mock enqueueMany to throw
-        vi.spyOn(queue, 'enqueueMany').mockRejectedValueOnce(new Error('db failure'));
-        await expect(batch.enqueue()).rejects.toThrow('db failure');
-        // Check items restored
-        expect(batch.items.length).toBe(2);
-        expect(batch.items[0].type).toBe('t1');
-        expect(batch.items[1].type).toBe('t2');
-        // Should work on second attempt (without mock)
-        vi.restoreAllMocks();
-        const tasks = await batch.enqueue({ returnTasks: true });
-        expect(batch.items.length).toBe(0);
-        const t1 = await queue.getTask(tasks[0].id);
-        expect(t1).toBeDefined();
-        expect(t1?.type).toBe('t1');
-    });
-    it('should work correctly with queue.batch()', async () => {
-        const batch = queue.batch();
-        batch.add('b1', { x: 1 });
-        batch.add('b2', { x: 2 });
-        const tasks = await batch.enqueue({ returnTasks: true });
-        expect(tasks.length).toBe(2);
-        expect(batch.items.length).toBe(0);
-    });
-    describe('enqueueMany Alignment and Dependencies', () => {
-        it('should correctly map dependencies when enqueuing a mix of tasks with and without idempotency keys', async () => {
-            const q = queueProvider.get(`q-${crypto.randomUUID()}`);
-            const items = [
-                { type: 'test', data: { value: '1' } },
-                { type: 'test', data: { value: '2' }, idempotencyKey: 'key-2' },
-                { type: 'test', data: { value: '3' }, scheduleAfter: [0] },
-                { type: 'test', data: { value: '4' }, idempotencyKey: 'key-4' },
-                { type: 'test', data: { value: '5' }, scheduleAfter: [0] },
-            ];
-            const tasks = await q.enqueueMany(items, { returnTasks: true });
-            expect(tasks).toHaveLength(5);
-            const task1Id = tasks[0].id;
-            const task3Id = tasks[2].id;
-            const task5Id = tasks[4].id;
-            const deps = await database
-                .select()
-                .from(taskDependencyTable)
-                .where(inArray(taskDependencyTable.taskId, [task3Id, task5Id]));
-            expect(deps).toHaveLength(2);
-            expect(deps.every(d => d.dependencyTaskId === task1Id)).toBe(true);
-        });
-        it('should correctly map dependencies when batch-enqueuing with pre-existing idempotency keys', async () => {
-            const q = queueProvider.get(`q-${crypto.randomUUID()}`);
-            const existingTask = await q.enqueue('test', { value: 'existing' }, { idempotencyKey: 'shared-key' });
-            const items = [
-                { type: 'test', data: { value: 'new' } },
-                { type: 'test', data: { value: 'duplicate' }, idempotencyKey: 'shared-key' },
-                { type: 'test', data: { value: 'dependent' }, scheduleAfter: [1] },
-            ];
-            const tasks = await q.enqueueMany(items, { returnTasks: true, replace: false });
-            expect(tasks[1].id).toBe(existingTask.id);
-            const dependentTaskId = tasks[2].id;
-            const deps = await database
-                .select()
-                .from(taskDependencyTable)
-                .where(eq(taskDependencyTable.taskId, dependentTaskId));
-            expect(deps).toHaveLength(1);
-            expect(deps[0].dependencyTaskId).toBe(existingTask.id);
-        });
-        it('should accurately increment parent unresolvedCompleteDependencies across multiple namespaces in a single batch', async () => {
-            const queueA = queueProvider.get(`QueueA-${crypto.randomUUID()}`);
-            const queueB = queueProvider.get(`QueueB-${crypto.randomUUID()}`);
-            const queueC = queueProvider.get(`QueueC-${crypto.randomUUID()}`);
-            const parentA = await queueA.enqueue('test', { value: 'parentA' });
-            const parentB = await queueB.enqueue('test', { value: 'parentB' });
-            await queueC.enqueueMany([
-                { type: 'test', data: { value: 'child1' }, parentId: parentA.id },
-                { type: 'test', data: { value: 'child2' }, parentId: parentA.id },
-                { type: 'test', data: { value: 'child3' }, parentId: parentB.id },
-            ]);
-            const upA = await queueA.getTask(parentA.id);
-            const upB = await queueB.getTask(parentB.id);
-            expect(upA?.unresolvedCompleteDependencies).toBe(2);
-            expect(upB?.unresolvedCompleteDependencies).toBe(1);
-        });
-        it('should correctly map dependencies when using object with index', async () => {
-            const q = queueProvider.get(`q-${crypto.randomUUID()}`);
-            const items = [
-                { type: 'test', data: { value: '1' } },
-                { type: 'test', data: { value: '2' }, scheduleAfter: [0] },
-                { type: 'test', data: { value: '3' }, scheduleAfter: [{ index: 0 }] },
-            ];
-            const tasks = await q.enqueueMany(items, { returnTasks: true });
-            const task1Id = tasks[0].id;
-            const task2Id = tasks[1].id;
-            const task3Id = tasks[2].id;
-            const deps = await database
-                .select()
-                .from(taskDependencyTable)
-                .where(inArray(taskDependencyTable.taskId, [task2Id, task3Id]));
-            expect(deps).toHaveLength(2);
-            expect(deps.every(d => d.dependencyTaskId === task1Id)).toBe(true);
-        });
-    });
-});

package/task-queue/tests/enqueue-item.test.d.ts

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

package/task-queue/tests/enqueue-item.test.js

@@ -1,12 +0,0 @@
-import { describe, expectTypeOf, test } from 'vitest';
-describe('EnqueueManyItem Type Definitions', () => {
-    test('EnqueueManyItem should be a discriminated union', () => {
-        const item = {};
-        if (item.type == 'test-task') {
-            expectTypeOf(item.data).toEqualTypeOf();
-        }
-        else if (item.type == 'other-task') {
-            expectTypeOf(item.data).toEqualTypeOf();
-        }
-    });
-});

package/task-queue/tests/fan-out-spawning.test.d.ts

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