@tstdl/base 0.93.181 → 0.93.183

package/task-queue/tests/fan-out-spawning.test.js

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

package/task-queue/tests/idempotent-replacement.test.d.ts

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

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

@@ -1,114 +0,0 @@
-import { eq } from 'drizzle-orm';
-import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it } from 'vitest';
-import { Database } from '../../orm/server/index.js';
-import { TaskQueueProvider, TaskStatus } from '../../task-queue/index.js';
-import { taskDependency as taskDependencyTable } from '../../task-queue/postgres/schemas.js';
-import { setupIntegrationTest } from '../../testing/index.js';
-import { timeout } from '../../utils/timing.js';
-describe('Idempotent Replacement', () => {
-    let injector;
-    let queue;
-    let database;
-    beforeAll(async () => {
-        ({ injector } = await setupIntegrationTest({ modules: { taskQueue: true } }));
-        database = injector.resolve(Database);
-    });
-    beforeEach(() => {
-        const queueProvider = injector.resolve(TaskQueueProvider);
-        const queueName = `idempotent-queue-${crypto.randomUUID()}`;
-        queue = queueProvider.get(queueName, {
-            visibilityTimeout: 1000,
-        });
-    });
-    afterEach(async () => {
-        await queue.clear();
-    });
-    afterAll(async () => {
-        await injector?.dispose();
-    });
-    it('should NOT be affected by "ghost" dependencies after replacement', async () => {
-        const depA = await queue.enqueue('depA', {});
-        const depB = await queue.enqueue('depB', {});
-        const depC = await queue.enqueue('depC', {});
-        const idempotencyKey = 'my-idempotent-task';
-        // 1. Initial enqueue with A and B
-        const taskV1 = await queue.enqueue('main', { version: 1 }, {
-            idempotencyKey,
-            scheduleAfter: [depA.id, depB.id],
-        });
-        expect(taskV1.status).toBe(TaskStatus.Waiting);
-        expect(taskV1.unresolvedScheduleDependencies).toBe(2);
-        // 2. Replacement enqueue with only C
-        const taskV2 = await queue.enqueue('main', { version: 2 }, {
-            idempotencyKey,
-            scheduleAfter: [depC.id],
-            replace: true,
-        });
-        expect(taskV2.id).toBe(taskV1.id);
-        expect(taskV2.unresolvedScheduleDependencies).toBe(1);
-        expect(taskV2.data).toEqual({ version: 2 });
-        // 3. Complete an OLD dependency (depA)
-        const dDepA = await queue.dequeue({ types: ['depA'] });
-        await queue.complete(dDepA);
-        // Give it a moment to process background dependency resolution if any
-        await timeout(100);
-        // 4. Verify main task is STILL waiting for depC
-        const uTask = await queue.getTask(taskV1.id);
-        expect(uTask?.status).toBe(TaskStatus.Waiting);
-        expect(uTask?.unresolvedScheduleDependencies).toBe(1);
-        // 5. Complete NEW dependency (depC)
-        const dDepC = await queue.dequeue({ types: ['depC'] });
-        await queue.complete(dDepC);
-        // 6. Verify main task is now Pending
-        const fTask = await queue.getTask(taskV1.id);
-        expect(fTask?.status).toBe(TaskStatus.Pending);
-    });
-    it('should update parentId on replacement', async () => {
-        const parent1 = await queue.enqueue('parent', { id: 1 });
-        const parent2 = await queue.enqueue('parent', { id: 2 });
-        const idempotencyKey = 'task-1';
-        const taskV1 = await queue.enqueue('child', {}, { idempotencyKey, parentId: parent1.id });
-        expect(taskV1.parentId).toBe(parent1.id);
-        // Replace with new parent
-        const taskV2 = await queue.enqueue('child', {}, { idempotencyKey, parentId: parent2.id, replace: true });
-        expect(taskV2.id).toBe(taskV1.id);
-        expect(taskV2.parentId).toBe(parent2.id);
-    });
-    it('should NOT corrupt state on idempotent enqueues (replace: false)', async () => {
-        const dep = await queue.enqueue('dep', {});
-        const idempotencyKey = 'task-2';
-        // Initial enqueue without dependency
-        const taskV1 = await queue.enqueue('main', {}, { idempotencyKey });
-        expect(taskV1.status).toBe(TaskStatus.Pending);
-        // Deduplicated enqueue with dependency
-        const taskV2 = await queue.enqueue('main', {}, { idempotencyKey, scheduleAfter: [dep.id], replace: false });
-        expect(taskV2.id).toBe(taskV1.id);
-        const task = await queue.getTask(taskV2.id);
-        expect(task?.status).toBe(TaskStatus.Pending);
-        expect(task?.unresolvedScheduleDependencies).toBe(0);
-    });
-    it('should NOT orphan children on task replacement', async () => {
-        const idempotencyKey = 'parent-task';
-        const parent = await queue.enqueue('parent', {}, { idempotencyKey });
-        // Enqueue child
-        await queue.enqueue('child', {}, { parentId: parent.id });
-        const parentAfterChild = await queue.getTask(parent.id);
-        expect(parentAfterChild?.unresolvedCompleteDependencies).toBe(1);
-        // Replace parent
-        const replacedParent = await queue.enqueue('parent', { replaced: true }, { idempotencyKey, replace: true });
-        expect(replacedParent.unresolvedCompleteDependencies).toBe(1);
-    });
-    it('should clear and recreate dependencies when enqueuing existing tasks with replace: true', async () => {
-        const dep1 = await queue.enqueue('test', { value: 'dep1' });
-        const dep2 = await queue.enqueue('test', { value: 'dep2' });
-        const task = await queue.enqueue('test', { value: 'main' }, { idempotencyKey: 'main-key', scheduleAfter: [dep1.id] });
-        // Re-enqueue with replace: true and different dependency
-        await queue.enqueue('test', { value: 'main-replaced' }, { idempotencyKey: 'main-key', replace: true, scheduleAfter: [dep2.id] });
-        const deps = await database
-            .select()
-            .from(taskDependencyTable)
-            .where(eq(taskDependencyTable.taskId, task.id));
-        expect(deps).toHaveLength(1);
-        expect(deps[0].dependencyTaskId).toBe(dep2.id);
-    });
-});

