@tstdl/base 0.93.140 → 0.93.142

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

@@ -0,0 +1,94 @@
+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 waitForCompletion is false', async () => {
+        const parent = await queue.enqueue('parent', {});
+        const dParent = await queue.dequeue();
+        // Spawn child with waitForCompletion: false
+        await queue.enqueueMany([{ type: 'child', data: {}, parentId: parent.id, waitForCompletion: 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

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

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

@@ -0,0 +1,114 @@
+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

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

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

@@ -0,0 +1,39 @@
+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
+    });
+});