@tstdl/base 0.93.142 → 0.93.144

package/authentication/client/authentication.service.d.ts

@@ -31,6 +31,7 @@ export declare class AuthenticationClientService<AdditionalTokenPayload extends
     private clockOffset;
     private initialized;
     private refreshLoopPromise;
+    private loggingOut;
     /**
      * Observable for authentication errors.
      * Emits when a refresh fails.

package/authentication/client/authentication.service.js

@@ -74,6 +74,7 @@ let AuthenticationClientService = class AuthenticationClientService {
     clockOffset = 0;
     initialized = false;
     refreshLoopPromise;
+    loggingOut;
     /**
      * Observable for authentication errors.
      * Emits when a refresh fails.
@@ -233,18 +234,26 @@ let AuthenticationClientService = class AuthenticationClientService {
      * This will attempt to end the session on the server and then clear local credentials.
      */
     async logout() {
-        try {
-            await Promise.race([
-                this.client.endSession(),
-                timeout(logoutTimeout),
-            ]).catch((error) => this.logger.error(error));
-        }
-        finally {
-            // Always clear the local token, even if the server call fails.
-            this.forceRefreshRequested.set(false);
-            this.setNewToken(undefined);
-            this.loggedOutBus.publishAndForget();
+        if (isDefined(this.loggingOut)) {
+            await this.loggingOut;
+            return;
         }
+        this.loggingOut = (async () => {
+            try {
+                await Promise.race([
+                    this.client.endSession(),
+                    timeout(logoutTimeout),
+                ]).catch((error) => this.logger.error(error));
+            }
+            finally {
+                // Always clear the local token, even if the server call fails.
+                this.forceRefreshRequested.set(false);
+                this.setNewToken(undefined);
+                this.loggedOutBus.publishAndForget();
+                this.loggingOut = undefined;
+            }
+        })();
+        await this.loggingOut;
     }
     /**
      * Force an immediate refresh of the token.

package/authentication/client/http-client.middleware.js

@@ -36,14 +36,17 @@ export function waitForAuthenticationCredentialsMiddleware(authenticationService
  */
 export function logoutOnUnauthorizedMiddleware(authenticationServiceOrProvider) {
     const getAuthenticationService = cacheValueOrAsyncProvider(authenticationServiceOrProvider);
-    async function logoutOnUnauthorizedMiddleware(_context, next) {
+    async function logoutOnUnauthorizedMiddleware({ request }, next) {
         try {
             await next();
         }
         catch (error) {
             if ((error instanceof HttpError) && (error.response?.statusCode == 401)) {
-                const authenticationService = await getAuthenticationService();
-                await authenticationService.logout();
+                const endpoint = request.context?.endpoint;
+                if (endpoint?.data?.[dontWaitForValidToken] != true) {
+                    const authenticationService = await getAuthenticationService();
+                    await authenticationService.logout();
+                }
             }
             throw error;
         }

package/authentication/tests/authentication.client-middleware.test.js

@@ -1,6 +1,7 @@
 import { of } from 'rxjs';
 import { describe, expect, test, vi } from 'vitest';
 import { HttpClientRequest, HttpClientResponse, HttpError, HttpErrorReason } from '../../http/index.js';
+import { dontWaitForValidToken } from '../authentication.api.js';
 import { logoutOnUnauthorizedMiddleware, waitForAuthenticationCredentialsMiddleware } from '../client/http-client.middleware.js';
 describe('waitForAuthenticationCredentialsMiddleware', () => {
     test('should wait for token and call next', async () => {
@@ -41,6 +42,33 @@ describe('logoutOnUnauthorizedMiddleware', () => {
         await expect(middleware({ request }, next)).rejects.toThrow(HttpError);
         expect(authenticationServiceMock.logout).toHaveBeenCalled();
     });
+    test('should NOT call logout on 401 error if endpoint has dontWaitForValidToken', async () => {
+        const authenticationServiceMock = {
+            logout: vi.fn().mockResolvedValue(undefined),
+        };
+        const middleware = logoutOnUnauthorizedMiddleware(authenticationServiceMock);
+        const request = new HttpClientRequest('http://localhost');
+        request.context = {
+            endpoint: {
+                resource: 'end-session',
+                data: {
+                    [dontWaitForValidToken]: true,
+                },
+            },
+        };
+        const response = new HttpClientResponse({
+            request,
+            statusCode: 401,
+            statusMessage: 'Unauthorized',
+            headers: {},
+            body: undefined,
+            closeHandler: () => { }
+        });
+        const error = new HttpError(HttpErrorReason.StatusCode, request, { response });
+        const next = vi.fn().mockRejectedValue(error);
+        await expect(middleware({ request }, next)).rejects.toThrow(HttpError);
+        expect(authenticationServiceMock.logout).not.toHaveBeenCalled();
+    });
     test('should not call logout on other errors', async () => {
         const authenticationServiceMock = {
             logout: vi.fn().mockResolvedValue(undefined),

package/authentication/tests/authentication.client-service-methods.test.js

@@ -1,19 +1,20 @@
-import { describe, expect, test, vi, beforeEach, afterEach } from 'vitest';
 import { Subject } from 'rxjs';
+import { afterEach, beforeEach, describe, expect, test, vi } from 'vitest';
 import { AuthenticationClientService } from '../../authentication/client/authentication.service.js';
 import { AUTHENTICATION_API_CLIENT } from '../../authentication/client/tokens.js';
+import { CancellationSignal, CancellationToken } from '../../cancellation/token.js';
+import { Injector } from '../../injector/index.js';
 import { Lock } from '../../lock/index.js';
 import { Logger } from '../../logger/index.js';
 import { MessageBus } from '../../message-bus/index.js';
-import { Injector } from '../../injector/index.js';
-import { CancellationSignal, CancellationToken } from '../../cancellation/token.js';
 import { configureDefaultSignalsImplementation } from '../../signals/implementation/configure.js';
 describe('AuthenticationClientService Methods', () => {
     let injector;
     let service;
     let mockApiClient;
     let mockLock;
-    let mockMessageBus;
+    let mockTokenUpdateBus;
+    let mockLoggedOutBus;
     let mockLogger;
     beforeEach(() => {
         const storage = new Map();
@@ -46,9 +47,16 @@ describe('AuthenticationClientService Methods', () => {
                 return await callback({ lost: false });
             }),
         };
-        mockMessageBus = {
+        mockTokenUpdateBus = {
             publishAndForget: vi.fn(),
             messages$: new Subject(),
+            allMessages$: new Subject(),
+            dispose: vi.fn(),
+        };
+        mockLoggedOutBus = {
+            publishAndForget: vi.fn(),
+            messages$: new Subject(),
+            allMessages$: new Subject(),
             dispose: vi.fn(),
         };
         mockLogger = {
@@ -59,7 +67,15 @@ describe('AuthenticationClientService Methods', () => {
         };
         injector.register(AUTHENTICATION_API_CLIENT, { useValue: mockApiClient });
         injector.register(Lock, { useValue: mockLock });
-        injector.register(MessageBus, { useValue: mockMessageBus });
+        injector.register(MessageBus, {
+            useFactory: (argument) => {
+                if (argument === 'AuthenticationService:tokenUpdate')
+                    return mockTokenUpdateBus;
+                if (argument === 'AuthenticationService:loggedOut')
+                    return mockLoggedOutBus;
+                return undefined;
+            },
+        });
         injector.register(Logger, { useValue: mockLogger });
         const disposeToken = new CancellationToken();
         injector.register(CancellationSignal, { useValue: disposeToken.signal });
@@ -122,6 +138,22 @@ describe('AuthenticationClientService Methods', () => {
         mockApiClient.unimpersonate.mockRejectedValue(new Error('Unimpersonation failed'));
         await expect(service.unimpersonate()).rejects.toThrow('Unimpersonation failed');
     });
+    test('logout should handle concurrent calls and avoid multiple api requests', async () => {
+        let resolveEndSession;
+        const endSessionPromise = new Promise((resolve) => {
+            resolveEndSession = resolve;
+        });
+        mockApiClient.endSession.mockReturnValue(endSessionPromise);
+        const logout1 = service.logout();
+        const logout2 = service.logout();
+        // logout1 and logout2 will be different promises because the method is async
+        expect(mockApiClient.endSession).toHaveBeenCalledTimes(1);
+        resolveEndSession(undefined);
+        await Promise.all([logout1, logout2]);
+        expect(service.isLoggedIn()).toBe(false);
+        expect(mockTokenUpdateBus.publishAndForget).toHaveBeenCalledWith(undefined);
+        expect(mockLoggedOutBus.publishAndForget).toHaveBeenCalled();
+    });
     test('syncClock should handle errors gracefully', async () => {
         mockApiClient.timestamp.mockRejectedValue(new Error('Time sync failed'));
         await service.syncClock();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tstdl/base",
-  "version": "0.93.142",
+  "version": "0.93.144",
   "author": "Patrick Hein",
   "publishConfig": {
     "access": "public"
@@ -152,8 +152,8 @@
     "type-fest": "^5.4"
   },
   "peerDependencies": {
-    "@aws-sdk/client-s3": "^3.997",
-    "@aws-sdk/s3-request-presigner": "^3.997",
+    "@aws-sdk/client-s3": "^3.999",
+    "@aws-sdk/s3-request-presigner": "^3.999",
     "@genkit-ai/google-genai": "^1.29",
     "@google-cloud/storage": "^7.19",
     "@toon-format/toon": "^2.1.0",

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,12 +71,12 @@ 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 { defaultQueueConfig, queueableOrWaitableStatuses, queueableStatuses, TaskDependencyType, TaskQueue, TaskStatus, terminalStatuses } from '../task-queue.js';
 import { PostgresTaskQueueModuleConfig } from './module.js';
 import { taskArchive as taskArchiveTable, taskDependency as taskDependencyTable, taskDependencyType, taskStatus, task as taskTable } from './schemas.js';
-import { finalizedStatuses, PostgresTask, PostgresTaskArchive, queueableOrWaitableStatuses, queueableStatuses, terminalStatuses } from './task.model.js';
+import { PostgresTask, PostgresTaskArchive } from './task.model.js';
 let PostgresTaskQueue = class PostgresTaskQueue extends TaskQueue {
     #database = inject(Database);
     #repository = injectRepository(PostgresTask);
@@ -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.parentRequires != false) && !(isArray(item.parentRequires) && (item.parentRequires.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.parentRequires != false) && !(isArray(item.parentRequires) && (item.parentRequires.length == 0))) {
                         dependencies.push({
                             taskId: item.parentId,
                             dependencyTaskId: task.id,
                             type: TaskDependencyType.Child,
-                            requiredStatuses: [TaskStatus.Completed],
+                            requiredStatuses: isArray(item.parentRequires)
+                                ? item.parentRequires
+                                : [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 });
                         }
                     }
                 }
@@ -506,7 +506,7 @@ let PostgresTaskQueue = class PostgresTaskQueue extends TaskQueue {
         const timeout = options?.timeout ?? Infinity;
         const interval = options?.interval ?? 1000;
         const cancellationSignal = this.#cancellationSignal.optionallyInherit(options?.cancellationSignal);
-        const waitStatuses = options?.statuses ?? finalizedStatuses;
+        const waitStatuses = options?.statuses ?? terminalStatuses;
         const messageBus$ = this.#messageBus.allMessages$.pipe(filter((namespace) => namespace == this.#namespace), throttleTime(500, undefined, { leading: true, trailing: true }));
         const continue$ = merge(messageBus$, cancellationSignal);
         const timer = Timer.startNew();
@@ -566,7 +566,7 @@ let PostgresTaskQueue = class PostgresTaskQueue extends TaskQueue {
             const nonFinalizedTasks = await tx.pgTransaction
                 .select({ id: taskTable.id, namespace: taskTable.namespace })
                 .from(taskTable)
-                .where(and(eq(taskTable.namespace, this.#namespace), notInArray(taskTable.status, finalizedStatuses)))
+                .where(and(eq(taskTable.namespace, this.#namespace), notInArray(taskTable.status, terminalStatuses)))
                 .for('update');
             if (nonFinalizedTasks.length > 0) {
                 const ids = nonFinalizedTasks.map((t) => t.id);
@@ -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))
@@ -1066,7 +1065,7 @@ let PostgresTaskQueue = class PostgresTaskQueue extends TaskQueue {
                     status: taskTable.status,
                 });
                 for (const row of updatedRows) {
-                    if (finalizedStatuses.includes(row.status)) {
+                    if (terminalStatuses.includes(row.status)) {
                         terminalTasks.push({ id: row.id, status: row.status, namespace: row.namespace });
                     }
                     notifiedNamespaces.add(row.namespace);
@@ -1102,7 +1101,7 @@ let PostgresTaskQueue = class PostgresTaskQueue extends TaskQueue {
                 const rowsToArchive = await tx.pgTransaction
                     .select()
                     .from(taskTable)
-                    .where(and(eq(taskTable.namespace, this.#namespace), inArray(taskTable.status, finalizedStatuses), lte(taskTable.completeTimestamp, sql `${TRANSACTION_TIMESTAMP} - ${interval(this.retention, 'milliseconds')}`), notExists(tx.pgTransaction
+                    .where(and(eq(taskTable.namespace, this.#namespace), inArray(taskTable.status, terminalStatuses), lte(taskTable.completeTimestamp, sql `${TRANSACTION_TIMESTAMP} - ${interval(this.retention, 'milliseconds')}`), notExists(tx.pgTransaction
                     .select({ id: childTaskTable.id })
                     .from(childTaskTable)
                     .where(eq(childTaskTable.parentId, taskTable.id))), notExists(tx.pgTransaction
@@ -1300,7 +1299,7 @@ let PostgresTaskQueue = class PostgresTaskQueue extends TaskQueue {
             priorityAgeTimestamp: TRANSACTION_TIMESTAMP,
             state: (options?.resetState == true) ? null : undefined,
         })
-            .where(and(eq(taskTable.id, id), or(inArray(taskTable.status, queueableStatuses), inArray(taskTable.status, finalizedStatuses), lt(taskTable.visibilityDeadline, TRANSACTION_TIMESTAMP))));
+            .where(and(eq(taskTable.id, id), or(inArray(taskTable.status, queueableStatuses), inArray(taskTable.status, terminalStatuses), lt(taskTable.visibilityDeadline, TRANSACTION_TIMESTAMP))));
     }
     notify(namespace = this.#namespace) {
         this.#messageBus.publishAndForget(namespace);

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

@@ -2,12 +2,6 @@
 import { BaseEntity, type Json, type Timestamp } from '../../orm/index.js';
 import type { ObjectLiteral } from '../../types/types.js';
 import { type Task, TaskDependencyType, TaskStatus } from '../task-queue.js';
-export declare const terminalStatuses: TaskStatus[];
-export declare const finalizedStatuses: TaskStatus[];
-export declare const nonFinalizedStatuses: TaskStatus[];
-export declare const queueableStatuses: TaskStatus[];
-export declare const waitableStatuses: TaskStatus[];
-export declare const queueableOrWaitableStatuses: TaskStatus[];
 export declare abstract class PostgresTaskBase<Data extends ObjectLiteral = ObjectLiteral, State extends ObjectLiteral = ObjectLiteral, Result extends ObjectLiteral = ObjectLiteral> extends BaseEntity implements Task {
     namespace: string;
     type: string;
@@ -16,7 +10,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

@@ -11,13 +11,7 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 import { BaseEntity, ForeignKey, Index, JsonProperty, Table, TimestampProperty, Unique, UuidProperty } from '../../orm/index.js';
 import { Array as ArrayProperty, BooleanProperty, Enumeration, Integer, NumberProperty, StringProperty } from '../../schema/index.js';
 import { isNotNull } from 'drizzle-orm';
-import { TaskDependencyType, TaskStatus } from '../task-queue.js';
-export const terminalStatuses = [TaskStatus.Completed, TaskStatus.Cancelled, TaskStatus.Dead, TaskStatus.TimedOut, TaskStatus.Expired, TaskStatus.Skipped, TaskStatus.Orphaned];
-export const finalizedStatuses = terminalStatuses;
-export const nonFinalizedStatuses = [TaskStatus.Pending, TaskStatus.Retrying, TaskStatus.Waiting, TaskStatus.WaitingChildren, TaskStatus.Running];
-export const queueableStatuses = [TaskStatus.Pending, TaskStatus.Retrying];
-export const waitableStatuses = [TaskStatus.Waiting, TaskStatus.WaitingChildren];
-export const queueableOrWaitableStatuses = [...queueableStatuses, ...waitableStatuses];
+import { queueableOrWaitableStatuses, queueableStatuses, TaskDependencyType, TaskStatus, terminalStatuses } from '../task-queue.js';
 export class PostgresTaskBase extends BaseEntity {
     namespace;
     type;
@@ -26,7 +20,7 @@ export class PostgresTaskBase extends BaseEntity {
     traceId;
     parentId;
     tags;
-    failFast;
+    abortOnDependencyFailure;
     priority;
     unresolvedScheduleDependencies;
     unresolvedCompleteDependencies;
@@ -76,7 +70,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

@@ -95,10 +95,20 @@ export declare const TaskStatus: {
      */
     readonly Orphaned: "orphaned";
 };
+export declare const terminalStatuses: ["completed", "cancelled", "dead", "timed-out", "expired", "skipped", "orphaned"];
+export declare const nonTerminalStatuses: ["pending", "retrying", "waiting", "waiting-children", "running"];
+export declare const queueableStatuses: ["pending", "retrying"];
+export declare const waitableStatuses: ["waiting", "waiting-children"];
+export declare const queueableOrWaitableStatuses: ["pending", "retrying", "waiting", "waiting-children"];
 /**
  * Type of task status.
  */
 export type TaskStatus = EnumType<typeof TaskStatus>;
+export type TerminalTaskStatus = typeof terminalStatuses[number];
+export type NonTerminalTaskStatus = typeof nonTerminalStatuses[number];
+export type QueueableTaskStatus = typeof queueableStatuses[number];
+export type WaitableTaskStatus = typeof waitableStatuses[number];
+export type QueueableOrWaitableTaskStatus = typeof queueableOrWaitableStatuses[number];
 /**
  * Represents the type of dependency between tasks.
  */
@@ -158,8 +168,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 `parentRequires`). */
+        abortOnDependencyFailure: boolean;
         /** The data associated with the task. */
         data: TaskData<Definitions, Type>;
         /** The ID of the parent task, if any. */
@@ -240,9 +250,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. */
+    parentRequires?: boolean | TerminalTaskStatus[];
     /** The timestamp when the task should be processed. */
     scheduleTimestamp?: number;
     /** The duration (ms) before the task is considered expired. */

package/task-queue/task-queue.js

@@ -157,6 +157,11 @@ export const TaskStatus = defineEnum('TaskStatus', {
      */
     Orphaned: 'orphaned',
 });
+export const terminalStatuses = [TaskStatus.Completed, TaskStatus.Cancelled, TaskStatus.Dead, TaskStatus.TimedOut, TaskStatus.Expired, TaskStatus.Skipped, TaskStatus.Orphaned];
+export const nonTerminalStatuses = [TaskStatus.Pending, TaskStatus.Retrying, TaskStatus.Waiting, TaskStatus.WaitingChildren, TaskStatus.Running];
+export const queueableStatuses = [TaskStatus.Pending, TaskStatus.Retrying];
+export const waitableStatuses = [TaskStatus.Waiting, TaskStatus.WaitingChildren];
+export const queueableOrWaitableStatuses = [...queueableStatuses, ...waitableStatuses];
 /**
  * Represents the type of dependency between tasks.
  */

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 parentRequires 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, parentRequires: 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 parentRequires 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 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

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, parentRequires: 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,
+                parentRequires: 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 parentRequires: 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, parentRequires: 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);