@tstdl/base 0.93.141 → 0.93.142

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

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

@@ -10,7 +10,7 @@ describe('Extensive Task Queue Dependency Tests', () => {
     });
     beforeEach(() => {
         const queueProvider = injector.resolve(TaskQueueProvider);
-        const queueName = `extensive-dep-queue-${Date.now()}-${Math.random()}`;
+        const queueName = `extensive-dep-queue-${crypto.randomUUID()}`;
         queue = queueProvider.get(queueName, {
             visibilityTimeout: 1000,
         });
@@ -21,16 +21,6 @@ describe('Extensive Task Queue Dependency Tests', () => {
     afterAll(async () => {
         await injector?.dispose();
     });
-    async function waitForStatus(id, status) {
-        for (let i = 0; i < 100; i++) {
-            const task = await queue.getTask(id);
-            if (task?.status === status)
-                return;
-            await timeout(50);
-        }
-        const finalTask = await queue.getTask(id);
-        throw new Error(`Task ${id} did not reach status ${status}. Current status: ${finalTask?.status}`);
-    }
     async function completeTask(type) {
         const dequeued = await queue.dequeue({ types: [type] });
         if (!dequeued)
@@ -56,14 +46,13 @@ describe('Extensive Task Queue Dependency Tests', () => {
         expect(taskF.status).toBe(TaskStatus.Waiting);
         // 1. Complete A
         await completeTask('A');
-        await waitForStatus(taskB.id, TaskStatus.Pending);
-        await waitForStatus(taskC.id, TaskStatus.Pending);
+        await queue.waitForTasks([taskB.id, taskC.id], { statuses: [TaskStatus.Pending] });
         // 2. Complete B
         await completeTask('B');
-        await waitForStatus(taskD.id, TaskStatus.Pending);
+        await queue.waitForTasks([taskD.id], { statuses: [TaskStatus.Pending] });
         // 3. Complete C
         await completeTask('C');
-        await waitForStatus(taskE.id, TaskStatus.Pending);
+        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);
@@ -73,7 +62,51 @@ describe('Extensive Task Queue Dependency Tests', () => {
         expect((await queue.getTask(taskF.id))?.status).toBe(TaskStatus.Waiting);
         // 5. Complete E
         await completeTask('E');
-        await waitForStatus(taskF.id, TaskStatus.Pending);
+        await queue.waitForTasks([taskF.id], { statuses: [TaskStatus.Pending] });
+    });
+    it('should respect failFast = false (continue other branches)', async () => {
+        const taskA = await queue.enqueue('A', {});
+        const taskB = await queue.enqueue('B', {}, { scheduleAfter: [taskA.id], failFast: 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 failFast 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', {});
@@ -81,12 +114,11 @@ describe('Extensive Task Queue Dependency Tests', () => {
         const taskC = await queue.enqueue('C', {}, { scheduleAfter: [taskA.id] });
         const taskD = await queue.enqueue('D', {}, { scheduleAfter: [taskB.id, taskC.id] });
         await completeTask('A');
-        await waitForStatus(taskB.id, TaskStatus.Pending);
-        await waitForStatus(taskC.id, TaskStatus.Pending);
+        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 waitForStatus(taskD.id, TaskStatus.Pending);
+        await queue.waitForTasks([taskD.id], { statuses: [TaskStatus.Pending] });
     });
     it('should handle Deep Chain (A -> B -> C -> D)', async () => {
         const taskA = await queue.enqueue('A', {});
@@ -94,11 +126,11 @@ describe('Extensive Task Queue Dependency Tests', () => {
         const taskC = await queue.enqueue('C', {}, { scheduleAfter: [taskB.id] });
         const taskD = await queue.enqueue('D', {}, { scheduleAfter: [taskC.id] });
         await completeTask('A');
-        await waitForStatus(taskB.id, TaskStatus.Pending);
+        await queue.waitForTasks([taskB.id], { statuses: [TaskStatus.Pending] });
         await completeTask('B');
-        await waitForStatus(taskC.id, TaskStatus.Pending);
+        await queue.waitForTasks([taskC.id], { statuses: [TaskStatus.Pending] });
         await completeTask('C');
-        await waitForStatus(taskD.id, TaskStatus.Pending);
+        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', {});
@@ -110,7 +142,7 @@ describe('Extensive Task Queue Dependency Tests', () => {
             expect((await queue.getTask(taskC.id))?.status).toBe(TaskStatus.Waiting);
         }
         await completeTask('B49');
-        await waitForStatus(taskC.id, TaskStatus.Pending);
+        await queue.waitForTasks([taskC.id], { statuses: [TaskStatus.Pending] });
     });
     it('should handle deep tree with branching and merging', async () => {
         const taskA = await queue.enqueue('A', {});
@@ -123,13 +155,13 @@ describe('Extensive Task Queue Dependency Tests', () => {
         await completeTask('A');
         await completeTask('B1');
         await completeTask('B2');
-        await waitForStatus(taskC.id, TaskStatus.Pending);
+        await queue.waitForTasks([taskC.id], { statuses: [TaskStatus.Pending] });
         await completeTask('C');
-        await waitForStatus(taskD1.id, TaskStatus.Pending);
-        await waitForStatus(taskD2.id, TaskStatus.Pending);
+        await queue.waitForTasks([taskD1.id], { statuses: [TaskStatus.Pending] });
+        await queue.waitForTasks([taskD2.id], { statuses: [TaskStatus.Pending] });
         await completeTask('D1');
         await completeTask('D2');
-        await waitForStatus(taskE.id, TaskStatus.Pending);
+        await queue.waitForTasks([taskE.id], { statuses: [TaskStatus.Pending] });
     });
     it('should handle fail-fast cascade', async () => {
         const taskA = await queue.enqueue('A', {});
@@ -139,10 +171,7 @@ describe('Extensive Task Queue Dependency Tests', () => {
         const taskE = await queue.enqueue('E', {}, { scheduleAfter: [taskC.id, taskD.id], failFast: true });
         const dA = await queue.dequeue({ types: ['A'] });
         await queue.fail(dA, new Error('fatal'), { fatal: true });
-        await waitForStatus(taskB.id, TaskStatus.Dead);
-        await waitForStatus(taskC.id, TaskStatus.Dead);
-        await waitForStatus(taskD.id, TaskStatus.Dead);
-        await waitForStatus(taskE.id, TaskStatus.Dead);
+        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', {});
@@ -154,6 +183,6 @@ describe('Extensive Task Queue Dependency Tests', () => {
         await timeout(100);
         expect((await queue.getTask(taskC.id))?.status).toBe(TaskStatus.Waiting);
         await completeTask('B');
-        await waitForStatus(taskC.id, TaskStatus.Pending);
+        await queue.waitForTasks([taskC.id], { statuses: [TaskStatus.Pending] });
     });
 });