@tstdl/base 0.93.143 → 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.143",
+  "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/task-queue.js

@@ -73,10 +73,10 @@ import { Timer } from '../../utils/timer.js';
 import { cancelableTimeout } from '../../utils/timing.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);
@@ -189,7 +189,7 @@ let PostgresTaskQueue = class PostgresTaskQueue extends TaskQueue {
             }));
             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.blockParent != false) && !(isArray(item.blockParent) && (item.blockParent.length == 0))));
+            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;
@@ -258,13 +258,13 @@ let PostgresTaskQueue = class PostgresTaskQueue extends TaskQueue {
                     if (!processedTaskIds.has(task.id)) {
                         continue;
                     }
-                    if (isDefined(item.parentId) && (item.blockParent != false) && !(isArray(item.blockParent) && (item.blockParent.length == 0))) {
+                    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: isArray(item.blockParent)
-                                ? item.blockParent
+                            requiredStatuses: isArray(item.parentRequires)
+                                ? item.parentRequires
                                 : [TaskStatus.Completed],
                         });
                     }
@@ -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);
@@ -1065,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);
@@ -1101,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
@@ -1299,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;

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;

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,7 +168,7 @@ 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 (dependency finalized with a status not in `blockParent`). */
+        /** 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>;
@@ -242,7 +252,7 @@ export type EnqueueOptions = {
     /** Whether to skip the task if any of its dependencies fail. */
     abortOnDependencyFailure?: boolean;
     /** The statuses the parent task should wait for this task to reach. */
-    blockParent?: boolean | TaskStatus[];
+    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 blockParent 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, blockParent: 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/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 blockParent 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 blockParent: false
-        await queue.enqueueMany([{ type: 'child', data: {}, parentId: parent.id, blockParent: 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, blockParent: 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,
-                blockParent: 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 blockParent: 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, blockParent: true });
+            await queue.enqueue('child', {}, { parentId: parent.id, parentRequires: true });
             const updatedParent = await queue.getTask(parent.id);
             expect(updatedParent?.unresolvedCompleteDependencies).toBe(1);
         });