@tstdl/base 0.93.141 → 0.93.142

package/task-queue/tests/zombie-recovery.test.js

@@ -10,7 +10,7 @@ describe('Zombie Recovery Race Condition', () => {
     });
     beforeEach(() => {
         const queueProvider = injector.resolve(TaskQueueProvider);
-        const queueName = `zombie-recovery-queue-${Date.now()}-${Math.random()}`;
+        const queueName = `zombie-recovery-queue-${crypto.randomUUID()}`;
         queue = queueProvider.get(queueName, {
             visibilityTimeout: 100, // Very short visibility timeout
             retryDelayMinimum: 0,
@@ -37,7 +37,7 @@ describe('Zombie Recovery Race Condition', () => {
         await queue.maintenance();
         // Verify it was recovered to Pending
         const recoveredParent = await queue.getTask(parent.id);
-        expect(recoveredParent?.status).toBe(TaskStatus.Pending);
+        expect(recoveredParent?.status).toBe(TaskStatus.Retrying);
         // If the bug exists, startTimestamp is still set here.
         // 6. Complete the child while parent is still Pending
         const dChild = await queue.dequeue({ types: ['child'] });
@@ -46,6 +46,6 @@ describe('Zombie Recovery Race Condition', () => {
         // BUG: evaluateTaskStatus will see unresolvedCompleteDependencies=0 and startTimestamp != null,
         // and incorrectly transition the Pending parent to Completed.
         const finalParent = await queue.getTask(parent.id);
-        expect(finalParent?.status).toBe(TaskStatus.Pending); // It should still be pending execution!
+        expect(finalParent?.status).toBe(TaskStatus.Retrying); // It should still be pending execution!
     });
 });

package/testing/integration-setup.js

@@ -1,4 +1,5 @@
 import { sql } from 'drizzle-orm';
+import { afterAll } from 'vitest';
 import { configureApiServer } from '../api/server/index.js';
 import { configureAudit } from '../audit/index.js';
 import { AuthenticationApiClient } from '../authentication/client/api.client.js';
@@ -18,7 +19,7 @@ import { configureLocalMessageBus } from '../message-bus/index.js';
 import { configureWebServerModule, WebServerModule } from '../module/modules/web-server.module.js';
 import { configureNotification } from '../notification/server/index.js';
 import { configureS3ObjectStorage } from '../object-storage/s3/index.js';
-import { configureOrm, Database, runDatabaseMigrations } from '../orm/server/index.js';
+import { bootstrapOrm, configureOrm, Database } from '../orm/server/index.js';
 import { getEntitySchema, getEntityTableName } from '../orm/utils.js';
 import { configurePostgresRateLimiter } from '../rate-limit/postgres/module.js';
 import { configureDefaultSignalsImplementation } from '../signals/implementation/configure.js';
@@ -53,7 +54,7 @@ export async function setupIntegrationTest(options = {}) {
     };
     // 4. Configure ORM
     // We disable autoMigrate here because APPLICATION_INITIALIZER is not used in integration tests
-    // We manually run migrations via runDatabaseMigrations below
+    // We manually run migrations via bootstrapOrm below
     configureOrm({
         repositoryConfig: { schema: options.orm?.schema ?? 'test' },
         connection: dbConfig,
@@ -118,7 +119,7 @@ export async function setupIntegrationTest(options = {}) {
                 injector,
             });
         }
-        await runInInjectionContext(injector, runDatabaseMigrations);
+        await runInInjectionContext(injector, bootstrapOrm);
         if (options.modules?.objectStorage) {
             const bucketPerModule = options.s3?.bucketPerModule ?? configParser.boolean('S3_BUCKET_PER_MODULE', true);
             configureS3ObjectStorage({
@@ -162,6 +163,7 @@ export async function setupIntegrationTest(options = {}) {
             }
         }
     });
+    afterAll(async () => await injector.dispose());
     return { injector, database };
 }
 /**

package/utils/timing.d.ts

@@ -8,9 +8,9 @@ export declare function timeout(milliseconds?: number, options?: {
 /** Timeout until specified time */
 export declare function timeoutUntil(timestamp: number | Date): Promise<void>;
 /** Timeout for specified duration */
-export declare function cancelableTimeout(milliseconds: number, cancelSignal: Observable<void> | CancellationSignal): Promise<'timeout' | 'canceled'>;
+export declare function cancelableTimeout(milliseconds: number, cancelSignal: Observable<unknown> | CancellationSignal): Promise<'timeout' | 'canceled'>;
 /** Timeout until specified time */
-export declare function cancelableTimeoutUntil(timestamp: number | Date, cancelSignal: Observable<void> | CancellationSignal): Promise<'timeout' | 'canceled'>;
+export declare function cancelableTimeoutUntil(timestamp: number | Date, cancelSignal: Observable<unknown> | CancellationSignal): Promise<'timeout' | 'canceled'>;
 export declare function withTimeout<T>(milliseconds: number, promiseOrProvider: ValueOrProvider<Promise<T>>, options?: {
     errorMessage?: string;
 }): Promise<T>;

package/task-queue/postgres/drizzle/0000_wakeful_sunspot.sql

@@ -1,82 +0,0 @@
-CREATE TYPE "task_queue"."task_dependency_type" AS ENUM('schedule', 'complete');--> statement-breakpoint
-CREATE TYPE "task_queue"."task_status" AS ENUM('pending', 'running', 'completed', 'cancelled', 'dead', 'waiting', 'waiting-children', 'paused');--> statement-breakpoint
-CREATE TABLE "task_queue"."task" (
-	"id" uuid PRIMARY KEY DEFAULT gen_random_uuid() NOT NULL,
-	"namespace" text NOT NULL,
-	"type" text NOT NULL,
-	"status" "task_queue"."task_status" NOT NULL,
-	"idempotency_key" text,
-	"trace_id" text,
-	"tags" text[] NOT NULL,
-	"fail_fast" boolean NOT NULL,
-	"priority" integer NOT NULL,
-	"unresolved_schedule_dependencies" integer NOT NULL,
-	"unresolved_complete_dependencies" integer NOT NULL,
-	"token" uuid,
-	"creation_timestamp" timestamp with time zone NOT NULL,
-	"priority_age_timestamp" timestamp with time zone NOT NULL,
-	"schedule_timestamp" timestamp with time zone NOT NULL,
-	"start_timestamp" timestamp with time zone,
-	"time_to_live" timestamp with time zone,
-	"visibility_deadline" timestamp with time zone,
-	"complete_timestamp" timestamp with time zone,
-	"tries" integer NOT NULL,
-	"progress" double precision NOT NULL,
-	"data" jsonb,
-	"state" jsonb,
-	"result" jsonb,
-	"error" jsonb,
-	"parent_id" uuid,
-	CONSTRAINT "task_namespace_id_unique" UNIQUE("namespace","id"),
-	CONSTRAINT "task_namespace_idempotency_key_unique" UNIQUE("namespace","idempotency_key")
-);
---> statement-breakpoint
-CREATE TABLE "task_queue"."task_archive" (
-	"id" uuid PRIMARY KEY DEFAULT gen_random_uuid() NOT NULL,
-	"namespace" text NOT NULL,
-	"type" text NOT NULL,
-	"status" "task_queue"."task_status" NOT NULL,
-	"idempotency_key" text,
-	"trace_id" text,
-	"tags" text[] NOT NULL,
-	"fail_fast" boolean NOT NULL,
-	"priority" integer NOT NULL,
-	"unresolved_schedule_dependencies" integer NOT NULL,
-	"unresolved_complete_dependencies" integer NOT NULL,
-	"token" uuid,
-	"creation_timestamp" timestamp with time zone NOT NULL,
-	"priority_age_timestamp" timestamp with time zone NOT NULL,
-	"schedule_timestamp" timestamp with time zone NOT NULL,
-	"start_timestamp" timestamp with time zone,
-	"time_to_live" timestamp with time zone,
-	"visibility_deadline" timestamp with time zone,
-	"complete_timestamp" timestamp with time zone,
-	"tries" integer NOT NULL,
-	"progress" double precision NOT NULL,
-	"data" jsonb,
-	"state" jsonb,
-	"result" jsonb,
-	"error" jsonb,
-	"parent_id" uuid
-);
---> statement-breakpoint
-CREATE TABLE "task_queue"."task_dependency" (
-	"id" uuid PRIMARY KEY DEFAULT gen_random_uuid() NOT NULL,
-	"namespace" text NOT NULL,
-	"task_id" uuid NOT NULL,
-	"dependency_task_id" uuid NOT NULL,
-	"type" "task_queue"."task_dependency_type" NOT NULL,
-	"required_statuses" "task_queue"."task_status"[] NOT NULL,
-	CONSTRAINT "td_namespace_task_id_dependency_task_id_type_unique" UNIQUE("namespace","task_id","dependency_task_id","type")
-);
---> statement-breakpoint
-ALTER TABLE "task_queue"."task" ADD CONSTRAINT "task_namespace_parentId_task_fkey" FOREIGN KEY ("namespace","parent_id") REFERENCES "task_queue"."task"("namespace","id") ON DELETE no action ON UPDATE no action;--> statement-breakpoint
-ALTER TABLE "task_queue"."task_dependency" ADD CONSTRAINT "task_dependency_namespace_dependencyTaskId_task_fkey" FOREIGN KEY ("namespace","dependency_task_id") REFERENCES "task_queue"."task"("namespace","id") ON DELETE cascade ON UPDATE no action;--> statement-breakpoint
-ALTER TABLE "task_queue"."task_dependency" ADD CONSTRAINT "task_dependency_namespace_taskId_task_fkey" FOREIGN KEY ("namespace","task_id") REFERENCES "task_queue"."task"("namespace","id") ON DELETE cascade ON UPDATE no action;--> statement-breakpoint
-CREATE INDEX "task_parent_id_idx" ON "task_queue"."task" USING btree ("parent_id");--> statement-breakpoint
-CREATE INDEX "task_status_visibility_deadline_idx" ON "task_queue"."task" USING btree ("status","visibility_deadline");--> statement-breakpoint
-CREATE INDEX "task_status_complete_timestamp_idx" ON "task_queue"."task" USING btree ("status","complete_timestamp");--> statement-breakpoint
-CREATE INDEX "task_tags_idx" ON "task_queue"."task" USING gin ("tags");--> statement-breakpoint
-CREATE INDEX "task_namespace_status_schedule_timestamp_priority_idx" ON "task_queue"."task" USING btree ("namespace","status","schedule_timestamp","priority");--> statement-breakpoint
-CREATE INDEX "task_archive_namespace_complete_timestamp_idx" ON "task_queue"."task_archive" USING btree ("namespace","complete_timestamp");--> statement-breakpoint
-CREATE INDEX "task_dependency_namespace_dependency_task_id_type_idx" ON "task_queue"."task_dependency" USING btree ("namespace","dependency_task_id","type");

package/task-queue/tests/cascading-cancellations.test.js

@@ -1,38 +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('Cascading Cancellations', () => {
-    let injector;
-    let queue;
-    beforeAll(async () => {
-        ({ injector } = await setupIntegrationTest({ modules: { taskQueue: true } }));
-    });
-    beforeEach(() => {
-        const queueProvider = injector.resolve(TaskQueueProvider);
-        const queueName = `cancellation-queue-${Date.now()}-${Math.random()}`;
-        queue = queueProvider.get(queueName, {
-            visibilityTimeout: 1000,
-        });
-    });
-    afterEach(async () => {
-        await queue.clear();
-    });
-    afterAll(async () => {
-        await injector?.dispose();
-    });
-    it('should recursively cancel children in ownership tree', async () => {
-        const root = await queue.enqueue('root', {});
-        const child1 = await queue.enqueue('child1', {}, { parentId: root.id });
-        const child2 = await queue.enqueue('child2', {}, { parentId: root.id });
-        const grandchild = await queue.enqueue('grandchild', {}, { parentId: child1.id });
-        await queue.cancel(root.id);
-        const uRoot = await queue.getTask(root.id);
-        const uChild1 = await queue.getTask(child1.id);
-        const uChild2 = await queue.getTask(child2.id);
-        const uGrandchild = await queue.getTask(grandchild.id);
-        expect(uRoot?.status).toBe(TaskStatus.Cancelled);
-        expect(uChild1?.status).toBe(TaskStatus.Cancelled);
-        expect(uChild2?.status).toBe(TaskStatus.Cancelled);
-        expect(uGrandchild?.status).toBe(TaskStatus.Cancelled);
-    });
-});

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

@@ -1,122 +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';
-import { timeout } from '../../utils/timing.js';
-describe('Complex Queue Scenarios', () => {
-    let injector;
-    let queue;
-    beforeAll(async () => {
-        ({ injector } = await setupIntegrationTest({ modules: { taskQueue: true } }));
-    });
-    beforeEach(() => {
-        const queueProvider = injector.resolve(TaskQueueProvider);
-        const queueName = `complex-queue-${Date.now()}-${Math.random()}`;
-        // Configure with specific settings for testing logic
-        queue = queueProvider.get(queueName, {
-            visibilityTimeout: 1000,
-            priorityAgingInterval: 50, // Fast aging
-            priorityAgingStep: 10,
-            rateLimit: 5,
-            rateInterval: 200,
-            retryDelayMinimum: 50,
-            retryDelayGrowth: 2,
-            retention: 50, // Fast retention for archive test
-        });
-    });
-    afterEach(async () => {
-        await queue.clear();
-        const queueProvider = injector.resolve(TaskQueueProvider);
-        await queueProvider.get('other-queue').clear();
-    });
-    afterAll(async () => {
-        await injector?.dispose();
-    });
-    async function waitForStatus(id, status) {
-        for (let i = 0; i < 50; i++) {
-            const task = await queue.getTask(id);
-            if (task?.status === status)
-                return;
-            await timeout(10);
-        }
-    }
-    describe('Complex Dependencies', () => {
-        it('should handle Diamond Dependency (A -> B, A -> C, (B&C) -> D)', async () => {
-            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);
-            expect(taskA.status).toBe(TaskStatus.Pending);
-            // Process A
-            const dA = await queue.dequeue({ types: ['A'] });
-            await queue.complete(dA);
-            await waitForStatus(taskB.id, TaskStatus.Pending);
-            await waitForStatus(taskC.id, TaskStatus.Pending);
-            // Process B
-            const dB = await queue.dequeue({ types: ['B'] });
-            await queue.complete(dB);
-            // D still waiting (needs C)
-            const uD2 = await queue.getTask(taskD.id);
-            expect(uD2?.status).toBe(TaskStatus.Waiting);
-            // Process C
-            const dC = await queue.dequeue({ types: ['C'] });
-            await queue.complete(dC);
-            await waitForStatus(taskD.id, TaskStatus.Pending);
-            // D should be Pending
-            const uD3 = await queue.getTask(taskD.id);
-            expect(uD3?.status).toBe(TaskStatus.Pending);
-        });
-        it('should handle Deep Chain (A -> B -> C -> D)', async () => {
-            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(taskB.id, TaskStatus.Pending);
-            await queue.complete((await queue.dequeue({ types: ['B'] })));
-            await waitForStatus(taskC.id, TaskStatus.Pending);
-            await queue.complete((await queue.dequeue({ types: ['C'] })));
-            await waitForStatus(taskD.id, 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);
-        });
-    });
-    describe('Other Scenarios', () => {
-        it('should handle priority aging', async () => {
-            const t1 = await queue.enqueue('low', {}, { priority: 2000 });
-            const t2 = await queue.enqueue('high', {}, { priority: 1000 });
-            // Wait for aging to trigger
-            await timeout(100);
-            await queue.maintenance();
-            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 });
-            }
-            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/dag-dependencies.test.js

@@ -1,41 +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('DAG Dependencies', () => {
-    let injector;
-    let queue;
-    beforeAll(async () => {
-        ({ injector } = await setupIntegrationTest({ modules: { taskQueue: true } }));
-    });
-    beforeEach(() => {
-        const queueProvider = injector.resolve(TaskQueueProvider);
-        const queueName = `dag-queue-${Date.now()}-${Math.random()}`;
-        queue = queueProvider.get(queueName, {
-            visibilityTimeout: 1000,
-        });
-    });
-    afterEach(async () => {
-        await queue.clear();
-    });
-    afterAll(async () => {
-        await injector?.dispose();
-    });
-    it('should schedule a task only after dependency reaches required status (scheduleAfter)', async () => {
-        const prereq = await queue.enqueue('prereq', { val: 1 });
-        const dependent = await queue.enqueue('dependent', { foo: 'bar' }, {
-            scheduleAfter: [prereq.id],
-        });
-        expect(dependent.status).toBe(TaskStatus.Waiting);
-        const dequeued = await queue.dequeue({ types: ['prereq'] });
-        expect(dequeued?.id).toBe(prereq.id);
-        await queue.complete(dequeued);
-        // Dependent should transition to Pending.
-        // Let's dequeue and complete it to make it reaches a finalized state for waitForTasks
-        const dDependent = await queue.dequeue({ types: ['dependent'] });
-        expect(dDependent?.id).toBe(dependent.id);
-        await queue.complete(dDependent);
-        await queue.waitForTasks([dependent.id]);
-        const updatedDependent = await queue.getTask(dependent.id);
-        expect(updatedDependent?.status).toBe(TaskStatus.Completed);
-    });
-});