package/task-queue/tests/missing-idempotent-tasks.test.d.ts

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

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

@@ -1,39 +0,0 @@
-import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it } from 'vitest';
-import { TaskQueueProvider, TaskStatus } from '../../task-queue/index.js';
-import { setupIntegrationTest } from '../../testing/index.js';
-describe('Missing Idempotent Tasks Bug', () => {
-    let injector;
-    let queue;
-    beforeAll(async () => {
-        ({ injector } = await setupIntegrationTest({ modules: { taskQueue: true } }));
-    });
-    beforeEach(() => {
-        const queueProvider = injector.resolve(TaskQueueProvider);
-        const queueName = `missing-idem-queue-${crypto.randomUUID()}`;
-        queue = queueProvider.get(queueName, {
-            visibilityTimeout: 1000,
-        });
-    });
-    afterEach(async () => {
-        await queue.clear();
-    });
-    afterAll(async () => {
-        await injector?.dispose();
-    });
-    it('should NOT crash when enqueuing duplicate idempotent tasks with dependencies and returnTasks: false', async () => {
-        const key = 'idem-key';
-        const dep = await queue.enqueue('dep', {});
-        // 1. Initial enqueue
-        const task1 = await queue.enqueue('main', {}, { idempotencyKey: key });
-        // 2. Second enqueue with same key and a dependency, returnTasks: false
-        // This should NOT crash.
-        // replace=false means we should ignore the new data AND the new dependency for the existing task.
-        await expect(queue.enqueueMany([
-            { type: 'main', data: { new: 'data' }, idempotencyKey: key, scheduleAfter: [dep.id] }
-        ], { replace: false, returnTasks: false })).resolves.toBeUndefined();
-        const updatedTask = await queue.getTask(task1.id);
-        expect(updatedTask?.data).toEqual({}); // Data should not have changed
-        expect(updatedTask?.unresolvedScheduleDependencies).toBe(0); // Dependency should not have been added
-        expect(updatedTask?.status).toBe(TaskStatus.Pending); // Should still be Pending, not Waiting
-    });
-});

package/task-queue/tests/optimization-edge-cases.test.d.ts

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

package/task-queue/tests/optimization-edge-cases.test.js

