@tstdl/base 0.93.87 → 0.93.90

package/queue/tests/queue.test.js

@@ -1,623 +0,0 @@
-import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it } from 'vitest';
-import { configurePostgresCircuitBreaker, migratePostgresCircuitBreaker } from '../../circuit-breaker/postgres/module.js';
-import { Injector, runInInjectionContext } from '../../injector/index.js';
-import { ConsoleLogTransport, LogFormatter, Logger, LogTransport, PrettyPrintLogFormatter } from '../../logger/index.js';
-import { configureLocalMessageBus } from '../../message-bus/index.js';
-import { configureOrm } from '../../orm/server/index.js';
-import { QueueProvider, TaskState, UniqueTagStrategy } from '../../queue/index.js';
-import { configurePostgresQueue, migratePostgresQueueSchema } from '../../queue/postgres/index.js';
-import * as configParser from '../../utils/config-parser.js';
-import { currentTimestamp } from '../../utils/date-time.js';
-import { timeout } from '../../utils/timing.js';
-/**
- * Encapsulates the boilerplate for setting up the integration environment.
- */
-async function setupIntegrationTest() {
-    const injector = new Injector('TestInjector');
-    injector.register(LogFormatter, { useToken: PrettyPrintLogFormatter });
-    injector.register(LogTransport, { useToken: ConsoleLogTransport });
-    // 2. Configuration
-    const dbConfig = {
-        host: configParser.string('DATABASE_HOST', '127.0.0.1'),
-        port: configParser.positiveInteger('DATABASE_PORT', 5432),
-        user: configParser.string('DATABASE_USER', 'tstdl'),
-        password: configParser.string('DATABASE_PASS', 'wf7rq6glrk5jykne'),
-        database: configParser.string('DATABASE_NAME', 'tstdl'),
-    };
-    // 3. Configure Modules
-    configureOrm({
-        repositoryConfig: { schema: 'test' },
-        connection: dbConfig,
-    });
-    configureLocalMessageBus();
-    configurePostgresQueue();
-    configurePostgresCircuitBreaker();
-    // 4. Run Migrations
-    // We need to resolve the module config once to ensure migrations run against the correct DB
-    await runInInjectionContext(injector, migratePostgresQueueSchema);
-    await runInInjectionContext(injector, migratePostgresCircuitBreaker);
-    return injector;
-}
-describe('Queue Integration Tests', () => {
-    let injector;
-    let queue;
-    let logger;
-    const queueName = `test-queue-${Date.now()}`;
-    // Helper to verify state in DB
-    async function assertTaskState(id, state, message) {
-        const task = await queue.get(id);
-        expect(task?.status, message).toBe(state);
-    }
-    beforeAll(async () => {
-        injector = await setupIntegrationTest();
-        logger = injector.resolve(Logger);
-        // 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.
-        const queueProvider = injector.resolve(QueueProvider);
-        queue = queueProvider.get(queueName, {
-            processTimeout: 5000,
-            retryDelayMinimum: 100, // Fast retries for testing
-            retryDelayGrowth: 1, // Linear/No growth for predictable tests
-        });
-        logger.info(`Queue initialized: ${queueName}`);
-    });
-    afterEach(async () => {
-        // Drain the queue to prevent state leakage between tests
-        await queue.clear();
-    });
-    afterAll(async () => {
-        try {
-            await queue.clear();
-            await injector.dispose();
-        }
-        catch (error) {
-            // Ignore known double-dispose issue from MessageBus interaction
-            if (error instanceof Error && error.message === 'MessageBus is disposed.') {
-                return;
-            }
-            throw error;
-        }
-    });
-    it('Basic FIFO Flow', async () => {
-        logger.info('--- Test: Basic FIFO Flow ---');
-        const t1 = await queue.enqueue({ value: 'first' });
-        const t2 = await queue.enqueue({ value: 'second' });
-        const d1 = await queue.dequeue();
-        expect(d1?.id).toBe(t1.id);
-        expect(d1?.data.value).toBe('first');
-        await queue.acknowledge(d1, { success: true });
-        await assertTaskState(t1.id, TaskState.Completed, 'Task 1 completed');
-        const d2 = await queue.dequeue();
-        expect(d2?.id).toBe(t2.id);
-        await queue.acknowledge(d2, { success: true });
-    });
-    it('Priorities', async () => {
-        logger.info('--- Test: Prioritization ---');
-        // Priority 1000 (default)
-        const low = await queue.enqueue({ value: 'low' });
-        // Priority 1
-        const high = await queue.enqueue({ value: 'high' }, { priority: 1 });
-        const first = await queue.dequeue();
-        expect(first?.id).toBe(high.id);
-        await queue.acknowledge(first);
-        const second = await queue.dequeue();
-        expect(second?.id).toBe(low.id);
-        await queue.acknowledge(second);
-    });
-    it('Deduplication (Unique Tags)', async () => {
-        logger.info('--- Test: Deduplication (Unique Tags) ---');
-        const tag = `unique-${Date.now()}`;
-        // 1. Initial Insert
-        const t1 = await queue.enqueue({ value: 'original' }, { tag, uniqueTag: UniqueTagStrategy.KeepOld });
-        // 2. KeepOld Strategy: Should return existing task, ignore new data
-        const t2 = await queue.enqueue({ value: 'ignored' }, { tag, uniqueTag: UniqueTagStrategy.KeepOld });
-        expect(t1.id, 'KeepOld returned same ID').toBe(t2.id);
-        const check1 = await queue.get(t1.id);
-        expect(check1?.data.value).toBe('original');
-        // 3. TakeNew Strategy: Should replace existing task with new data (new ID generated)
-        const t3 = await queue.enqueue({ value: 'updated' }, { tag, uniqueTag: UniqueTagStrategy.TakeNew });
-        expect(t1.id, 'TakeNew generated a NEW ID').not.toBe(t3.id);
-        // Old ID should be gone (updated to new ID)
-        const checkOld = await queue.get(t1.id);
-        expect(checkOld).toBeUndefined();
-        // New ID should have new data
-        const checkNew = await queue.get(t3.id);
-        expect(checkNew?.data.value).toBe('updated');
-        expect(checkNew?.tries).toBe(0);
-    });
-    it('Retries and Failures', async () => {
-        logger.info('--- Test: Retries and Dead Letter ---');
-        const task = await queue.enqueue({ value: 'fail-me' });
-        // Try 1
-        const attempt1 = await queue.dequeue();
-        expect(attempt1?.id).toBe(task.id);
-        await queue.fail(attempt1, { message: 'oops' });
-        // Force reschedule to now to bypass retryDelay
-        await queue.reschedule(task.id, Date.now());
-        // Try 2
-        const attempt2 = await queue.dequeue();
-        expect(attempt2?.id).toBe(task.id);
-        expect(attempt2?.tries).toBe(2);
-        // Fail fatally
-        await queue.fail(attempt2, { message: 'fatal error' }, true);
-        await assertTaskState(task.id, TaskState.Dead, 'Task is Dead after fatal error');
-    });
-    it('Hierarchy (Parent/Child)', async () => {
-        logger.info('--- Test: Hierarchy (Parent/Child) ---');
-        // A. Create Parent
-        const p = await queue.enqueue({ value: 'parent-manual' });
-        // B. Dequeue Parent
-        const pTask = await queue.dequeue();
-        expect(pTask?.id).toBe(p.id);
-        // C. Parent spawns child
-        const child = await queue.enqueue({ value: 'child-manual' }, { parentId: p.id });
-        // D. "Finish" Parent execution. It should enter WAITING.
-        await queue.acknowledge(pTask);
-        await assertTaskState(p.id, TaskState.Waiting, 'Parent entered WAITING state');
-        // E. Dequeue & Finish Child
-        const cTask = await queue.dequeue();
-        expect(cTask?.id).toBe(child.id);
-        await queue.acknowledge(cTask);
-        // F. Check Parent State -> PENDING (Fan-In triggered)
-        await assertTaskState(p.id, TaskState.Pending, 'Parent rescheduled (PENDING)');
-        // G. Dequeue Parent Again (Resume) & Finish
-        const pTaskResumed = await queue.dequeue();
-        expect(pTaskResumed?.id).toBe(p.id);
-        await queue.acknowledge(pTaskResumed);
-        await assertTaskState(p.id, TaskState.Completed, 'Parent COMPLETED');
-    });
-    it('Batching', async () => {
-        logger.info('--- Test: Batch Operations ---');
-        const batch = queue.batch();
-        for (let i = 0; i < 5; i++) {
-            batch.add({ value: `batch-${i}` });
-        }
-        const tasks = await batch.enqueue(true);
-        expect(tasks.length).toBe(5);
-        const dequeuedBatch = await queue.dequeueMany(5);
-        expect(dequeuedBatch.length).toBe(5);
-        await queue.acknowledgeMany(dequeuedBatch);
-        const leftover = await queue.dequeue();
-        expect(leftover).toBeUndefined();
-    });
-    it('Partial Success: Parent resumes after one child fails and another succeeds', async () => {
-        logger.info('--- Test: Partial Success ---');
-        // 1. Create Parent
-        const p = await queue.enqueue({ value: 'parent' });
-        // 2. Dequeue Parent
-        const pTask = await queue.dequeue();
-        expect(pTask?.id).toBe(p.id);
-        // 3. Parent spawns two children
-        const child1 = await queue.enqueue({ value: 'child-success' }, { parentId: p.id });
-        const child2 = await queue.enqueue({ value: 'child-fail' }, { parentId: p.id });
-        // 4. Acknowledge Parent -> Waiting
-        await queue.acknowledge(pTask);
-        await assertTaskState(p.id, TaskState.Waiting, 'Parent is WAITING');
-        // 5. Dequeue & Succeed Child 1
-        const c1Task = await queue.dequeue();
-        expect(c1Task?.id).toBe(child1.id);
-        await queue.acknowledge(c1Task);
-        // Parent should still be waiting
-        await assertTaskState(p.id, TaskState.Waiting, 'Parent still WAITING after first child');
-        // 6. Dequeue & Fail Child 2 (Fatal)
-        const c2Task = await queue.dequeue();
-        expect(c2Task?.id).toBe(child2.id);
-        await queue.fail(c2Task, { message: 'intentional failure' }, true);
-        // 7. Check Parent State -> PENDING (Woken up despite child failure)
-        await assertTaskState(p.id, TaskState.Pending, 'Parent woken up (PENDING) despite child failure');
-        // 8. Dequeue Parent Again & Complete
-        const pTaskResumed = await queue.dequeue();
-        expect(pTaskResumed?.id).toBe(p.id);
-        await queue.acknowledge(pTaskResumed);
-        await assertTaskState(p.id, TaskState.Completed, 'Parent COMPLETED successfully');
-    });
-    it('Acknowledge with pre-existing failed child: Parent completes', async () => {
-        logger.info('--- Test: Acknowledge with pre-existing failed child ---');
-        // 1. Create Parent
-        const p = await queue.enqueue({ value: 'parent-2' });
-        // 2. Dequeue Parent
-        const pTask = await queue.dequeue();
-        // 3. Parent spawns a child that fails
-        const child = await queue.enqueue({ value: 'child-fail-early' }, { parentId: p.id });
-        const cTask = await queue.dequeue();
-        await queue.fail(cTask, { message: 'fail early' }, true);
-        await assertTaskState(child.id, TaskState.Dead, 'Child is DEAD');
-        // 4. Parent acknowledges its own execution.
-        // It should COMPLETE now, even though child is dead, because there are no ACTIVE children.
-        await queue.acknowledge(pTask);
-        await assertTaskState(p.id, TaskState.Completed, 'Parent COMPLETED even with dead child');
-    });
-    it('Fan-In & Result Persistence', async () => {
-        logger.info('--- Test: Fan-In & Result Persistence ---');
-        // 1. Create Parent
-        const p = await queue.enqueue({ value: 'parent' });
-        // 2. Dequeue Parent
-        const pTask = await queue.dequeue();
-        expect(pTask?.id).toBe(p.id);
-        // 3. Parent spawns children
-        await queue.enqueueMany([
-            { data: { value: 'child-1' }, parentId: p.id },
-            { data: { value: 'child-2' }, parentId: p.id },
-        ]);
-        // 4. Acknowledge Parent with a result. This result should be saved as 'state' since we move to Waiting.
-        const partialResult = { step: 'children-spawned' };
-        await queue.acknowledge(pTask, partialResult);
-        // 5. Verify Parent is WAITING and has the state
-        const pWaiting = await queue.get(p.id);
-        expect(pWaiting?.status).toBe(TaskState.Waiting);
-        expect(pWaiting?.state).toEqual(partialResult);
-        // 6. Complete children
-        const c1 = await queue.dequeue();
-        const c2 = await queue.dequeue();
-        await queue.acknowledge(c1);
-        await queue.acknowledge(c2);
-        // 7. Verify Parent is PENDING
-        await assertTaskState(p.id, TaskState.Pending, 'Parent woken up');
-        // 8. Dequeue Parent again and check its state
-        const pResumed = await queue.dequeue();
-        expect(pResumed?.id).toBe(p.id);
-        expect(pResumed?.state).toEqual(partialResult);
-        await queue.acknowledge(pResumed);
-        await assertTaskState(p.id, TaskState.Completed, 'Parent COMPLETED');
-    });
-    it('Circuit Breaker Probe Logic', async () => {
-        logger.info('--- Test: Circuit Breaker Probe Logic ---');
-        const cbQueueName = `cb-test-${Date.now()}`;
-        const queueProvider = injector.resolve(QueueProvider);
-        const cbQueue = queueProvider.get(cbQueueName, {
-            circuitBreakerThreshold: 2,
-            circuitBreakerResetTimeout: 500,
-        });
-        // 1. Trip the breaker (Threshold = 2)
-        await cbQueue.enqueueMany([
-            { data: { value: 'fail-1' } },
-            { data: { value: 'fail-2' } },
-        ]);
-        const fail1 = await cbQueue.dequeue();
-        const fail2 = await cbQueue.dequeue();
-        await cbQueue.fail(fail1, 'fail');
-        await cbQueue.fail(fail2, 'fail');
-        // 2. Enqueue more tasks
-        await cbQueue.enqueueMany([
-            { data: { value: 't1' } },
-            { data: { value: 't2' } },
-        ]);
-        // 3. Dequeue should return nothing while Open
-        const tasksOpen = await cbQueue.dequeueMany(5);
-        expect(tasksOpen.length).toBe(0);
-        // 4. Wait for reset timeout
-        await timeout(600);
-        // 5. First dequeue after timeout should be a PROBE (only 1 task)
-        const tasksProbe = await cbQueue.dequeueMany(5);
-        expect(tasksProbe.length).toBe(1);
-        expect(tasksProbe[0]?.data.value).toBe('t1');
-        // 6. While Half-Open (waiting for probe result), subsequent dequeues should return nothing
-        const tasksHalfOpen = await cbQueue.dequeueMany(5);
-        expect(tasksHalfOpen.length).toBe(0);
-        // 7. Acknowledge probe -> Breaker closes
-        await cbQueue.acknowledge(tasksProbe[0]);
-        // 8. Now closed, we should get the rest
-        const remaining = await cbQueue.dequeueMany(5);
-        expect(remaining.length).toBe(1);
-        expect(remaining[0]?.data.value).toBe('t2');
-        await cbQueue.clear();
-    });
-    it('Bulk failMany & Circuit Breaker', async () => {
-        logger.info('--- Test: Bulk failMany & Circuit Breaker ---');
-        const cbQueueName = `bulk-fail-test-${Date.now()}`;
-        const queueProvider = injector.resolve(QueueProvider);
-        const cbQueue = queueProvider.get(cbQueueName, {
-            circuitBreakerThreshold: 5,
-            circuitBreakerResetTimeout: 5000,
-            maxTries: 1, // Fail immediately
-        });
-        // 1. Enqueue 5 tasks (Threshold)
-        const tasks = await cbQueue.enqueueMany([
-            { data: { value: 'f1' } },
-            { data: { value: 'f2' } },
-            { data: { value: 'f3' } },
-            { data: { value: 'f4' } },
-            { data: { value: 'f5' } },
-        ], { returnTasks: true });
-        // 2. Dequeue all
-        const dequeued = await cbQueue.dequeueMany(5);
-        expect(dequeued.length).toBe(5);
-        // 3. Fail all
-        await cbQueue.failMany(dequeued, ['e1', 'e2', 'e3', 'e4', 'e5']);
-        // 4. Verify all are Dead
-        for (const t of tasks) {
-            const stored = await cbQueue.get(t.id);
-            expect(stored?.status, `Task ${t.id} is dead`).toBe(TaskState.Dead);
-            expect(stored?.error?.message).toMatch(/e\d/);
-        }
-        // 5. Verify Circuit Breaker is OPEN
-        // Enqueue a new task
-        await cbQueue.enqueue({ value: 'probe' });
-        // Try to dequeue - should fail because CB is open (Threshold 5 reached by batch of 5)
-        const probe = await cbQueue.dequeue();
-        expect(probe).toBeUndefined();
-        await cbQueue.clear();
-    });
-    it('Bulk failMany with Fan-In', async () => {
-        logger.info('--- Test: Bulk failMany with Fan-In ---');
-        // 1. Create Parent
-        const p = await queue.enqueue({ value: 'parent-bulk' });
-        const pTask = await queue.dequeue();
-        // 2. Create Children
-        const children = await queue.enqueueMany([
-            { data: { value: 'c1' }, parentId: p.id },
-            { data: { value: 'c2' }, parentId: p.id },
-            { data: { value: 'c3' }, parentId: p.id },
-        ], { returnTasks: true });
-        await queue.acknowledge(pTask); // Parent -> Waiting
-        // 3. Dequeue Children
-        const dequeuedChildren = await queue.dequeueMany(3);
-        expect(dequeuedChildren.length).toBe(3);
-        // 4. Fail all children (Fatal)
-        const fiQueueName = `fanin-test-${Date.now()}`;
-        const queueProvider = injector.resolve(QueueProvider);
-        const fiQueue = queueProvider.get(fiQueueName, {
-            maxTries: 1,
-        });
-        const p2 = await fiQueue.enqueue({ value: 'parent-fi' });
-        const p2Task = await fiQueue.dequeue();
-        const children2 = await fiQueue.enqueueMany([
-            { data: { value: 'c1' }, parentId: p2.id },
-            { data: { value: 'c2' }, parentId: p2.id },
-        ], { returnTasks: true });
-        await fiQueue.acknowledge(p2Task); // Waiting
-        const dequeued2 = await fiQueue.dequeueMany(2);
-        // Fail many
-        await fiQueue.failMany(dequeued2, ['error', 'error']);
-        // Check children are dead
-        const c1State = await fiQueue.get(children2[0].id);
-        expect(c1State?.status).toBe(TaskState.Dead);
-        // Check Parent Fan-In -> Should be Pending
-        const p2State = await fiQueue.get(p2.id);
-        expect(p2State?.status).toBe(TaskState.Pending);
-        await fiQueue.clear();
-    });
-});
-describe('PostgresQueue (Distributed Task Orchestration)', () => {
-    let injector;
-    let queue;
-    beforeAll(async () => {
-        injector = await setupIntegrationTest();
-    });
-    beforeEach(() => {
-        const queueProvider = injector.resolve(QueueProvider);
-        const queueName = `pg-test-queue-${Date.now()}-${Math.random()}`;
-        queue = queueProvider.get(queueName, {
-            processTimeout: 200, // Short timeout for testing
-            retryDelayMinimum: 50,
-            retryDelayGrowth: 1,
-            circuitBreakerThreshold: 2,
-            circuitBreakerResetTimeout: 200,
-        });
-    });
-    afterEach(async () => {
-        await queue.clear();
-    });
-    afterAll(async () => {
-        await injector?.dispose();
-    });
-    describe('Basic Lifecycle', () => {
-        it('should enqueue and dequeue a task', async () => {
-            await queue.enqueue({ foo: 'bar' });
-            const task = await queue.dequeue();
-            expect(task).toBeDefined();
-            expect(task?.data).toEqual({ foo: 'bar' });
-            expect(task?.status).toBe(TaskState.Running);
-            expect(task?.tries).toBe(1);
-        });
-        it('should acknowledge a task successfully', async () => {
-            const task = await queue.enqueue({ foo: 'bar' });
-            const dequeued = await queue.dequeue();
-            await queue.acknowledge(dequeued, { result: true });
-            const updated = await queue.get(task.id);
-            expect(updated?.status).toBe(TaskState.Completed);
-            expect(updated?.result).toEqual({ result: true });
-            expect(updated?.completeTimestamp).toBeGreaterThan(0);
-        });
-        it('should fail a task and increment tries', async () => {
-            const task = await queue.enqueue({ foo: 'bar' });
-            const dequeued = await queue.dequeue();
-            await queue.fail(dequeued, new Error('temp failure'));
-            const updated = await queue.get(task.id);
-            expect(updated?.status).toBe(TaskState.Pending);
-            expect(updated?.tries).toBe(1);
-            expect(updated?.error).toBeDefined();
-        });
-    });
-    describe('Deduplication (Unique Tags)', () => {
-        it('should keep the old task when using UniqueTagStrategy.KeepOld', async () => {
-            const tag = 'unique-1';
-            await queue.enqueue({ foo: 'first' }, { tag, uniqueTag: UniqueTagStrategy.KeepOld });
-            await queue.enqueue({ foo: 'second' }, { tag, uniqueTag: UniqueTagStrategy.KeepOld });
-            const count = await queue.countByTag(tag);
-            const task = (await queue.getByTag(tag))[0];
-            expect(count).toBe(1);
-            expect(task?.data).toEqual({ foo: 'first' });
-        });
-        it('should overwrite with new data when using UniqueTagStrategy.TakeNew', async () => {
-            const tag = 'unique-2';
-            await queue.enqueue({ foo: 'first' }, { tag, uniqueTag: UniqueTagStrategy.TakeNew });
-            await queue.enqueue({ foo: 'second' }, { tag, uniqueTag: UniqueTagStrategy.TakeNew });
-            const count = await queue.countByTag(tag);
-            const task = (await queue.getByTag(tag))[0];
-            expect(count).toBe(1);
-            expect(task?.data).toEqual({ foo: 'second' });
-            expect(task?.tries).toBe(0); // Should reset
-        });
-    });
-    describe('Priority and Scheduling', () => {
-        it('should dequeue tasks in priority order (lower number first)', async () => {
-            await queue.enqueue({ foo: 'low' }, { priority: 2000 });
-            await queue.enqueue({ foo: 'high' }, { priority: 10 });
-            await queue.enqueue({ foo: 'mid' }, { priority: 1000 });
-            const t1 = await queue.dequeue();
-            const t2 = await queue.dequeue();
-            const t3 = await queue.dequeue();
-            expect(t1?.data.foo).toBe('high');
-            expect(t2?.data.foo).toBe('mid');
-            expect(t3?.data.foo).toBe('low');
-        });
-        it('should not dequeue a task scheduled in the future', async () => {
-            const future = currentTimestamp() + 500;
-            await queue.enqueue({ foo: 'future' }, { scheduleTimestamp: future });
-            const task = await queue.dequeue();
-            expect(task).toBeUndefined();
-            await timeout(600);
-            const taskLater = await queue.dequeue();
-            expect(taskLater).toBeDefined();
-        });
-    });
-    describe('Concurrency Control', () => {
-        it('should respect global concurrency limits', async () => {
-            const queueProvider = injector.resolve(QueueProvider);
-            const limitedQueue = queueProvider.get(`limit-test-${Date.now()}`, { globalConcurrency: 2 });
-            await limitedQueue.enqueueMany([{ data: { foo: '1' } }, { data: { foo: '2' } }, { data: { foo: '3' } }]);
-            const t1 = await limitedQueue.dequeue();
-            const t2 = await limitedQueue.dequeue();
-            const t3 = await limitedQueue.dequeue();
-            expect(t1).toBeDefined();
-            expect(t2).toBeDefined();
-            expect(t3).toBeUndefined(); // Limit reached
-            await limitedQueue.acknowledge(t1);
-            const t3Retry = await limitedQueue.dequeue();
-            expect(t3Retry).toBeDefined(); // Slot opened
-            await limitedQueue.clear();
-        });
-    });
-    describe('Circuit Breaker', () => {
-        it('should trip the breaker after threshold failures', async () => {
-            // Config: circuitBreakerThreshold: 2 (set in beforeEach)
-            await queue.enqueue({ foo: '1' });
-            await queue.enqueue({ foo: '2' });
-            await queue.enqueue({ foo: '3' });
-            await queue.fail((await queue.dequeue()), 'err');
-            await queue.fail((await queue.dequeue()), 'err');
-            // Breaker should be Open
-            const t3Attempt = await queue.dequeue();
-            expect(t3Attempt).toBeUndefined();
-        });
-        it('should allow a single probe in Half-Open state', async () => {
-            await queue.enqueueMany([{ data: { foo: '1' } }, { data: { foo: '2' } }]);
-            await queue.fail((await queue.dequeue()), 'err');
-            await queue.fail((await queue.dequeue()), 'err');
-            // Breaker is Open. Wait for reset timeout (200ms)
-            await timeout(250);
-            const probe = await queue.dequeue();
-            expect(probe).toBeDefined();
-            const secondAttempt = await queue.dequeue();
-            expect(secondAttempt).toBeUndefined(); // Only 1 probe allowed in Half-Open
-        });
-    });
-    describe('Task Hierarchy (Orchestration)', () => {
-        it('should move parent to Waiting if children are spawned', async () => {
-            const parent = await queue.enqueue({ foo: 'parent' });
-            const pDequeued = await queue.dequeue();
-            // Spawn child
-            await queue.enqueue({ foo: 'child' }, { parentId: pDequeued.id });
-            await queue.acknowledge(pDequeued);
-            const pStatus = await queue.get(parent.id);
-            expect(pStatus?.status).toBe(TaskState.Waiting);
-        });
-        it('should wake up parent when all children are completed', async () => {
-            const parent = await queue.enqueue({ foo: 'parent' });
-            const child = await queue.enqueue({ foo: 'child' }, { parentId: parent.id });
-            // Parent is in Waiting (simulated by manual acknowledge)
-            const pDequeued = await queue.dequeue();
-            await queue.acknowledge(pDequeued);
-            // Complete child
-            const cDequeued = await queue.dequeue();
-            await queue.acknowledge(cDequeued);
-            const pStatus = await queue.get(parent.id);
-            expect(pStatus?.status).toBe(TaskState.Pending); // Woken up
-        });
-    });
-    describe('Timeouts and Maintenance (Pruning)', () => {
-        it('should recover "Zombie" tasks (crashed workers)', async () => {
-            const task = await queue.enqueue({ foo: 'zombie' });
-            await queue.dequeue(); // Task is now Running with a lease
-            // processTimeout is 200ms. Wait for it to expire.
-            await timeout(300);
-            const recovered = await queue.dequeue();
-            expect(recovered?.id).toBe(task.id);
-            expect(recovered?.tries).toBe(2);
-        });
-        it('should fail tasks that exceed Hard Execution Timeout via prune', async () => {
-            // Re-configure queue with very short execution timeout
-            const queueProvider = injector.resolve(QueueProvider);
-            const shortQueue = queueProvider.get(`prune-test-${Date.now()}`, { executionTimeout: 100 });
-            const task = await shortQueue.enqueue({ foo: 'long-running' });
-            await shortQueue.dequeue();
-            await timeout(200);
-            await shortQueue.prune();
-            const updated = await shortQueue.get(task.id);
-            expect(updated?.status).toBe(TaskState.Dead);
-            expect(updated?.error?.message).toContain('Hard Execution Timeout');
-            await shortQueue.clear();
-        });
-        it('should touch a task to extend lease', async () => {
-            const task = await queue.enqueue({ foo: 'work' });
-            const dequeued = await queue.dequeue();
-            const initialLock = dequeued.lockExpirationTimestamp;
-            await timeout(50);
-            const touched = await queue.touch(dequeued);
-            expect(touched?.lockExpirationTimestamp).toBeGreaterThan(initialLock);
-        });
-        it('should prevent touching if lease is lost (stolen by another worker)', async () => {
-            await queue.enqueue({ foo: 'work' });
-            const dequeued = await queue.dequeue();
-            expect(dequeued).toBeDefined();
-            // processTimeout is 200ms. Wait for it to expire.
-            await timeout(300);
-            await queue.dequeue(); // Stolen by another worker (tries=2)
-            // Original worker tries to touch
-            const touchResult = await queue.touch(dequeued);
-            expect(touchResult).toBeUndefined();
-        });
-    });
-    describe('Batch Operations', () => {
-        it('should acknowledge many tasks efficiently', async () => {
-            const tasks = await queue.enqueueMany([
-                { data: { foo: '1' } },
-                { data: { foo: '2' } },
-            ], { returnTasks: true });
-            const d1 = await queue.dequeue();
-            const d2 = await queue.dequeue();
-            await queue.acknowledgeMany([d1, d2]);
-            const t1 = await queue.get(tasks[0].id);
-            const t2 = await queue.get(tasks[1].id);
-            expect(t1?.status).toBe(TaskState.Completed);
-            expect(t2?.status).toBe(TaskState.Completed);
-        });
-    });
-    describe('Rescheduling', () => {
-        it('should reschedule and refund tries if running', async () => {
-            const task = await queue.enqueue({ foo: 'reschedule-me' });
-            const dequeued = await queue.dequeue();
-            expect(dequeued?.tries).toBe(1);
-            const inFuture = currentTimestamp() + 1000;
-            await queue.reschedule(dequeued.id, inFuture);
-            const updated = await queue.get(task.id);
-            expect(updated?.status).toBe(TaskState.Pending);
-            expect(updated?.tries).toBe(0); // Refunded
-            expect(updated?.scheduleTimestamp).toBe(inFuture);
-        });
-    });
-    describe('TaskContext (Worker DX)', () => {
-        it('checkpoint() should update progress and handle lease loss', async () => {
-            const task = await queue.enqueue({ foo: 'progress' });
-            const dequeued = await queue.dequeue();
-            // In real scenarios TaskContext wraps the queue logic.
-            // Here we just verify touch/checkpoint effects on the DB.
-            await queue.touch(dequeued, { progress: 0.5, state: { step: 1 } });
-            const updated = await queue.get(task.id);
-            expect(updated?.progress).toBe(0.5);
-            expect(updated?.state).toEqual({ step: 1 });
-        });
-    });
-});

