@tstdl/base 0.93.142 → 0.93.143

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tstdl/base",
-  "version": "0.93.142",
+  "version": "0.93.143",
   "author": "Patrick Hein",
   "publishConfig": {
     "access": "public"

package/task-queue/postgres/drizzle/{0000_great_gwen_stacy.sql → 0000_faithful_daimon_hellstrom.sql}

@@ -9,7 +9,7 @@ CREATE TABLE "task_queue"."task" (
 	"trace_id" text,
 	"parent_id" uuid,
 	"tags" text[] NOT NULL,
-	"fail_fast" boolean NOT NULL,
+	"abort_on_dependency_failure" boolean NOT NULL,
 	"priority" integer NOT NULL,
 	"unresolved_schedule_dependencies" integer NOT NULL,
 	"unresolved_complete_dependencies" integer NOT NULL,
@@ -39,7 +39,7 @@ CREATE TABLE "task_queue"."task_archive" (
 	"trace_id" text,
 	"parent_id" uuid,
 	"tags" text[] NOT NULL,
-	"fail_fast" boolean NOT NULL,
+	"abort_on_dependency_failure" boolean NOT NULL,
 	"priority" integer NOT NULL,
 	"unresolved_schedule_dependencies" integer NOT NULL,
 	"unresolved_complete_dependencies" integer NOT NULL,

package/task-queue/postgres/drizzle/meta/0000_snapshot.json

@@ -1,5 +1,5 @@
 {
-  "id": "aaf1f877-e250-4660-bd3d-9ba1bfacd10c",
+  "id": "f8a5fa74-ffdf-4135-a006-8c8f958ddefa",
   "prevId": "00000000-0000-0000-0000-000000000000",
   "version": "7",
   "dialect": "postgresql",
@@ -58,8 +58,8 @@
           "primaryKey": false,
           "notNull": true
         },
-        "fail_fast": {
-          "name": "fail_fast",
+        "abort_on_dependency_failure": {
+          "name": "abort_on_dependency_failure",
           "type": "boolean",
           "primaryKey": false,
           "notNull": true
@@ -463,8 +463,8 @@
           "primaryKey": false,
           "notNull": true
         },
-        "fail_fast": {
-          "name": "fail_fast",
+        "abort_on_dependency_failure": {
+          "name": "abort_on_dependency_failure",
           "type": "boolean",
           "primaryKey": false,
           "notNull": true

package/task-queue/postgres/drizzle/meta/_journal.json

@@ -5,8 +5,8 @@
     {
       "idx": 0,
       "version": "7",
-      "when": 1772048658458,
-      "tag": "0000_great_gwen_stacy",
+      "when": 1772055508571,
+      "tag": "0000_faithful_daimon_hellstrom",
       "breakpoints": true
     }
   ]

package/task-queue/postgres/task-queue.js

@@ -71,7 +71,7 @@ import { distinct, toArray } from '../../utils/array/array.js';
 import { currentTimestamp } from '../../utils/date-time.js';
 import { Timer } from '../../utils/timer.js';
 import { cancelableTimeout } from '../../utils/timing.js';
-import { isDefined, isNotNull, isNull, isNumber, isString, isUndefined } from '../../utils/type-guards.js';
+import { isArray, isDefined, isNotNull, isNull, isNumber, isString, isUndefined } from '../../utils/type-guards.js';
 import { millisecondsPerMinute, millisecondsPerSecond } from '../../utils/units.js';
 import { defaultQueueConfig, TaskDependencyType, TaskQueue, TaskStatus } from '../task-queue.js';
 import { PostgresTaskQueueModuleConfig } from './module.js';
@@ -122,7 +122,7 @@ let PostgresTaskQueue = class PostgresTaskQueue extends TaskQueue {
         tags: sql `excluded.tags`,
         unresolvedScheduleDependencies: taskTable.unresolvedScheduleDependencies,
         unresolvedCompleteDependencies: taskTable.unresolvedCompleteDependencies,
-        failFast: sql `excluded.fail_fast`,
+        abortOnDependencyFailure: sql `excluded.abort_on_dependency_failure`,
         tries: 0,
         creationTimestamp: TRANSACTION_TIMESTAMP,
         priorityAgeTimestamp: TRANSACTION_TIMESTAMP,
@@ -157,41 +157,39 @@ let PostgresTaskQueue = class PostgresTaskQueue extends TaskQueue {
                 scheduleAfter: isDefined(item.scheduleAfter) ? Array.from(new Map(item.scheduleAfter.map((s) => [isNumber(s) || isString(s) ? s : JSON.stringify(s), s])).values()) : undefined,
                 completeAfter: isDefined(item.completeAfter) ? Array.from(new Map(item.completeAfter.map((s) => [isNumber(s) || isString(s) ? s : JSON.stringify(s), s])).values()) : undefined,
             }));
-            const entitiesWithIndex = itemsWithDistinctDependencies.map((item, index) => {
-                return {
-                    index,
-                    entity: {
-                        namespace: this.#namespace,
-                        type: item.type,
-                        status: TaskStatus.Pending,
-                        token: null,
-                        priority: item.priority ?? 1000,
-                        idempotencyKey: item.idempotencyKey ?? null,
-                        traceId: null,
-                        tags: item.tags ?? [],
-                        unresolvedScheduleDependencies: 0,
-                        unresolvedCompleteDependencies: 0,
-                        failFast: item.failFast ?? false,
-                        parentId: item.parentId ?? null,
-                        tries: 0,
-                        progress: 0,
-                        creationTimestamp: TRANSACTION_TIMESTAMP,
-                        priorityAgeTimestamp: TRANSACTION_TIMESTAMP,
-                        scheduleTimestamp: item.scheduleTimestamp ?? TRANSACTION_TIMESTAMP,
-                        startTimestamp: null,
-                        timeToLive: item.timeToLive ?? sql `${TRANSACTION_TIMESTAMP} + ${interval(this.defaultTimeToLive, 'milliseconds')}`,
-                        visibilityDeadline: null,
-                        completeTimestamp: null,
-                        data: item.data,
-                        state: null,
-                        result: null,
-                        error: null,
-                    },
-                };
-            });
+            const entitiesWithIndex = itemsWithDistinctDependencies.map((item, index) => ({
+                index,
+                entity: {
+                    namespace: this.#namespace,
+                    type: item.type,
+                    status: TaskStatus.Pending,
+                    token: null,
+                    priority: item.priority ?? 1000,
+                    idempotencyKey: item.idempotencyKey ?? null,
+                    traceId: null,
+                    tags: item.tags ?? [],
+                    unresolvedScheduleDependencies: 0,
+                    unresolvedCompleteDependencies: 0,
+                    abortOnDependencyFailure: item.abortOnDependencyFailure ?? false,
+                    parentId: item.parentId ?? null,
+                    tries: 0,
+                    progress: 0,
+                    creationTimestamp: TRANSACTION_TIMESTAMP,
+                    priorityAgeTimestamp: TRANSACTION_TIMESTAMP,
+                    scheduleTimestamp: item.scheduleTimestamp ?? TRANSACTION_TIMESTAMP,
+                    startTimestamp: null,
+                    timeToLive: item.timeToLive ?? sql `${TRANSACTION_TIMESTAMP} + ${interval(this.defaultTimeToLive, 'milliseconds')}`,
+                    visibilityDeadline: null,
+                    completeTimestamp: null,
+                    data: item.data,
+                    state: null,
+                    result: null,
+                    error: null,
+                },
+            }));
             const itemsWithIdempotency = entitiesWithIndex.filter((e) => isNotNull(e.entity.idempotencyKey));
             const itemsWithoutIdempotency = entitiesWithIndex.filter((e) => isNull(e.entity.idempotencyKey));
-            const hasDependencies = itemsWithDistinctDependencies.some((item) => ((item.scheduleAfter?.length ?? 0) > 0) || ((item.completeAfter?.length ?? 0) > 0) || (isDefined(item.parentId) && (item.waitForCompletion ?? true)));
+            const hasDependencies = itemsWithDistinctDependencies.some((item) => ((item.scheduleAfter?.length ?? 0) > 0) || ((item.completeAfter?.length ?? 0) > 0) || (isDefined(item.parentId) && (item.blockParent != false) && !(isArray(item.blockParent) && (item.blockParent.length == 0))));
             const mustUseTransaction = (entitiesWithIndex.length > 1) || hasDependencies;
             const newTransaction = __addDisposableResource(env_1, (mustUseTransaction && isUndefined(options?.transaction)) ? await this.#repository.startTransaction() : undefined, true);
             const transaction = newTransaction ?? options?.transaction;
@@ -260,12 +258,14 @@ let PostgresTaskQueue = class PostgresTaskQueue extends TaskQueue {
                     if (!processedTaskIds.has(task.id)) {
                         continue;
                     }
-                    if (isDefined(item.parentId) && (item.waitForCompletion ?? true)) {
+                    if (isDefined(item.parentId) && (item.blockParent != false) && !(isArray(item.blockParent) && (item.blockParent.length == 0))) {
                         dependencies.push({
                             taskId: item.parentId,
                             dependencyTaskId: task.id,
                             type: TaskDependencyType.Child,
-                            requiredStatuses: [TaskStatus.Completed],
+                            requiredStatuses: isArray(item.blockParent)
+                                ? item.blockParent
+                                : [TaskStatus.Completed],
                         });
                     }
                     if (isDefined(item.scheduleAfter)) {
@@ -335,7 +335,7 @@ let PostgresTaskQueue = class PostgresTaskQueue extends TaskQueue {
                             .from(taskArchiveTable)
                             .where(inArray(taskArchiveTable.id, distinctDependencyIds)));
                         if (dependencyStatuses.length > 0) {
-                            await this.resolveDependenciesMany(dependencyStatuses.map((s) => ({ id: s.id, status: s.status })), { transaction: transaction });
+                            await this.resolveDependenciesMany(dependencyStatuses.map((s) => ({ id: s.id, status: s.status })), { transaction });
                         }
                     }
                 }
@@ -932,7 +932,6 @@ let PostgresTaskQueue = class PostgresTaskQueue extends TaskQueue {
         await this.resolveDependenciesMany([{ id, status, namespace: options?.namespace }], options);
     }
     async resolveDependenciesMany(tasks, options) {
-        this.#logger.debug(`Resolving dependencies for ${tasks.length} tasks`);
         if (tasks.length == 0) {
             return;
         }
@@ -953,7 +952,7 @@ let PostgresTaskQueue = class PostgresTaskQueue extends TaskQueue {
                 return;
             }
             const resolvedEdges = [];
-            const failFastTaskIds = new Set();
+            const abortOnDependencyFailureTaskIds = new Set();
             for (const dep of dependents) {
                 const status = taskStatusMap.get(dep.dependencyTaskId);
                 const isMatched = dep.requiredStatuses.includes(status);
@@ -961,7 +960,7 @@ let PostgresTaskQueue = class PostgresTaskQueue extends TaskQueue {
                 if (isMatched || isTerminal) {
                     resolvedEdges.push(dep);
                     if (!isMatched) {
-                        failFastTaskIds.add(dep.taskId);
+                        abortOnDependencyFailureTaskIds.add(dep.taskId);
                     }
                 }
             }
@@ -989,17 +988,17 @@ let PostgresTaskQueue = class PostgresTaskQueue extends TaskQueue {
       `);
             const terminalTasks = [];
             const skippedTaskIds = new Set();
-            if (failFastTaskIds.size > 0) {
-                const sortedFailFastIds = [...failFastTaskIds].toSorted();
+            if (abortOnDependencyFailureTaskIds.size > 0) {
+                const sortedAbortIds = [...abortOnDependencyFailureTaskIds].toSorted();
                 const dependentTasks = await tx.pgTransaction
-                    .select({ id: taskTable.id, namespace: taskTable.namespace, failFast: taskTable.failFast, status: taskTable.status })
+                    .select({ id: taskTable.id, namespace: taskTable.namespace, abortOnDependencyFailure: taskTable.abortOnDependencyFailure, status: taskTable.status })
                     .from(taskTable)
-                    .where(inArray(taskTable.id, sortedFailFastIds))
+                    .where(inArray(taskTable.id, sortedAbortIds))
                     .orderBy(asc(taskTable.id))
                     .for('update');
                 const tasksToSkip = [];
                 for (const task of dependentTasks) {
-                    if (task.failFast && !terminalStatuses.includes(task.status)) {
+                    if (task.abortOnDependencyFailure && !terminalStatuses.includes(task.status)) {
                         tasksToSkip.push(task.id);
                         skippedTaskIds.add(task.id);
                     }
@@ -1010,7 +1009,7 @@ let PostgresTaskQueue = class PostgresTaskQueue extends TaskQueue {
                         .set({
                         status: TaskStatus.Skipped,
                         token: null,
-                        error: jsonbBuildObject({ code: 'DependencyFailed', message: 'One or more dependencies failed and failFast is enabled' }),
+                        error: jsonbBuildObject({ code: 'DependencyFailed', message: 'One or more dependencies failed and abortOnDependencyFailure is enabled' }),
                         completeTimestamp: TRANSACTION_TIMESTAMP,
                     })
                         .where(inArray(taskTable.id, tasksToSkip))

package/task-queue/postgres/task.model.d.ts

@@ -16,7 +16,7 @@ export declare abstract class PostgresTaskBase<Data extends ObjectLiteral = Obje
     traceId: string | null;
     parentId: string | null;
     tags: string[];
-    failFast: boolean;
+    abortOnDependencyFailure: boolean;
     priority: number;
     unresolvedScheduleDependencies: number;
     unresolvedCompleteDependencies: number;

package/task-queue/postgres/task.model.js

@@ -26,7 +26,7 @@ export class PostgresTaskBase extends BaseEntity {
     traceId;
     parentId;
     tags;
-    failFast;
+    abortOnDependencyFailure;
     priority;
     unresolvedScheduleDependencies;
     unresolvedCompleteDependencies;
@@ -76,7 +76,7 @@ __decorate([
 __decorate([
     BooleanProperty(),
     __metadata("design:type", Boolean)
-], PostgresTaskBase.prototype, "failFast", void 0);
+], PostgresTaskBase.prototype, "abortOnDependencyFailure", void 0);
 __decorate([
     Integer(),
     __metadata("design:type", Number)

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

@@ -158,8 +158,8 @@ export type Task<Definitions extends TaskDefinitionMap = Record<string, {
         unresolvedScheduleDependencies: number;
         /** The number of unresolved completion dependencies. */
         unresolvedCompleteDependencies: number;
-        /** Whether to skip the task if any of its dependencies fail. */
-        failFast: boolean;
+        /** Whether to skip the task if any of its dependencies fail (dependency finalized with a status not in `blockParent`). */
+        abortOnDependencyFailure: boolean;
         /** The data associated with the task. */
         data: TaskData<Definitions, Type>;
         /** The ID of the parent task, if any. */
@@ -240,9 +240,9 @@ export type EnqueueOptions = {
      */
     completeAfter?: TaskDependencySpecification[];
     /** Whether to skip the task if any of its dependencies fail. */
-    failFast?: boolean;
-    /** Whether the parent task should wait for this task to complete. */
-    waitForCompletion?: boolean;
+    abortOnDependencyFailure?: boolean;
+    /** The statuses the parent task should wait for this task to reach. */
+    blockParent?: boolean | TaskStatus[];
     /** The timestamp when the task should be processed. */
     scheduleTimestamp?: number;
     /** The duration (ms) before the task is considered expired. */

package/task-queue/tests/coverage-branch.test.js

@@ -305,9 +305,9 @@ describe('Task Queue Branch Coverage Enhancement', () => {
         const updated = await pruneQueue.getTask(task.id);
         expect(updated?.status).toBe(TaskStatus.TimedOut);
     });
-    it('should handle enqueueMany with parentId and waitForCompletion false', async () => {
+    it('should handle enqueueMany with parentId and blockParent false', async () => {
         const parent = await queue.enqueue('p', {});
-        const tasks = await queue.enqueueMany([{ type: 'child', data: {}, parentId: parent.id, waitForCompletion: false }], { returnTasks: true });
+        const tasks = await queue.enqueueMany([{ type: 'child', data: {}, parentId: parent.id, blockParent: false }], { returnTasks: true });
         expect(tasks).toHaveLength(1);
         expect(tasks[0]?.parentId).toBe(parent.id);
         const updatedParent = await queue.getTask(parent.id);

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

@@ -64,14 +64,14 @@ describe('Extensive Task Queue Dependency Tests', () => {
         await completeTask('E');
         await queue.waitForTasks([taskF.id], { statuses: [TaskStatus.Pending] });
     });
-    it('should respect failFast = false (continue other branches)', async () => {
+    it('should respect abortOnDependencyFailure = false (continue other branches)', async () => {
         const taskA = await queue.enqueue('A', {});
-        const taskB = await queue.enqueue('B', {}, { scheduleAfter: [taskA.id], failFast: false });
+        const taskB = await queue.enqueue('B', {}, { scheduleAfter: [taskA.id], abortOnDependencyFailure: 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.
+        // If abortOnDependencyFailure 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);
@@ -163,12 +163,12 @@ describe('Extensive Task Queue Dependency Tests', () => {
         await completeTask('D2');
         await queue.waitForTasks([taskE.id], { statuses: [TaskStatus.Pending] });
     });
-    it('should handle fail-fast cascade', async () => {
+    it('should handle abort cascade', async () => {
         const taskA = await queue.enqueue('A', {});
-        const taskB = await queue.enqueue('B', {}, { scheduleAfter: [taskA.id], failFast: true });
-        const taskC = await queue.enqueue('C', {}, { scheduleAfter: [taskB.id], failFast: true });
-        const taskD = await queue.enqueue('D', {}, { scheduleAfter: [taskA.id], failFast: true });
-        const taskE = await queue.enqueue('E', {}, { scheduleAfter: [taskC.id, taskD.id], failFast: true });
+        const taskB = await queue.enqueue('B', {}, { scheduleAfter: [taskA.id], abortOnDependencyFailure: true });
+        const taskC = await queue.enqueue('C', {}, { scheduleAfter: [taskB.id], abortOnDependencyFailure: true });
+        const taskD = await queue.enqueue('D', {}, { scheduleAfter: [taskA.id], abortOnDependencyFailure: true });
+        const taskE = await queue.enqueue('E', {}, { scheduleAfter: [taskC.id, taskD.id], abortOnDependencyFailure: true });
         const dA = await queue.dequeue({ types: ['A'] });
         await queue.fail(dA, new Error('fatal'), { fatal: true });
         await queue.waitForTasks([taskB.id, taskC.id, taskD.id, taskE.id], { statuses: [TaskStatus.Skipped] });

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

@@ -61,11 +61,11 @@ describe('Queue Dependencies & Tree Tests', () => {
             const d2 = await queue.dequeue({ types: ['dependent'] });
             expect(d2?.id).toBe(dependent.id);
         });
-        it('should fail-fast if dependency fails', async () => {
+        it('should abort if dependency fails', async () => {
             const prereq = await queue.enqueue('prereq', {});
             const dependent = await queue.enqueue('dependent', {}, {
                 scheduleAfter: [prereq.id],
-                failFast: true
+                abortOnDependencyFailure: true,
             });
             const dequeued = await queue.dequeue({ types: ['prereq'] });
             // Fail fatally
@@ -75,10 +75,10 @@ describe('Queue Dependencies & Tree Tests', () => {
             expect(updatedDependent?.status).toBe(TaskStatus.Skipped);
             expect(updatedDependent?.error?.code).toBe('DependencyFailed');
         });
-        it('should NOT overwrite terminal states during cancellation (failFast + complete)', async () => {
+        it('should NOT overwrite terminal states during cancellation (abortOnDependencyFailure + complete)', async () => {
             const dep = await queue.enqueue('dep', {});
             // completeAfter allows 'main' to be Running while 'dep' is not finished
-            const main = await queue.enqueue('main', {}, { completeAfter: [dep.id], failFast: true });
+            const main = await queue.enqueue('main', {}, { completeAfter: [dep.id], abortOnDependencyFailure: true });
             const runningDep = await queue.dequeue();
             expect(runningDep?.id).toBe(dep.id);
             const runningMain = await queue.dequeue();
@@ -110,13 +110,13 @@ describe('Queue Dependencies & Tree Tests', () => {
             await queueA.clear();
             await queueB.clear();
         });
-        it('should correctly skip dependent tasks across namespaces when failFast is triggered', async () => {
+        it('should correctly skip dependent tasks across namespaces when abortOnDependencyFailure is triggered', async () => {
             const queueProvider = injector.resolve(TaskQueueProvider);
             const queueA = queueProvider.get(`QueueA-${crypto.randomUUID()}`);
             const queueB = queueProvider.get(`QueueB-${crypto.randomUUID()}`);
             const taskA = await queueA.enqueue('test', { value: 'A' });
             const taskB = await queueB.enqueue('test', { value: 'B' }, {
-                failFast: true,
+                abortOnDependencyFailure: true,
                 scheduleAfter: [{ id: taskA.id }],
             });
             const dequeuedA = await queueA.dequeue();
@@ -132,7 +132,7 @@ describe('Queue Dependencies & Tree Tests', () => {
             const prereq = await queue.enqueue('prereq', {});
             // Wait for prereq to be Dead or Completed
             const dependent = await queue.enqueue('dependent', {}, {
-                scheduleAfter: [{ id: prereq.id, requiredStatuses: [TaskStatus.Dead, TaskStatus.Completed] }]
+                scheduleAfter: [{ id: prereq.id, requiredStatuses: [TaskStatus.Dead, TaskStatus.Completed] }],
             });
             // Fail fatally -> Dead
             const d1 = await queue.dequeue({ types: ['prereq'] });
@@ -234,7 +234,7 @@ describe('Queue Dependencies & Tree Tests', () => {
         });
         it('should NOT resolve completed tasks as Cancelled when calling cancelMany (Issue 3)', async () => {
             const taskA = await queue.enqueue('test', { name: 'A' });
-            const taskB = await queue.enqueue('test', { name: 'B' }, { scheduleAfter: [taskA.id], failFast: true });
+            const taskB = await queue.enqueue('test', { name: 'B' }, { scheduleAfter: [taskA.id], abortOnDependencyFailure: true });
             const dequeuedA = await queue.dequeue();
             await queue.complete(dequeuedA);
             // B should have unresolvedScheduleDependencies = 0 and be Pending because A completed
@@ -243,7 +243,7 @@ describe('Queue Dependencies & Tree Tests', () => {
             expect(freshB?.status).toBe(TaskStatus.Pending);
             // Cancel A. Since A is Completed, it shouldn't be touched in DB.
             // Importantly, it shouldn't trigger dependency resolution for B as 'Cancelled'.
-            // In the old code, this would have caused B to be transitioned to 'Skipped' because A was resolved as 'Cancelled' but B required 'Completed' (and failFast is true).
+            // In the old code, this would have caused B to be transitioned to 'Skipped' because A was resolved as 'Cancelled' but B required 'Completed' (and abortOnDependencyFailure is true).
             await queue.cancelMany([taskA.id]);
             const stillFreshA = await queue.getTask(taskA.id);
             expect(stillFreshA?.status).toBe(TaskStatus.Completed);
@@ -280,7 +280,7 @@ describe('Queue Dependencies & Tree Tests', () => {
             await queue.enqueueMany([
                 { type: 'b', data: { val: 1 } },
                 { type: 'b', data: { val: 2 } },
-                { type: 'b', data: { val: 3 } }
+                { type: 'b', data: { val: 3 } },
             ]);
             const token = new CancellationToken();
             const batchConsumer = queue.getBatchConsumer(2, token);

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

@@ -45,11 +45,11 @@ describe('Fan-Out Spawning', () => {
         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 () => {
+    it('should NOT transition parent to Waiting if blockParent 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 });
+        // Spawn child with blockParent: false
+        await queue.enqueueMany([{ type: 'child', data: {}, parentId: parent.id, blockParent: false }], { returnTasks: true });
         await queue.complete(dParent);
         const uParent = await queue.getTask(parent.id);
         expect(uParent?.status).toBe(TaskStatus.Completed); // Finished immediately

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

@@ -195,7 +195,7 @@ describe('PostgresQueue (Distributed Task Orchestration)', () => {
             const queueB = queueProvider.get(nameB);
             const parent = await queueA.enqueue('test', { value: 'parent' });
             expect(parent.unresolvedCompleteDependencies).toBe(0);
-            await queueB.enqueue('test', { value: 'child' }, { parentId: parent.id, waitForCompletion: true });
+            await queueB.enqueue('test', { value: 'child' }, { parentId: parent.id, blockParent: true });
             const updatedParent = await queueA.getTask(parent.id);
             expect(updatedParent?.unresolvedCompleteDependencies).toBe(1);
             await database.update(taskTable).set({ parentId: null }).where(or(eq(taskTable.namespace, nameA), eq(taskTable.namespace, nameB)));
@@ -254,7 +254,7 @@ describe('PostgresQueue (Distributed Task Orchestration)', () => {
             await q.enqueue('test', {}, {
                 idempotencyKey,
                 parentId: parent.id,
-                waitForCompletion: true,
+                blockParent: true,
             });
             // Dequeue and complete parent
             const dequeuedParent = await q.dequeue();
@@ -263,10 +263,10 @@ describe('PostgresQueue (Distributed Task Orchestration)', () => {
             expect(updatedParent?.status).toBe(TaskStatus.Completed);
             await q.clear();
         });
-        it('should increment unresolvedCompleteDependencies for children with waitForCompletion: true (Bug 6-2)', async () => {
+        it('should increment unresolvedCompleteDependencies for children with blockParent: true (Bug 6-2)', async () => {
             const parent = await queue.enqueue('parent', {});
             expect(parent.unresolvedCompleteDependencies).toBe(0);
-            await queue.enqueue('child', {}, { parentId: parent.id, waitForCompletion: true });
+            await queue.enqueue('child', {}, { parentId: parent.id, blockParent: true });
             const updatedParent = await queue.getTask(parent.id);
             expect(updatedParent?.unresolvedCompleteDependencies).toBe(1);
         });

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

@@ -21,11 +21,11 @@ describe('Zombie Parent Deadlock', () => {
     afterAll(async () => {
         await injector?.dispose();
     });
-    it('should resolve parent even if child fails (failFast: false)', async () => {
+    it('should resolve parent even if child fails (abortOnDependencyFailure: false)', async () => {
         const parent = await queue.enqueue('parent', {});
         const dParent = await queue.dequeue();
-        // Spawn a child that will fail. Parent has failFast: false by default.
-        const [child] = await queue.enqueueMany([{ type: 'child', data: {}, parentId: parent.id, failFast: false }], { returnTasks: true });
+        // Spawn a child that will fail. Parent has abortOnDependencyFailure: false by default.
+        const [child] = await queue.enqueueMany([{ type: 'child', data: {}, parentId: parent.id, abortOnDependencyFailure: false }], { returnTasks: true });
         await queue.complete(dParent);
         // Parent should be WaitingChildren
         const uParent = await queue.getTask(parent.id);