@tstdl/base 0.93.140 → 0.93.141

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

@@ -1,7 +1,6 @@
 import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it } from 'vitest';
-import { DependencyJoinMode, TaskQueueProvider, TaskStatus } from '../../task-queue/index.js';
+import { TaskQueueProvider, TaskStatus } from '../../task-queue/index.js';
 import { setupIntegrationTest } from '../../testing/index.js';
-import { currentTimestamp } from '../../utils/date-time.js';
 import { timeout } from '../../utils/timing.js';
 describe('Complex Queue Scenarios', () => {
     let injector;
@@ -37,19 +36,15 @@ describe('Complex Queue Scenarios', () => {
             const task = await queue.getTask(id);
             if (task?.status === status)
                 return;
-            await queue.processPendingFanIn();
             await timeout(10);
         }
     }
     describe('Complex Dependencies', () => {
         it('should handle Diamond Dependency (A -> B, A -> C, (B&C) -> D)', async () => {
-            // D waits for B and C
-            const taskD = await queue.enqueue('D', {}, { scheduleAfterTags: ['tag-b', 'tag-c'] });
-            // B and C wait for A
-            const taskB = await queue.enqueue('B', {}, { tags: ['tag-b'], scheduleAfterTags: ['tag-a'] });
-            const taskC = await queue.enqueue('C', {}, { tags: ['tag-c'], scheduleAfterTags: ['tag-a'] });
-            // A runs first
-            const taskA = await queue.enqueue('A', {}, { tags: ['tag-a'] });
+            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] });
             expect(taskD.status).toBe(TaskStatus.Waiting);
             expect(taskB.status).toBe(TaskStatus.Waiting);
             expect(taskC.status).toBe(TaskStatus.Waiting);
@@ -62,8 +57,6 @@ describe('Complex Queue Scenarios', () => {
             // Process B
             const dB = await queue.dequeue({ types: ['B'] });
             await queue.complete(dB);
-            await timeout(20);
-            await queue.processPendingFanIn();
             // D still waiting (needs C)
             const uD2 = await queue.getTask(taskD.id);
             expect(uD2?.status).toBe(TaskStatus.Waiting);
@@ -76,231 +69,54 @@ describe('Complex Queue Scenarios', () => {
             expect(uD3?.status).toBe(TaskStatus.Pending);
         });
         it('should handle Deep Chain (A -> B -> C -> D)', async () => {
-            const D = await queue.enqueue('D', {}, { scheduleAfterTags: ['C'] });
-            const C = await queue.enqueue('C', {}, { tags: ['C'], scheduleAfterTags: ['B'] });
-            const B = await queue.enqueue('B', {}, { tags: ['B'], scheduleAfterTags: ['A'] });
-            const A = await queue.enqueue('A', {}, { tags: ['A'] });
-            // Run A
+            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 queue.complete((await queue.dequeue({ types: ['A'] })));
-            await waitForStatus(B.id, TaskStatus.Pending);
-            // Run B
+            await waitForStatus(taskB.id, TaskStatus.Pending);
             await queue.complete((await queue.dequeue({ types: ['B'] })));
-            await waitForStatus(C.id, TaskStatus.Pending);
-            // Run C
+            await waitForStatus(taskC.id, TaskStatus.Pending);
             await queue.complete((await queue.dequeue({ types: ['C'] })));
-            await waitForStatus(D.id, TaskStatus.Pending);
-            expect((await queue.getTask(D.id))?.status).toBe(TaskStatus.Pending);
+            await waitForStatus(taskD.id, TaskStatus.Pending);
         });
-        it('should propagate cancellation down the dependency tree', async () => {
-            // Use parentId for explicit tree structure which `cancel` supports
-            const root = await queue.enqueue('root', {});
-            const child = await queue.enqueue('child', {}, { parentId: root.id });
-            const grandChild = await queue.enqueue('grand', {}, { parentId: child.id });
-            await queue.cancel(root.id);
-            expect((await queue.getTask(root.id))?.status).toBe(TaskStatus.Cancelled);
-            expect((await queue.getTask(child.id))?.status).toBe(TaskStatus.Cancelled);
-            expect((await queue.getTask(grandChild.id))?.status).toBe(TaskStatus.Cancelled);
+        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);
         });
     });
-    describe('Scheduling & Priorities', () => {
-        it('should promote priority of old pending tasks (Aging)', async () => {
+    describe('Other Scenarios', () => {
+        it('should handle priority aging', async () => {
             const t1 = await queue.enqueue('low', {}, { priority: 2000 });
-            // Wait for aging interval (50ms)
-            await timeout(60);
-            await queue.maintenance();
-            const updated = await queue.getTask(t1.id);
-            // Default step is 10. 2000 - 10 = 1990
-            expect(updated?.priority).toBe(1990);
-        });
-        it('should respect exponential backoff on failure', async () => {
-            const task = await queue.enqueue('fail-test', {});
-            // Try 1
-            const d1 = await queue.dequeue();
-            await queue.fail(d1, new Error('fail 1'));
-            const u1 = await queue.getTask(task.id);
-            expect(u1?.tries).toBe(1);
-            const delay1 = u1.scheduleTimestamp - currentTimestamp();
-            expect(delay1).toBeGreaterThan(20); // Approx check
-            // Force reschedule to now
-            await queue.reschedule(task.id, currentTimestamp());
-            // Try 2
-            const d2 = await queue.dequeue();
-            await queue.fail(d2, new Error('fail 2'));
-            const u2 = await queue.getTask(task.id);
-            expect(u2?.tries).toBe(2);
-            const now = currentTimestamp();
-            expect(u2.scheduleTimestamp > now + 50).toBe(true);
-        });
-    });
-    describe('Rate Limiting & Concurrency', () => {
-        it('should limit burst dequeue rate', async () => {
-            // Rate limit 5, interval 100ms
-            await queue.enqueueMany(Array.from({ length: 10 }, (_, i) => ({ type: 'burst', data: { i } })));
-            // Request burstCapacity (5)
-            const batch1 = await queue.dequeueMany(5);
-            expect(batch1.length).toBe(5);
-            // Try immediately again
-            const batch2 = await queue.dequeueMany(1);
-            expect(batch2.length).toBe(0); // Rate limited
-            // Wait for refill
-            await timeout(300);
-            const batch3 = await queue.dequeueMany(5);
-            expect(batch3.length).toBe(5); // Refilled
-        });
-        it('should respect global concurrency limit', async () => {
-            const queueProvider = injector.resolve(TaskQueueProvider);
-            const limitQueue = queueProvider.get(`limit-${Date.now()}`, { globalConcurrency: 2 });
-            await limitQueue.enqueueMany([
-                { type: 'c', data: {} },
-                { type: 'c', data: {} },
-                { type: 'c', data: {} },
-            ]);
-            const t1 = await limitQueue.dequeue();
-            const t2 = await limitQueue.dequeue();
-            const t3 = await limitQueue.dequeue();
-            expect(t1).toBeDefined();
-            expect(t2).toBeDefined();
-            expect(t3).toBeUndefined(); // Max concurrency reached
-            await limitQueue.complete(t1);
-            const t3_retry = await limitQueue.dequeue();
-            expect(t3_retry).toBeDefined();
-            await limitQueue.clear();
-        });
-    });
-    describe('Archival & Maintenance', () => {
-        it('should archive completed tasks after retention period', async () => {
-            const qProvider = injector.resolve(TaskQueueProvider);
-            const archiveQueue = qProvider.get(`archive-${Date.now()}-${Math.random()}`, { retention: 100 });
-            const task = await archiveQueue.enqueue('archive-me', {});
-            const d = await archiveQueue.dequeue();
-            await archiveQueue.complete(d);
-            // Verify it is in main table
-            const before = await archiveQueue.getTask(task.id);
-            expect(before).toBeDefined();
-            expect(before?.status).toBe(TaskStatus.Completed);
-            expect(before.completeTimestamp > 0).toBe(true);
-            // Wait for retention (50ms).
-            await timeout(60);
-            await archiveQueue.maintenance();
-            // Should move from main table to archive
-            const loaded = await archiveQueue.getTask(task.id);
-            expect(loaded).toBeDefined();
-            expect(loaded?.status).toBe(TaskStatus.Completed);
-            await archiveQueue.clear();
-        });
-        it('should prune expired pending tasks', async () => {
-            // Time to live: 50ms
-            const task = await queue.enqueue('expire-me', {}, { timeToLive: currentTimestamp() + 50 });
-            await timeout(60);
-            await queue.maintenance();
-            const updated = await queue.getTask(task.id);
-            expect(updated?.status).toBe(TaskStatus.Dead);
-            expect((updated?.error)['code']).toBe('Expired');
-        });
-        it('should retrieve task from archive', async () => {
-            // Manually insert into archive? We can't access archiveRepository directly.
-            // But we can use maintenance to force it.
-            // Wait, if the previous test failed, this might also fail.
-            // But let's try with a VERY clear scenario.
-            const task = await queue.enqueue('archive-retrieval-test', {});
-            const d = await queue.dequeue();
-            await queue.complete(d);
-            // Force move
-            await timeout(60);
+            const t2 = await queue.enqueue('high', {}, { priority: 1000 });
+            // Wait for aging to trigger
+            await timeout(100);
             await queue.maintenance();
-            // Verify retrieval
-            const fromArchive = await queue.getTask(task.id);
-            expect(fromArchive).toBeDefined();
-            expect(fromArchive?.status).toBe(TaskStatus.Completed);
-        });
-        it('should defer archival of parent tasks until children are archived', async () => {
-            const qProvider = injector.resolve(TaskQueueProvider);
-            const treeQueue = qProvider.get(`archive-tree-${Date.now()}`, { retention: 50 });
-            const parent = await treeQueue.enqueue('parent', {});
-            const child = await treeQueue.enqueue('child', {}, { parentId: parent.id });
-            const d1 = await treeQueue.dequeue();
-            const d2 = await treeQueue.dequeue();
-            await treeQueue.complete(d1);
-            await treeQueue.complete(d2);
-            // Wait for retention
-            await timeout(60);
-            // First maintenance: should archive child, but parent stays because child is still in main table (until it's deleted in the same tx maybe? No, loadMany happens before delete)
-            await treeQueue.maintenance();
-            const parentStillActive = await treeQueue.getTask(parent.id);
-            const childInArchive = await treeQueue.getTask(child.id);
-            // Verify child moved
-            expect(childInArchive).toBeDefined();
-            // Parent MUST still be in main table because child was present when archival query ran
-            expect(parentStillActive).toBeDefined();
-            // Second maintenance: should now archive parent because child is gone from main table
-            await treeQueue.maintenance();
-            const finalParent = await treeQueue.getTask(parent.id);
-            expect(finalParent).toBeDefined(); // Still defined (getTask checks both main and archive)
-            // We need to check if it's REALLY archived.
-            // We can use the #repository directly if we were in the class, but here we can check if it moved by checking against the main table?
-            // Actually getTask is implemented as:
-            /*
-            const active = await this.#repository.tryLoadByQuery({ namespace: this.#namespace, id });
-            if (isDefined(active)) return active;
-            return await this.#archiveRepository.tryLoadByQuery({ namespace: this.#namespace, id });
-            */
-            await treeQueue.clear();
-        });
-    });
-    describe('Batch & Bulk Operations', () => {
-        it('should enqueue and dequeue large batches', async () => {
-            const items = Array.from({ length: 50 }, (_, i) => ({ type: 'bulk', data: { i } }));
-            const queueProvider = injector.resolve(TaskQueueProvider);
-            const bulkQueue = queueProvider.get(`bulk-${Date.now()}`, { rateLimit: 100 });
-            await bulkQueue.enqueueMany(items);
-            const count = await bulkQueue.countByTags([]); // All -> 0 because empty intersection
-            expect(count).toBe(0);
-            const batch = await bulkQueue.dequeueMany(50);
-            expect(batch.length).toBe(50);
-            await bulkQueue.completeMany(batch);
-            await bulkQueue.clear();
-        });
-        it('should handle idempotency window', async () => {
-            const key = 'idem-test';
-            const t1 = await queue.enqueue('t', { v: 1 }, { idempotencyKey: key });
-            const t2 = await queue.enqueue('t', { v: 2 }, { idempotencyKey: key });
-            expect(t1.id).toBe(t2.id); // Deduplicated
-            const t3 = await queue.enqueue('t', { v: 3 }, { idempotencyKey: key, replace: true });
-            expect(t3.id).not.toBe(t1.id); // Replaced
-            expect(t3.data['v']).toBe(3);
-        });
-    });
-    describe('Edge Cases', () => {
-        it('should not fan-in if dependency fails and failFast=false', async () => {
-            const dependent = await queue.enqueue('dep', {}, { scheduleAfterTags: ['fail-tag'], failFast: false });
-            const prereq = await queue.enqueue('pre', {}, { tags: ['fail-tag'] });
-            const d = await queue.dequeue({ types: ['pre'] });
-            await queue.fail(d, new Error('fail'));
-            await queue.processPendingFanIn();
-            // Retry check because fan-in might be processed by background worker asynchronously
-            let u = await queue.getTask(dependent.id);
-            for (let i = 0; i < 5; i++) {
-                if (u?.status == TaskStatus.Waiting)
-                    break;
-                await timeout(10);
-                u = await queue.getTask(dependent.id);
+            const u1 = await queue.getTask(t1.id);
+            const u2 = await queue.getTask(t2.id);
+            expect(u1.priority).toBeLessThan(2000);
+            expect(u2.priority).toBeLessThan(1000);
+        });
+        it('should handle rate limiting', async () => {
+            // Limit is 5 per 200ms
+            for (let i = 0; i < 10; i++) {
+                await queue.enqueue('task', { i });
             }
-            expect(u?.status).toBe(TaskStatus.Waiting); // Should still be waiting because dependency didn't Complete
-        });
-        it('should handle mixed AND/OR dependencies', async () => {
-            const dep = await queue.enqueue('dep', {}, {
-                scheduleAfterTags: ['A', 'B'],
-                dependencyJoinMode: DependencyJoinMode.Or,
-            });
-            const A = await queue.enqueue('A', {}, { tags: ['A'] });
-            await queue.complete((await queue.dequeue({ types: ['A'] })));
-            await waitForStatus(dep.id, TaskStatus.Pending);
-            expect((await queue.getTask(dep.id))?.status).toBe(TaskStatus.Pending);
-        });
-        it('should not reschedule if task is not running', async () => {
-            const task = await queue.enqueue('t', {});
-            const res = await queue.touch(task);
-            expect(res).toBeUndefined();
+            const batch1 = await queue.dequeueMany(10);
+            expect(batch1.length).toBe(5);
+            await timeout(500); // Increased from 250
+            const batch2 = await queue.dequeueMany(10);
+            expect(batch2.length).toBe(5);
         });
     });
 });

package/task-queue/tests/coverage-branch.test.d.ts

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