package/test3.d.ts

@@ -1 +0,0 @@
-import './polyfills.js';

package/test3.js

@@ -1,47 +0,0 @@
-import './polyfills.js';
-import { Application } from './application/application.js';
-import { provideInitializer, provideModule, provideSignalHandler } from './application/providers.js';
-import { inject } from './injector/inject.js';
-import { configureLocalMessageBus } from './message-bus/index.js';
-import { configureOrm } from './orm/server/index.js';
-import { configurePostgresQueue, migratePostgresQueueSchema } from './queue/postgres/module.js';
-import { Queue, UniqueTagStrategy } from './queue/queue.js';
-import * as configParser from './utils/config-parser.js';
-if (1 + 1 == 2)
-    process.exit();
-const config = {
-    database: {
-        host: configParser.string('DATABASE_HOST', '127.0.0.1'),
-        port: configParser.positiveInteger('DATABASE_PORT', 5432),
-        user: configParser.string('DATABASE_USER', 'vitrass'),
-        pass: configParser.string('DATABASE_PASS', '6zv7edvqv9vvzz6u4kuk'),
-        database: configParser.string('DATABASE_NAME', 'vitrass'),
-        schema: configParser.string('DATABASE_SCHEMA', 'vitrass')
-    }
-};
-async function bootstrap() {
-    configureLocalMessageBus();
-    configureOrm({
-        connection: {
-            host: config.database.host,
-            port: config.database.port,
-            user: config.database.user,
-            password: config.database.pass,
-            database: config.database.database
-        },
-        repositoryConfig: { schema: 'vitrass' }
-    });
-    configurePostgresQueue({});
-    await migratePostgresQueueSchema();
-}
-async function main(_cancellationSignal) {
-    const queue = inject((Queue), 'echos');
-    await queue.enqueue({ name: 'Max 1' }, { tag: 'foo', uniqueTag: UniqueTagStrategy.TakeNew });
-    await queue.enqueue({ name: 'Max 2' }, { tag: 'foo', uniqueTag: UniqueTagStrategy.TakeNew });
-    await queue.enqueue({ name: 'Max 3' }, { tag: 'foo', uniqueTag: UniqueTagStrategy.TakeNew });
-}
-Application.run('Test', [
-    provideInitializer(bootstrap),
-    provideModule(main),
-    provideSignalHandler(),
-]);