@@ -1,124 +0,0 @@
-import { and, eq, sql } from 'drizzle-orm';
-import { describe, expect, vi } from 'vitest';
-import { inject } from '../../injector/index.js';
-import { TRANSACTION_TIMESTAMP } from '../../orm/index.js';
-import { injectRepository } from '../../orm/server/index.js';
-import { getIntegrationTest } from '../../testing/index.js';
-import { timeout } from '../../utils/timing.js';
-import { taskArchive as taskArchiveTable, taskDependency as taskDependencyTable, task as taskTable } from '../postgres/schemas.js';
-import { PostgresTaskQueue } from '../postgres/task-queue.js';
-import { PostgresTask, PostgresTaskArchive } from '../postgres/task.model.js';
-import { TaskDependencyType, TaskStatus } from '../task-queue.js';
-const test = getIntegrationTest({ modules: { taskQueue: true } });
-describe('Task Queue Optimization Edge Cases', () => {
-    test('should notify unique namespaces exactly once in incrementCounters', async () => {
-        const q1 = inject(PostgresTaskQueue, 'ns-1');
-        const q2 = inject(PostgresTaskQueue, 'ns-2');
-        const notifySpy = vi.spyOn(PostgresTaskQueue.prototype, 'notify');
-        const [t1] = await q1.enqueueMany([{ type: 't1', data: {} }], { returnTasks: true });
-        const [t2] = await q2.enqueueMany([{ type: 't2', data: {} }], { returnTasks: true });
-        notifySpy.mockClear();
-        await q1.incrementCounters([
-            { taskId: t1.id, dependencyTaskId: 'some-dep', type: TaskDependencyType.Schedule },
-            { taskId: t2.id, dependencyTaskId: 'some-dep', type: TaskDependencyType.Schedule },
-            { taskId: t1.id, dependencyTaskId: 'other-dep', type: TaskDependencyType.Schedule },
-        ]);
-        const notifiedNamespaces = notifySpy.mock.calls.map(call => call[0]);
-        expect(notifiedNamespaces).toContain('ns-1');
-        expect(notifiedNamespaces).toContain('ns-2');
-        expect(notifiedNamespaces.filter(n => n == 'ns-1').length).toBe(1);
-        expect(notifiedNamespaces.filter(n => n == 'ns-2').length).toBe(1);
-    });
-    test('should resolve edge and abort on unmatched terminal status in resolveDependenciesMany', async () => {
-        const queue = inject(PostgresTaskQueue, 'test-namespace');
-        const repository = injectRepository(PostgresTask);
-        const [parent] = await queue.enqueueMany([{ type: 'parent', data: {}, abortOnDependencyFailure: true }], { returnTasks: true });
-        const [child] = await queue.enqueueMany([{ type: 'child', data: {} }], { returnTasks: true });
-        await repository.session.insert(taskDependencyTable).values({
-            taskId: parent.id,
-            dependencyTaskId: child.id,
-            type: TaskDependencyType.Schedule,
-            requiredStatuses: [TaskStatus.Completed],
-        });
-        await repository.session.update(taskTable).set({ unresolvedScheduleDependencies: 1, status: TaskStatus.Waiting }).where(eq(taskTable.id, parent.id));
-        await queue.resolveDependenciesMany([{ id: child.id, status: TaskStatus.Dead, namespace: 'test-namespace' }]);
-        const updatedParent = await queue.getTask(parent.id);
-        expect(updatedParent.status).toBe(TaskStatus.Skipped);
-    });
-    test('should handle hard timeout during touch', async () => {
-        // Configure with small maxExecutionTime
-        const queue = inject(PostgresTaskQueue, { namespace: 'timeout-test', maxExecutionTime: 10 });
-        const [task] = await queue.enqueueMany([{ type: 'test', data: {} }], { returnTasks: true });
-        const [runningTask] = await queue.dequeueMany(1);
-        await timeout(50);
-        const result = await queue.touch(runningTask);
-        expect(result).toBeUndefined();
-        const updated = await queue.getTask(runningTask.id);
-        expect(updated.status).toBe(TaskStatus.TimedOut);
-    });
-    test('should handle non-existent tasks in complete and fail', async () => {
-        const queue = inject(PostgresTaskQueue, 'missing-test');
-        const fakeTask = { id: crypto.randomUUID(), token: crypto.randomUUID(), tries: 0 };
-        await expect(queue.complete(fakeTask)).resolves.toBeUndefined();
-        await expect(queue.fail(fakeTask, new Error('fail'))).resolves.toBeUndefined();
-    });
-    test('should handle terminal tasks with no dependents in resolveDependenciesMany', async () => {
-        const queue = inject(PostgresTaskQueue, 'no-deps-test');
-        const [task] = await queue.enqueueMany([{ type: 'test', data: {} }], { returnTasks: true });
-        await queue.resolveDependenciesMany([{ id: task.id, status: TaskStatus.Completed }]);
-    });
-    test('should handle archival and purge in maintenance', async () => {
-        const namespace = `archival-test-${crypto.randomUUID()}`;
-        // Configure with small retention
-        const queue = inject(PostgresTaskQueue, { namespace, retention: 1000, archiveRetention: 1000 });
-        const repository = injectRepository(PostgresTask);
-        const archiveRepository = injectRepository(PostgresTaskArchive);
-        const [task] = await queue.enqueueMany([{ type: 'test', data: {} }], { returnTasks: true });
-        await repository.session.update(taskTable)
-            .set({
-            status: TaskStatus.Completed,
-            completeTimestamp: sql `${TRANSACTION_TIMESTAMP} - interval '2 seconds'`,
-        })
-            .where(and(eq(taskTable.id, task.id), eq(taskTable.namespace, namespace)));
-        await queue.performArchival();
-        const archived = await archiveRepository.load(task.id);
-        expect(archived).toBeDefined();
-        await repository.session.update(taskArchiveTable)
-            .set({ completeTimestamp: sql `${TRANSACTION_TIMESTAMP} - interval '2 seconds'` })
-            .where(and(eq(taskArchiveTable.id, task.id), eq(taskArchiveTable.namespace, namespace)));
-        await queue.performArchivePurge();
-        const purged = await archiveRepository.load(task.id).catch(() => undefined);
-        expect(purged).toBeUndefined();
-    });
-    test('should notify on restart', async () => {
-        const namespace = `restart-test-${crypto.randomUUID()}`;
-        const queue = inject(PostgresTaskQueue, namespace);
-        const notifySpy = vi.spyOn(PostgresTaskQueue.prototype, 'notify');
-        const [task] = await queue.enqueueMany([{ type: 'test', data: {} }], { returnTasks: true });
-        await queue.cancelMany([task.id]);
-        notifySpy.mockClear();
-        await queue.restart(task.id);
-        expect(notifySpy).toHaveBeenCalledWith(namespace);
-    });
-    test('should use exponential backoff for zombies', async () => {
-        const namespace = `zombie-backoff-${crypto.randomUUID()}`;
-        // Configure with standard growth
-        const queue = inject(PostgresTaskQueue, { namespace, retryDelayMinimum: 1000, retryDelayGrowth: 2 });
-        const repository = injectRepository(PostgresTask);
-        const [task] = await queue.enqueueMany([{ type: 'test', data: {} }], { returnTasks: true });
-        await queue.dequeueMany(1);
-        await repository.session.update(taskTable)
-            .set({
-            status: TaskStatus.Running,
-            visibilityDeadline: sql `${TRANSACTION_TIMESTAMP} - interval '1 minute'`,
-            tries: 2,
-        })
-            .where(and(eq(taskTable.id, task.id), eq(taskTable.namespace, namespace)));
-        await queue.recoverStaleTasks();
-        const updated = await queue.getTask(task.id);
-        expect(updated.status).toBe(TaskStatus.Retrying);
-        const delay = updated.scheduleTimestamp - Date.now();
-        expect(delay).toBeGreaterThan(1000);
-        expect(delay).toBeLessThan(3000);
-    });
-});

package/task-queue/tests/queue-generic.test.d.ts

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

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

@@ -1,8 +0,0 @@
-import { describe, test, expectTypeOf } from 'vitest';
-describe('TaskQueue Class Generic', () => {
-    test('TaskQueue should accept TaskDefinitionMap', () => {
-        // If it compiles, it's good. But we can inspect the generic constraints.
-        // For now, simple existence check.
-        expectTypeOf().toBeObject();
-    });
-});

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

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