@tstdl/base 0.93.141 → 0.93.143

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

@@ -2,7 +2,6 @@ import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it } from
 import { CancellationToken } from '../../cancellation/index.js';
 import { TaskQueueProvider, TaskStatus } from '../../task-queue/index.js';
 import { setupIntegrationTest } from '../../testing/index.js';
-import { timeout } from '../../utils/timing.js';
 describe('Queue Dependencies & Tree Tests', () => {
     let injector;
     let queue;
@@ -11,7 +10,7 @@ describe('Queue Dependencies & Tree Tests', () => {
     });
     beforeEach(() => {
         const queueProvider = injector.resolve(TaskQueueProvider);
-        const queueName = `dep-queue-${Date.now()}-${Math.random()}`;
+        const queueName = `dep-queue-${crypto.randomUUID()}`;
         queue = queueProvider.get(queueName, {
             visibilityTimeout: 1000,
         });
@@ -22,15 +21,6 @@ describe('Queue Dependencies & Tree Tests', () => {
     afterAll(async () => {
         await injector?.dispose();
     });
-    async function waitForStatus(id, status) {
-        for (let i = 0; i < 20; i++) {
-            const task = await queue.getTask(id);
-            if (task?.status == status) {
-                return;
-            }
-            await timeout(50);
-        }
-    }
     describe('Dependencies (DAG)', () => {
         it('should schedule a task only after dependency completes (completeAfter)', async () => {
             // 1. Prereq
@@ -63,7 +53,7 @@ describe('Queue Dependencies & Tree Tests', () => {
             // 3. Complete prereq
             const dequeued = await queue.dequeue({ types: ['prereq'] });
             await queue.complete(dequeued);
-            await waitForStatus(dependent.id, TaskStatus.Pending);
+            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);
@@ -71,56 +61,165 @@ describe('Queue Dependencies & Tree Tests', () => {
             const d2 = await queue.dequeue({ types: ['dependent'] });
             expect(d2?.id).toBe(dependent.id);
         });
-        it('should fail-fast if dependency fails', async () => {
+        it('should abort if dependency fails', async () => {
             const prereq = await queue.enqueue('prereq', {});
             const dependent = await queue.enqueue('dependent', {}, {
                 scheduleAfter: [prereq.id],
-                failFast: true
+                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.Dead);
+            expect(updatedDependent?.status).toBe(TaskStatus.Skipped);
             expect(updatedDependent?.error?.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] }]
+                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 waitForStatus(dependent.id, TaskStatus.Pending);
+            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', async () => {
+        it('should retrieve task tree and cancel hierarchy (multiple children)', async () => {
             // Root
             const root = await queue.enqueue('root', {});
-            // Child
-            const child = await queue.enqueue('child', {}, { parentId: root.id });
+            // 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: child.id });
+            const grandchild = await queue.enqueue('grandchild', {}, { parentId: child1.id });
             // Get Tree
             const tree = await queue.getTree(root.id);
-            expect(tree.length).toBe(3);
+            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 tChild = await queue.getTask(child.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(tChild?.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'] });
@@ -133,6 +232,25 @@ describe('Queue Dependencies & Tree Tests', () => {
             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 () => {
@@ -162,7 +280,7 @@ describe('Queue Dependencies & Tree Tests', () => {
             await queue.enqueueMany([
                 { type: 'b', data: { val: 1 } },
                 { type: 'b', data: { val: 2 } },
-                { type: 'b', data: { val: 3 } }
+                { type: 'b', data: { val: 3 } },
             ]);
             const token = new CancellationToken();
             const batchConsumer = queue.getBatchConsumer(2, token);

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

@@ -0,0 +1,125 @@
+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/fan-out-spawning.test.js

@@ -1,16 +1,21 @@
 import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it } from 'vitest';
+import { Database } from '../../orm/server/index.js';
 import { TaskQueueProvider, TaskStatus } from '../../task-queue/index.js';
+import { task as taskTable } from '../../task-queue/postgres/schemas.js';
 import { setupIntegrationTest } from '../../testing/index.js';
-import { timeout } from '../../utils/timing.js';
+import { currentTimestamp } from '../../utils/date-time.js';
+import { eq } from 'drizzle-orm';
 describe('Fan-Out Spawning', () => {
     let injector;
     let queue;
+    let database;
     beforeAll(async () => {
         ({ injector } = await setupIntegrationTest({ modules: { taskQueue: true } }));
+        database = injector.resolve(Database);
     });
     beforeEach(() => {
         const queueProvider = injector.resolve(TaskQueueProvider);
-        const queueName = `fan-out-queue-${Date.now()}-${Math.random()}`;
+        const queueName = `fan-out-queue-${crypto.randomUUID()}`;
         queue = queueProvider.get(queueName, {
             visibilityTimeout: 1000,
         });
@@ -40,14 +45,50 @@ describe('Fan-Out Spawning', () => {
         const fParent = await queue.getTask(parent.id);
         expect(fParent?.status).toBe(TaskStatus.Completed);
     });
-    it('should NOT transition parent to Waiting if waitForCompletion is false', async () => {
+    it('should NOT transition parent to Waiting if blockParent is false', async () => {
         const parent = await queue.enqueue('parent', {});
         const dParent = await queue.dequeue();
-        // Spawn child with waitForCompletion: false
-        await queue.enqueueMany([{ type: 'child', data: {}, parentId: parent.id, waitForCompletion: false }], { returnTasks: true });
+        // Spawn child with blockParent: false
+        await queue.enqueueMany([{ type: 'child', data: {}, parentId: parent.id, blockParent: false }], { returnTasks: true });
         await queue.complete(dParent);
         const uParent = await queue.getTask(parent.id);
         expect(uParent?.status).toBe(TaskStatus.Completed); // Finished immediately
         expect(uParent?.unresolvedCompleteDependencies).toBe(0);
     });
+    it('should transition parent from WaitingChildren to Completed exactly when the last child finishes', async () => {
+        const parent = await queue.enqueue('parent', {});
+        const c1 = await queue.enqueue('child', { val: 1 }, { parentId: parent.id });
+        const c2 = await queue.enqueue('child', { val: 2 }, { parentId: parent.id });
+        const dp = await queue.dequeue();
+        await queue.complete(dp);
+        const up1 = await queue.getTask(parent.id);
+        expect(up1?.status).toBe(TaskStatus.WaitingChildren);
+        const dc1 = await queue.dequeue();
+        await queue.complete(dc1);
+        const up2 = await queue.getTask(parent.id);
+        expect(up2?.status).toBe(TaskStatus.WaitingChildren);
+        const dc2 = await queue.dequeue();
+        await queue.complete(dc2);
+        const up3 = await queue.getTask(parent.id);
+        expect(up3?.status).toBe(TaskStatus.Completed);
+    });
+    it('should protect parent tasks from archival if orphaned child tasks still exist', async () => {
+        const queueProvider = injector.resolve(TaskQueueProvider);
+        const ephemeralQueue = queueProvider.get(`ephemeral-${crypto.randomUUID()}`, { retention: 0 });
+        const parent = await ephemeralQueue.enqueue('parent', {});
+        await ephemeralQueue.enqueue('child', {}, { parentId: parent.id });
+        // Manually complete parent while child is still pending
+        await database
+            .update(taskTable)
+            .set({
+            status: TaskStatus.Completed,
+            completeTimestamp: currentTimestamp() - 1000,
+        })
+            .where(eq(taskTable.id, parent.id));
+        await ephemeralQueue.maintenance();
+        const updatedParent = await ephemeralQueue.getTask(parent.id);
+        expect(updatedParent).toBeDefined(); // Should still be in main table
+        expect(updatedParent?.status).toBe(TaskStatus.Completed);
+        await ephemeralQueue.clear();
+    });
 });

package/task-queue/tests/idempotent-replacement.test.js

@@ -1,16 +1,21 @@
+import { eq } from 'drizzle-orm';
 import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it } from 'vitest';
+import { Database } from '../../orm/server/index.js';
 import { TaskQueueProvider, TaskStatus } from '../../task-queue/index.js';
+import { taskDependency as taskDependencyTable } from '../../task-queue/postgres/schemas.js';
 import { setupIntegrationTest } from '../../testing/index.js';
 import { timeout } from '../../utils/timing.js';
 describe('Idempotent Replacement', () => {
     let injector;
     let queue;
+    let database;
     beforeAll(async () => {
         ({ injector } = await setupIntegrationTest({ modules: { taskQueue: true } }));
+        database = injector.resolve(Database);
     });
     beforeEach(() => {
         const queueProvider = injector.resolve(TaskQueueProvider);
-        const queueName = `idempotent-queue-${Date.now()}-${Math.random()}`;
+        const queueName = `idempotent-queue-${crypto.randomUUID()}`;
         queue = queueProvider.get(queueName, {
             visibilityTimeout: 1000,
         });
@@ -58,4 +63,52 @@ describe('Idempotent Replacement', () => {
         const fTask = await queue.getTask(taskV1.id);
         expect(fTask?.status).toBe(TaskStatus.Pending);
     });
+    it('should update parentId on replacement', async () => {
+        const parent1 = await queue.enqueue('parent', { id: 1 });
+        const parent2 = await queue.enqueue('parent', { id: 2 });
+        const idempotencyKey = 'task-1';
+        const taskV1 = await queue.enqueue('child', {}, { idempotencyKey, parentId: parent1.id });
+        expect(taskV1.parentId).toBe(parent1.id);
+        // Replace with new parent
+        const taskV2 = await queue.enqueue('child', {}, { idempotencyKey, parentId: parent2.id, replace: true });
+        expect(taskV2.id).toBe(taskV1.id);
+        expect(taskV2.parentId).toBe(parent2.id);
+    });
+    it('should NOT corrupt state on idempotent enqueues (replace: false)', async () => {
+        const dep = await queue.enqueue('dep', {});
+        const idempotencyKey = 'task-2';
+        // Initial enqueue without dependency
+        const taskV1 = await queue.enqueue('main', {}, { idempotencyKey });
+        expect(taskV1.status).toBe(TaskStatus.Pending);
+        // Deduplicated enqueue with dependency
+        const taskV2 = await queue.enqueue('main', {}, { idempotencyKey, scheduleAfter: [dep.id], replace: false });
+        expect(taskV2.id).toBe(taskV1.id);
+        const task = await queue.getTask(taskV2.id);
+        expect(task?.status).toBe(TaskStatus.Pending);
+        expect(task?.unresolvedScheduleDependencies).toBe(0);
+    });
+    it('should NOT orphan children on task replacement', async () => {
+        const idempotencyKey = 'parent-task';
+        const parent = await queue.enqueue('parent', {}, { idempotencyKey });
+        // Enqueue child
+        await queue.enqueue('child', {}, { parentId: parent.id });
+        const parentAfterChild = await queue.getTask(parent.id);
+        expect(parentAfterChild?.unresolvedCompleteDependencies).toBe(1);
+        // Replace parent
+        const replacedParent = await queue.enqueue('parent', { replaced: true }, { idempotencyKey, replace: true });
+        expect(replacedParent.unresolvedCompleteDependencies).toBe(1);
+    });
+    it('should clear and recreate dependencies when enqueuing existing tasks with replace: true', async () => {
+        const dep1 = await queue.enqueue('test', { value: 'dep1' });
+        const dep2 = await queue.enqueue('test', { value: 'dep2' });
+        const task = await queue.enqueue('test', { value: 'main' }, { idempotencyKey: 'main-key', scheduleAfter: [dep1.id] });
+        // Re-enqueue with replace: true and different dependency
+        await queue.enqueue('test', { value: 'main-replaced' }, { idempotencyKey: 'main-key', replace: true, scheduleAfter: [dep2.id] });
+        const deps = await database
+            .select()
+            .from(taskDependencyTable)
+            .where(eq(taskDependencyTable.taskId, task.id));
+        expect(deps).toHaveLength(1);
+        expect(deps[0].dependencyTaskId).toBe(dep2.id);
+    });
 });

package/task-queue/tests/missing-idempotent-tasks.test.js

@@ -1,5 +1,5 @@
 import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it } from 'vitest';
-import { TaskQueueProvider } from '../../task-queue/index.js';
+import { TaskQueueProvider, TaskStatus } from '../../task-queue/index.js';
 import { setupIntegrationTest } from '../../testing/index.js';
 describe('Missing Idempotent Tasks Bug', () => {
     let injector;
@@ -9,7 +9,7 @@ describe('Missing Idempotent Tasks Bug', () => {
     });
     beforeEach(() => {
         const queueProvider = injector.resolve(TaskQueueProvider);
-        const queueName = `missing-idem-queue-${Date.now()}-${Math.random()}`;
+        const queueName = `missing-idem-queue-${crypto.randomUUID()}`;
         queue = queueProvider.get(queueName, {
             visibilityTimeout: 1000,
         });
@@ -24,15 +24,16 @@ describe('Missing Idempotent Tasks Bug', () => {
         const key = 'idem-key';
         const dep = await queue.enqueue('dep', {});
         // 1. Initial enqueue
-        await queue.enqueue('main', {}, { idempotencyKey: key });
+        const task1 = await queue.enqueue('main', {}, { idempotencyKey: key });
         // 2. Second enqueue with same key and a dependency, returnTasks: false
         // This should NOT crash.
-        // It should ideally either:
-        // a) Ignore the new dependency because it's a duplicate and replace=false
-        // b) Add the dependency to the existing task (though replace=false usually means ignore)
-        // The current bug is that it CRASHES with TypeError.
+        // replace=false means we should ignore the new data AND the new dependency for the existing task.
         await expect(queue.enqueueMany([
-            { type: 'main', data: {}, idempotencyKey: key, scheduleAfter: [dep.id] }
+            { type: 'main', data: { new: 'data' }, idempotencyKey: key, scheduleAfter: [dep.id] }
         ], { replace: false, returnTasks: false })).resolves.toBeUndefined();
+        const updatedTask = await queue.getTask(task1.id);
+        expect(updatedTask?.data).toEqual({}); // Data should not have changed
+        expect(updatedTask?.unresolvedScheduleDependencies).toBe(0); // Dependency should not have been added
+        expect(updatedTask?.status).toBe(TaskStatus.Pending); // Should still be Pending, not Waiting
     });
 });