@tstdl/base 0.93.139 → 0.93.141

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

@@ -1,12 +1,14 @@
 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';
 import { currentTimestamp } from '../../utils/date-time.js';
+import { Timer } from '../../utils/timer.js';
 import { timeout } from '../../utils/timing.js';
+import { isDefined } from '../../utils/type-guards.js';
 describe('Queue Integration Tests', () => {
     let injector;
     let queue;
-    const queueName = `test-queue-${Date.now()}`;
     // Helper to verify state in DB
     async function assertTaskStatus(id, state, message) {
         const task = await queue.getTask(id);
@@ -14,10 +16,10 @@ describe('Queue Integration Tests', () => {
     }
     beforeAll(async () => {
         ({ injector } = await setupIntegrationTest({ modules: { taskQueue: true } }));
-        // Use the QueueProvider to Create/Retrieve the queue.
-        // This is the cleanest way to get a configured queue instance without
-        // messing with `injectArgument` manually in the test body.
+    });
+    beforeEach(async () => {
         const queueProvider = injector.resolve(TaskQueueProvider);
+        const queueName = `test-queue-${crypto.randomUUID()}`;
         queue = queueProvider.get(queueName, {
             visibilityTimeout: 5000,
             retryDelayMinimum: 100, // Fast retries for testing
@@ -30,7 +32,9 @@ describe('Queue Integration Tests', () => {
     });
     afterAll(async () => {
         try {
-            await queue.clear();
+            if (isDefined(queue)) {
+                await queue.clear();
+            }
             await injector.dispose();
         }
         catch (error) {
@@ -74,9 +78,9 @@ describe('Queue Integration Tests', () => {
         expect(t2.id, 'Same ID if not replaced').toBe(t1.id);
         const check1 = await queue.getTask(t1.id);
         expect((check1?.data)['value']).toBe('original');
-        // 3. Replace Strategy: Should replace existing task with new data AND new ID
+        // 3. Replace Strategy: Should replace existing task with new data. ID stays the same to avoid foreign key violations.
         const t3 = await queue.enqueueMany([{ type: 'test', data: { value: 'updated' }, idempotencyKey: key }], { replace: true, returnTasks: true });
-        expect(t3[0].id, 'New ID if replaced').not.toBe(t1.id);
+        expect(t3[0].id, 'Same ID if replaced').toBe(t1.id);
         // New task should have new data
         const checkNew = await queue.getTask(t3[0].id);
         expect((checkNew?.data)['value']).toBe('updated');
@@ -276,7 +280,7 @@ describe('PostgresQueue (Distributed Task Orchestration)', () => {
             const initialLock = dequeued.visibilityDeadline;
             await timeout(20);
             const touched = await queue.touch(dequeued);
-            expect(touched?.visibilityDeadline > initialLock).toBe(true);
+            expect(touched.visibilityDeadline > initialLock).toBe(true);
         });
         it('should prevent touching if token is lost (stolen by another worker)', async () => {
             await queue.enqueue('foo', { foo: 'work' });
@@ -331,4 +335,120 @@ describe('PostgresQueue (Distributed Task Orchestration)', () => {
             expect(updated?.state).toEqual({ step: 1 });
         });
     });
+    describe('waitForTasks', () => {
+        it('should wait for multiple tasks to reach finalized state', async () => {
+            const t1 = await queue.enqueue('foo', { foo: 'wait-1' });
+            const t2 = await queue.enqueue('foo', { foo: 'wait-2' });
+            void (async () => {
+                await timeout(100);
+                const d1 = await queue.dequeue();
+                await queue.complete(d1);
+                await timeout(100);
+                const d2 = await queue.dequeue();
+                await queue.complete(d2);
+            })();
+            const result = await queue.waitForTasks([t1.id, t2.id], { timeout: 2000 });
+            expect(result.cancelled).toBe(false);
+            const check1 = await queue.getTask(t1.id);
+            const check2 = await queue.getTask(t2.id);
+            expect(check1?.status).toBe(TaskStatus.Completed);
+            expect(check2?.status).toBe(TaskStatus.Completed);
+        });
+        it('should throw TimeoutError on timeout', async () => {
+            const t1 = await queue.enqueue('foo', { foo: 'timeout' });
+            await expect(queue.waitForTasks([t1.id], { timeout: 100 })).rejects.toThrow('Timeout while waiting for tasks to complete');
+        });
+        it('should wait for Cancelled and Dead states', async () => {
+            const t1 = await queue.enqueue('foo', { foo: 'cancel' });
+            const t2 = await queue.enqueue('foo', { foo: 'dead' });
+            void (async () => {
+                await timeout(50);
+                const d1 = await queue.dequeue();
+                if (d1)
+                    await queue.cancel(d1.id);
+                const d2 = await queue.dequeue();
+                if (d2)
+                    await queue.fail(d2, new Error('fatal'), { fatal: true });
+                queue.notify();
+            })();
+            const result = await queue.waitForTasks([t1.id, t2.id], { timeout: 2000 });
+            expect(result.cancelled).toBe(false);
+            const c1 = await queue.getTask(t1.id);
+            const c2 = await queue.getTask(t2.id);
+            expect(c1?.status).toBe(TaskStatus.Cancelled);
+            expect(c2?.status).toBe(TaskStatus.Dead);
+        });
+        it('should handle cancellationSignal', async () => {
+            const t1 = await queue.enqueue('foo', { foo: 'long' });
+            const signal = new CancellationToken();
+            void timeout(100).then(() => signal.set());
+            const result = await queue.waitForTasks([t1.id], { cancellationSignal: signal, timeout: 5000 });
+            expect(result.cancelled).toBe(true);
+        });
+        it('should return immediately for non-existent tasks', async () => {
+            const result = await queue.waitForTasks([crypto.randomUUID()], { timeout: 1000 });
+            expect(result.cancelled).toBe(false);
+        });
+        it('should return immediately if all tasks are already finalized', async () => {
+            const t1 = await queue.enqueue('foo', { foo: 'immediate' });
+            const d1 = await queue.dequeue();
+            await queue.complete(d1);
+            const timer = Timer.startNew();
+            const result = await queue.waitForTasks([t1.id], { timeout: 1000 });
+            expect(result.cancelled).toBe(false);
+            expect(timer.milliseconds).toBeLessThan(100);
+        });
+        it('should handle a mix of active and archived tasks', async () => {
+            const queueProvider = injector.resolve(TaskQueueProvider);
+            const archiveQueue = queueProvider.get(`archive-test-${crypto.randomUUID()}`, {
+                retention: 0, // Archive immediately
+            });
+            const t1 = await archiveQueue.enqueue('foo', { foo: 'archived' });
+            const d1 = await archiveQueue.dequeue();
+            await archiveQueue.complete(d1);
+            // Run maintenance to move to archive
+            await archiveQueue.maintenance();
+            const t2 = await archiveQueue.enqueue('foo', { foo: 'active' });
+            const d2 = await archiveQueue.dequeue();
+            await archiveQueue.complete(d2);
+            // t1 is archived, t2 is completed (active)
+            const result = await archiveQueue.waitForTasks([t1.id, t2.id], { timeout: 1000 });
+            expect(result.cancelled).toBe(false);
+            await archiveQueue.clear();
+        });
+        it('should return immediately for empty ids array', async () => {
+            const result = await queue.waitForTasks([], { timeout: 1000 });
+            expect(result.cancelled).toBe(false);
+        });
+        it('should wait for parent task to reach finalized state after child completion', async () => {
+            const parent = await queue.enqueue('parent', { value: 'parent' });
+            const dParent = await queue.dequeue({ types: ['parent'] });
+            expect(dParent).toBeDefined();
+            // Spawn a child
+            const [child] = await queue.enqueueMany([{ type: 'child', data: { value: 'child' }, parentId: parent.id, completeAfter: [] }], { returnTasks: true });
+            expect(child).toBeDefined();
+            // Re-enqueuing with dependency:
+            const parentWithDep = await queue.enqueue('parent-dep', { value: 'parent' }, { completeAfter: [child.id] });
+            let dParent2;
+            for (let i = 0; i < 10; i++) {
+                dParent2 = await queue.dequeue({ types: ['parent-dep'] });
+                if (dParent2)
+                    break;
+                await timeout(50);
+            }
+            expect(dParent2?.id).toBe(parentWithDep.id);
+            // Complete parent (it will move to Waiting because of completeAfter)
+            await queue.complete(dParent2);
+            const checkParent = await queue.getTask(parentWithDep.id);
+            expect(checkParent?.status).toBe(TaskStatus.WaitingChildren);
+            void (async () => {
+                await timeout(100);
+                const dChild = await queue.dequeue({ types: ['child'] });
+                await queue.complete(dChild);
+            })();
+            await queue.waitForTasks([parentWithDep.id], { timeout: 2000 });
+            const finalParent = await queue.getTask(parentWithDep.id);
+            expect(finalParent?.status).toBe(TaskStatus.Completed);
+        });
+    });
 });

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

@@ -37,11 +37,12 @@ describe('Worker & Base Class Tests', () => {
         });
         // Wait until 2 tasks are processed
         for (let i = 0; i < 50; i++) {
-            if (processed.length === 2)
+            if (processed.length == 2)
                 break;
             await timeout(20);
         }
         token.set(); // Stop worker
+        await queue.waitForTasks([t1.id, t2.id], { interval: 50, timeout: 1000 });
         expect(processed).toContain(1);
         expect(processed).toContain(2);
         expect(processed.length).toBe(2);
@@ -55,7 +56,14 @@ describe('Worker & Base Class Tests', () => {
         queue.process({ cancellationSignal: token }, async () => {
             throw new Error('worker error');
         });
-        await timeout(50);
+        // Wait until task is processed (error recorded and status is Pending)
+        for (let i = 0; i < 50; i++) {
+            const updated = await queue.getTask(task.id);
+            if (updated?.tries == 1 && updated.status == TaskStatus.Pending) {
+                break;
+            }
+            await timeout(20);
+        }
         token.set();
         const updated = await queue.getTask(task.id);
         expect(updated?.status).toBe(TaskStatus.Pending); // Should retry
@@ -71,7 +79,7 @@ describe('Worker & Base Class Tests', () => {
             executed = true;
             return TaskProcessResult.Complete();
         });
-        await timeout(500);
+        await queue.waitForTasks([task.id], { timeout: 5000 });
         token.set();
         expect(executed).toBe(true);
         const updated = await queue.getTask(task.id);
@@ -83,17 +91,21 @@ describe('Worker & Base Class Tests', () => {
         const processed = new Set();
         queue.process({ cancellationSignal: token }, async (context) => {
             processed.add(context.id);
-            if (context.id === tFail.id) {
+            if (context.id == tFail.id) {
                 return TaskProcessResult.Fail(new Error('explicit fail'));
             }
-            if (context.id === tResched.id) {
+            if (context.id == tResched.id) {
                 return TaskProcessResult.RescheduleBy(1000);
             }
             return TaskProcessResult.Complete();
         });
+        // Wait until tasks are processed (error/reschedule recorded and status is Pending)
         for (let i = 0; i < 50; i++) {
-            if (processed.size === 2)
+            const uFail = await queue.getTask(tFail.id);
+            const uResched = await queue.getTask(tResched.id);
+            if (uFail?.tries == 1 && uResched?.status == TaskStatus.Pending && (uResched?.scheduleTimestamp ?? 0) > Date.now()) {
                 break;
+            }
             await timeout(20);
         }
         token.set();
@@ -122,20 +134,31 @@ describe('Worker & Base Class Tests', () => {
             // Other queue spawn
             const otherQueue = injector.resolve(TaskQueueProvider).get('other-queue');
             const otherChild = await context.spawn(otherQueue, 'other', { x: 1 });
-            expect(otherChild.parentId).toBe(task.id);
             expect(otherChild.namespace).toBe('other-queue');
-            const otherChildren = await context.spawnMany(otherQueue, [{ type: 'other', data: { x: 2 } }]);
-            expect(otherChildren[0]?.parentId).toBe(task.id);
+            await context.spawnMany(otherQueue, [{ type: 'other', data: { x: 2 } }]);
             executed = true;
             return TaskProcessResult.Complete();
         });
-        for (let i = 0; i < 50; i++) {
-            if (executed)
-                break;
-            await timeout(20);
-        }
+        // Complete children so parent can finalize
+        void (async () => {
+            while (!executed) {
+                await timeout(50);
+            }
+            // At this point parent should be WaitingChildren if children are not done
+            const midTask = await queue.getTask(task.id);
+            expect(midTask?.status).toBe(TaskStatus.WaitingChildren);
+            while (true) {
+                const dChild = await queue.dequeue({ types: ['child'] });
+                if (!dChild)
+                    break;
+                await queue.complete(dChild);
+            }
+        })();
+        await queue.waitForTasks([task.id], { interval: 50, timeout: 5000 });
         token.set();
         expect(executed).toBe(true);
+        const finalTask = await queue.getTask(task.id);
+        expect(finalTask?.status).toBe(TaskStatus.Completed);
     });
     it('should correctly report isFinalAttempt in TaskContext', async () => {
         const queueProvider = injector.resolve(TaskQueueProvider);
@@ -150,13 +173,13 @@ describe('Worker & Base Class Tests', () => {
         const finalAttemptValues = [];
         testQueue.process({ cancellationSignal: token }, async (context) => {
             finalAttemptValues.push(context.isFinalAttempt);
-            if (context.attempt === 1) {
+            if (context.attempt == 1) {
                 throw new Error('fail first attempt');
             }
             return TaskProcessResult.Complete();
         });
         for (let i = 0; i < 100; i++) {
-            if (finalAttemptValues.length === 2)
+            if (finalAttemptValues.length == 2)
                 break;
             testQueue.notify();
             await timeout(20);

package/task-queue/tests/zombie-parent.test.d.ts

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

package/task-queue/tests/zombie-parent.test.js

@@ -0,0 +1,45 @@
+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('Zombie Parent Deadlock', () => {
+    let injector;
+    let queue;
+    beforeAll(async () => {
+        ({ injector } = await setupIntegrationTest({ modules: { taskQueue: true } }));
+    });
+    beforeEach(() => {
+        const queueProvider = injector.resolve(TaskQueueProvider);
+        const queueName = `zombie-queue-${Date.now()}-${Math.random()}`;
+        queue = queueProvider.get(queueName, {
+            visibilityTimeout: 1000,
+        });
+    });
+    afterEach(async () => {
+        await queue.clear();
+    });
+    afterAll(async () => {
+        await injector?.dispose();
+    });
+    it('should resolve parent even if child fails (failFast: false)', async () => {
+        const parent = await queue.enqueue('parent', {});
+        const dParent = await queue.dequeue();
+        // Spawn a child that will fail. Parent has failFast: false by default.
+        const [child] = await queue.enqueueMany([{ type: 'child', data: {}, parentId: parent.id, failFast: false }], { returnTasks: true });
+        await queue.complete(dParent);
+        // Parent should be WaitingChildren
+        const uParent = await queue.getTask(parent.id);
+        expect(uParent?.status).toBe(TaskStatus.WaitingChildren);
+        // Fail the child fatally
+        const dChild = await queue.dequeue();
+        await queue.fail(dChild, new Error('child failed'), { fatal: true });
+        // Verify child is Dead
+        const uChild = await queue.getTask(child.id);
+        expect(uChild?.status).toBe(TaskStatus.Dead);
+        // Wait a bit for dependency resolution
+        await timeout(200);
+        // Parent should NOT be stuck. It should transition to Completed because the child is terminal.
+        const fParent = await queue.getTask(parent.id);
+        expect(fParent?.status).toBe(TaskStatus.Completed);
+    });
+});

package/task-queue/tests/zombie-recovery.test.d.ts

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

package/task-queue/tests/zombie-recovery.test.js

@@ -0,0 +1,51 @@
+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('Zombie Recovery Race Condition', () => {
+    let injector;
+    let queue;
+    beforeAll(async () => {
+        ({ injector } = await setupIntegrationTest({ modules: { taskQueue: true } }));
+    });
+    beforeEach(() => {
+        const queueProvider = injector.resolve(TaskQueueProvider);
+        const queueName = `zombie-recovery-queue-${Date.now()}-${Math.random()}`;
+        queue = queueProvider.get(queueName, {
+            visibilityTimeout: 100, // Very short visibility timeout
+            retryDelayMinimum: 0,
+        });
+    });
+    afterEach(async () => {
+        await queue.clear();
+    });
+    afterAll(async () => {
+        await injector?.dispose();
+    });
+    it('should NOT prematurely complete a recovered parent when children finish', async () => {
+        // 1. Enqueue parent
+        const parent = await queue.enqueue('parent', {});
+        // 2. Dequeue parent (it is now Running, startTimestamp is set)
+        const dParent = await queue.dequeue();
+        expect(dParent?.id).toBe(parent.id);
+        expect(dParent?.startTimestamp).not.toBeNull();
+        // 3. Parent spawns a child that it waits for
+        const [child] = await queue.enqueueMany([{ type: 'child', data: {}, parentId: parent.id }], { returnTasks: true });
+        // 4. Simulate crash: Wait for visibility timeout so it becomes a zombie
+        await timeout(200);
+        // 5. Run maintenance to recover the zombie parent
+        await queue.maintenance();
+        // Verify it was recovered to Pending
+        const recoveredParent = await queue.getTask(parent.id);
+        expect(recoveredParent?.status).toBe(TaskStatus.Pending);
+        // If the bug exists, startTimestamp is still set here.
+        // 6. Complete the child while parent is still Pending
+        const dChild = await queue.dequeue({ types: ['child'] });
+        await queue.complete(dChild);
+        // 7. Verify parent status
+        // BUG: evaluateTaskStatus will see unresolvedCompleteDependencies=0 and startTimestamp != null,
+        // and incorrectly transition the Pending parent to Completed.
+        const finalParent = await queue.getTask(parent.id);
+        expect(finalParent?.status).toBe(TaskStatus.Pending); // It should still be pending execution!
+    });
+});