@tstdl/base 0.93.175 → 0.93.177

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

@@ -8,6 +8,13 @@
       "when": 1772055508571,
       "tag": "0000_faithful_daimon_hellstrom",
       "breakpoints": true
+    },
+    {
+      "idx": 1,
+      "version": "7",
+      "when": 1774305322701,
+      "tag": "0001_rapid_infant_terrible",
+      "breakpoints": true
     }
   ]
 }

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

@@ -64,7 +64,7 @@ import { NotFoundError, serializeError, TimeoutError } from '../../errors/index.
 import { afterResolve, inject, provide, Singleton } from '../../injector/index.js';
 import { Logger } from '../../logger/index.js';
 import { MessageBus } from '../../message-bus/index.js';
-import { arrayOverlaps, caseWhen, coalesce, enumValue, greatest, interval, jsonbBuildObject, least, power, RANDOM_UUID_V4, TRANSACTION_TIMESTAMP } from '../../orm/index.js';
+import { arrayOverlaps, buildJsonb, caseWhen, coalesce, enumValue, greatest, interval, least, power, RANDOM_UUID_V4, TRANSACTION_TIMESTAMP } from '../../orm/index.js';
 import { DatabaseConfig, injectRepository } from '../../orm/server/index.js';
 import { RateLimiter } from '../../rate-limit/index.js';
 import { distinct, toArray } from '../../utils/array/array.js';
@@ -133,7 +133,7 @@ let PostgresTaskQueue = class PostgresTaskQueue extends TaskQueue {
         progress: 0,
         data: sql `excluded.data`,
         state: null,
-        error: null,
+        errors: buildJsonb([]),
         result: null,
     };
     [afterResolve]() {
@@ -183,7 +183,7 @@ let PostgresTaskQueue = class PostgresTaskQueue extends TaskQueue {
                     data: item.data,
                     state: null,
                     result: null,
-                    error: null,
+                    errors: buildJsonb([]),
                 },
             }));
             const itemsWithIdempotency = entitiesWithIndex.filter((e) => isNotNull(e.entity.idempotencyKey));
@@ -721,7 +721,7 @@ let PostgresTaskQueue = class PostgresTaskQueue extends TaskQueue {
             status: caseWhen(exceededMaxExecutionTime, enumValue(TaskStatus, taskStatus, TaskStatus.TimedOut)).else(taskTable.status),
             visibilityDeadline: caseWhen(exceededMaxExecutionTime, null).else(sql `${TRANSACTION_TIMESTAMP} + ${interval(this.visibilityTimeout, 'milliseconds')}`),
             completeTimestamp: caseWhen(exceededMaxExecutionTime, TRANSACTION_TIMESTAMP).else(taskTable.completeTimestamp),
-            error: caseWhen(exceededMaxExecutionTime, jsonbBuildObject({ code: 'MaxTimeExceeded', message: 'Hard Execution Timeout' })).else(taskTable.error),
+            errors: caseWhen(exceededMaxExecutionTime, sql `${taskTable.errors} || ${buildJsonb([{ code: 'MaxTimeExceeded', message: 'Hard Execution Timeout' }])}`).else(taskTable.errors),
             progress: caseWhen(exceededMaxExecutionTime, taskTable.progress).else(isDefined(options?.progress) ? options.progress : taskTable.progress),
             state: caseWhen(exceededMaxExecutionTime, taskTable.state).else(isDefined(options?.state) ? options.state : taskTable.state),
         })
@@ -844,7 +844,7 @@ let PostgresTaskQueue = class PostgresTaskQueue extends TaskQueue {
                 .set({
                 status: update.status,
                 token: null,
-                error: update.error,
+                errors: sql `${taskTable.errors} || ${buildJsonb([update.error])}`,
                 visibilityDeadline: null,
                 scheduleTimestamp: (update.status == TaskStatus.Retrying) ? update.scheduleTimestamp : taskTable.scheduleTimestamp,
                 completeTimestamp: update.completeTimestamp,
@@ -866,7 +866,7 @@ let PostgresTaskQueue = class PostgresTaskQueue extends TaskQueue {
             const rows = tasks.map((task, index) => {
                 const error = ensureTaskError(errors[index]);
                 const update = this.getFailureUpdate(task.tries, error);
-                return sql `(${task.id}::uuid, ${task.token}::uuid, ${task.tries}::int, ${update.status}::${taskStatus}, ${update.error}::jsonb, ${update.scheduleTimestamp}::timestamptz, ${update.completeTimestamp}::timestamptz)`;
+                return sql `(${task.id}::uuid, ${task.token}::uuid, ${task.tries}::int, ${update.status}::${taskStatus}, ${buildJsonb([update.error])}, ${update.scheduleTimestamp}::timestamptz, ${update.completeTimestamp}::timestamptz)`;
             });
             const updates = tx.pgTransaction.$with('updates').as((qb) => qb
                 .select({
@@ -874,7 +874,7 @@ let PostgresTaskQueue = class PostgresTaskQueue extends TaskQueue {
                 updateToken: sql `(token)`.as('update_token'),
                 updateTries: sql `(tries)`.as('update_tries'),
                 updateStatus: sql `(status)`.as('update_status'),
-                updateError: sql `(error)`.as('update_error'),
+                updateErrors: sql `(error)`.as('update_errors'),
                 updateSchedule: sql `(schedule_timestamp)`.as('update_schedule'),
                 updateComplete: sql `(complete_timestamp)`.as('update_complete'),
             })
@@ -884,7 +884,7 @@ let PostgresTaskQueue = class PostgresTaskQueue extends TaskQueue {
                 .set({
                 status: sql `${updates.updateStatus}`,
                 token: null,
-                error: sql `${updates.updateError}`,
+                errors: sql `${taskTable.errors} || ${updates.updateErrors}`,
                 visibilityDeadline: null,
                 scheduleTimestamp: caseWhen(eq(updates.updateStatus, TaskStatus.Retrying), updates.updateSchedule).else(taskTable.scheduleTimestamp),
                 completeTimestamp: sql `${updates.updateComplete}`,
@@ -985,7 +985,7 @@ let PostgresTaskQueue = class PostgresTaskQueue extends TaskQueue {
                         .set({
                         status: TaskStatus.Skipped,
                         token: null,
-                        error: jsonbBuildObject({ code: 'DependencyFailed', message: 'One or more dependencies failed and abortOnDependencyFailure is enabled' }),
+                        errors: sql `${taskTable.errors} || ${buildJsonb([{ code: 'DependencyFailed', message: 'One or more dependencies failed and abortOnDependencyFailure is enabled' }])}`,
                         completeTimestamp: TRANSACTION_TIMESTAMP,
                     })
                         .where(inArray(taskTable.id, tasksToSkip))
@@ -1132,7 +1132,7 @@ let PostgresTaskQueue = class PostgresTaskQueue extends TaskQueue {
                     .set({
                     status: TaskStatus.Expired,
                     token: null,
-                    error: { code: 'Expired', message: 'Task expired before processing' },
+                    errors: sql `${taskTable.errors} || ${buildJsonb([{ code: 'Expired', message: 'Task expired before processing' }])}`,
                     completeTimestamp: TRANSACTION_TIMESTAMP,
                 })
                     .where(inArray(taskTable.id, tx.pgTransaction.select().from(expiredSelection)))
@@ -1166,7 +1166,7 @@ let PostgresTaskQueue = class PostgresTaskQueue extends TaskQueue {
                     visibilityDeadline: null,
                     completeTimestamp: caseWhen(or(lt(taskTable.startTimestamp, sql `${TRANSACTION_TIMESTAMP} - ${interval(this.maxExecutionTime, 'milliseconds')}`), gte(taskTable.tries, this.maxTries)), TRANSACTION_TIMESTAMP).else(null),
                     scheduleTimestamp: caseWhen(and(lt(taskTable.visibilityDeadline, TRANSACTION_TIMESTAMP), lt(taskTable.tries, this.maxTries), not(lt(taskTable.startTimestamp, sql `${TRANSACTION_TIMESTAMP} - ${interval(this.maxExecutionTime, 'milliseconds')}`))), sql `${TRANSACTION_TIMESTAMP} + ${interval(least(this.retryDelayMaximum, sql `${this.retryDelayMinimum} * ${power(this.retryDelayGrowth, sql `${taskTable.tries} - 1`)}`), 'milliseconds')}`).else(taskTable.scheduleTimestamp),
-                    error: caseWhen(lt(taskTable.startTimestamp, sql `${TRANSACTION_TIMESTAMP} - ${interval(this.maxExecutionTime, 'milliseconds')}`), jsonbBuildObject({ code: 'MaxTimeExceeded', message: sql `'Hard Execution Timeout: Task ran longer than ' || ${this.maxExecutionTime} || 'ms'`, lastError: taskTable.error })).else(caseWhen(lt(taskTable.tries, this.maxTries), jsonbBuildObject({ code: 'VisibilityTimeout', message: 'Worker Lost', lastError: taskTable.error })).else(jsonbBuildObject({ code: 'ZombieExhausted', message: 'Exceeded max retries after repeated crashes', lastError: taskTable.error }))),
+                    errors: caseWhen(lt(taskTable.startTimestamp, sql `${TRANSACTION_TIMESTAMP} - ${interval(this.maxExecutionTime, 'milliseconds')}`), sql `${taskTable.errors} || ${buildJsonb([{ code: 'MaxTimeExceeded', message: sql `'Hard Execution Timeout: Task ran longer than ' || ${this.maxExecutionTime} || 'ms'` }])}`).else(caseWhen(lt(taskTable.tries, this.maxTries), sql `${taskTable.errors} || ${buildJsonb([{ code: 'VisibilityTimeout', message: 'Worker Lost' }])}`).else(sql `${taskTable.errors} || ${buildJsonb([{ code: 'ZombieExhausted', message: 'Exceeded max retries after repeated crashes' }])}`)),
                 })
                     .where(inArray(taskTable.id, tx.pgTransaction.select().from(selection)))
                     .returning({ id: taskTable.id, status: taskTable.status });
@@ -1211,7 +1211,7 @@ let PostgresTaskQueue = class PostgresTaskQueue extends TaskQueue {
             .set({
             status: TaskStatus.Pending,
             token: null,
-            error: null,
+            errors: [],
             result: null,
             scheduleTimestamp: TRANSACTION_TIMESTAMP,
             completeTimestamp: null,
@@ -1319,7 +1319,7 @@ PostgresTaskQueue = __decorate([
     Singleton({
         argumentIdentityProvider: JSON.stringify,
         providers: [
-            provide(DatabaseConfig, { useFactory: (_, context) => context.resolve(PostgresTaskQueueModuleConfig).database ?? context.resolve(DatabaseConfig, undefined, { skipSelf: 2 }) }),
+            provide(DatabaseConfig, { useFactory: (_, context) => context.resolve(PostgresTaskQueueModuleConfig).database ?? context.resolve(DatabaseConfig, undefined, { skipSelf: true }) }),
         ],
     })
 ], PostgresTaskQueue);

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

@@ -1,4 +1,5 @@
 /** biome-ignore-all lint/nursery/noExcessiveClassesPerFile: <explanation> */
+import type { NonRecursiveSerializedError } from '../../errors/index.js';
 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';
@@ -27,7 +28,7 @@ export declare abstract class PostgresTaskBase<Data extends ObjectLiteral = Obje
     data: Json<Data> | null;
     state: Json<State> | null;
     result: Json<Result> | null;
-    error: Json<ObjectLiteral> | null;
+    errors: Json<NonRecursiveSerializedError[]>;
 }
 export declare class PostgresTask<Data extends ObjectLiteral = ObjectLiteral, State extends ObjectLiteral = ObjectLiteral, Result extends ObjectLiteral = ObjectLiteral> extends PostgresTaskBase<Data, State, Result> implements Task {
     static readonly entityName = "Task";

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

@@ -37,7 +37,7 @@ export class PostgresTaskBase extends BaseEntity {
     data;
     state;
     result;
-    error;
+    errors;
 }
 __decorate([
     StringProperty(),
@@ -136,9 +136,9 @@ __decorate([
     __metadata("design:type", Object)
 ], PostgresTaskBase.prototype, "result", void 0);
 __decorate([
-    JsonProperty({ nullable: true }),
+    JsonProperty(),
     __metadata("design:type", Object)
-], PostgresTaskBase.prototype, "error", void 0);
+], PostgresTaskBase.prototype, "errors", void 0);
 let PostgresTask = class PostgresTask extends PostgresTaskBase {
     static entityName = 'Task';
 };

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

@@ -1,12 +1,13 @@
 /** biome-ignore-all lint/nursery/noExcessiveClassesPerFile: <explanation> */
 import type { CancellationSignal } from '../cancellation/index.js';
 import { type EnumType } from '../enumeration/enumeration.js';
+import type { NonRecursiveSerializedError } from '../errors/index.js';
 import { Injector } from '../injector/index.js';
 import type { Resolvable, resolveArgumentType } from '../injector/interfaces.js';
 import { Logger } from '../logger/logger.js';
 import type { Transaction } from '../orm/server/transaction.js';
 import { Transactional } from '../orm/server/transactional.js';
-import type { OneOrMany, Record, UndefinableJson } from '../types/types.js';
+import type { OneOrMany, Record } from '../types/types.js';
 import { TaskQueueEnqueueBatch } from './enqueue-batch.js';
 import type { ProcessWorker, TaskData, TaskDefinitionMap, TaskOfType, TaskProcessResultPayload, TaskResult, TasksResults, TasksStates, TaskState, TaskTypes } from './types.js';
 /**
@@ -204,8 +205,8 @@ export type Task<Definitions extends TaskDefinitionMap = Record<string, {
         state: TaskState<Definitions, Type> | null;
         /** The result of the task, if successful. */
         result: TaskResult<Definitions, Type> | null;
-        /** The error that occurred, if the task failed. */
-        error: UndefinableJson | null;
+        /** The errors that occurred, if the task failed. */
+        errors: NonRecursiveSerializedError[];
     };
 }[Extract<keyof Definitions, string>];
 /** Default priority for tasks. */

package/task-queue/task-queue.js

@@ -283,9 +283,19 @@ export class TaskQueue extends Transactional {
                     }
                 }
                 catch (error) {
+                    const isUnsupportedAction = isError(error) && (error.message == 'Unsupported task result action.');
+                    const isCancelledBeforeStart = isError(error) && (error.message == 'Task cancelled before start');
+                    if (isCancelledBeforeStart) {
+                        return;
+                    }
                     context.logger.error('Error processing task', error);
-                    await this.fail(task, error);
-                    if (isError(error) && ((error.message === 'Task cancelled before start') || (error.message == 'Unsupported task result action.'))) {
+                    try {
+                        await this.fail(task, error, { fatal: isUnsupportedAction });
+                    }
+                    catch (failError) {
+                        context.logger.error('Error failing task after processing error', failError);
+                    }
+                    if (isUnsupportedAction) {
                         throw error;
                     }
                 }

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

@@ -212,7 +212,7 @@ describe('Task Queue Branch Coverage Enhancement', () => {
         await ttlQueue.maintenance();
         const updated = await ttlQueue.getTask(task.id);
         expect(updated?.status).toBe(TaskStatus.Expired);
-        expect(updated?.error?.message).toContain('Task expired');
+        expect(updated?.errors[0]?.message).toContain('Task expired');
     });
     it('should handle cancelMany with multiple valid IDs', async () => {
         const t1 = await queue.enqueue('c1', {});

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

@@ -73,7 +73,7 @@ describe('Queue Dependencies & Tree Tests', () => {
             await queue.waitForTasks([dependent.id]);
             const updatedDependent = await queue.getTask(dependent.id);
             expect(updatedDependent?.status).toBe(TaskStatus.Skipped);
-            expect(updatedDependent?.error?.code).toBe('DependencyFailed');
+            expect(updatedDependent?.errors[0]?.code).toBe('DependencyFailed');
         });
         it('should NOT overwrite terminal states during cancellation (abortOnDependencyFailure + complete)', async () => {
             const dep = await queue.enqueue('dep', {});
@@ -261,7 +261,7 @@ describe('Queue Dependencies & Tree Tests', () => {
             const updated = await queue.getTask(task.id);
             expect(updated?.status).toBe(TaskStatus.Pending);
             expect(updated?.tries).toBe(0);
-            expect(updated?.error).toBeNull();
+            expect(updated?.errors).toEqual([]);
         });
         it('should consume tasks via async iterator (getConsumer)', async () => {
             await queue.enqueue('c1', { val: 1 });

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

@@ -184,7 +184,7 @@ describe('PostgresQueue (Distributed Task Orchestration)', () => {
             const updated = await queue.getTask(task.id);
             expect(updated?.status).toBe(TaskStatus.Retrying);
             expect(updated?.tries).toBe(1);
-            expect(updated?.error).toBeDefined();
+            expect(updated?.errors).toHaveLength(1);
         });
         it('should NOT clear startTimestamp when transitioning to terminal or retry states', async () => {
             // Re-create queue with high circuit breaker threshold for this test
@@ -423,7 +423,7 @@ describe('PostgresQueue (Distributed Task Orchestration)', () => {
             await shortQueue.maintenance();
             const updated = await shortQueue.getTask(task.id);
             expect(updated?.status).toBe(TaskStatus.TimedOut);
-            expect(updated?.error?.code).toBe('MaxTimeExceeded');
+            expect(updated?.errors[0]?.code).toBe('MaxTimeExceeded');
             await shortQueue.clear();
         });
         it('should touch a task to extend token', async () => {

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

@@ -1,4 +1,4 @@
-import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it } from 'vitest';
+import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it, vi } from 'vitest';
 import { CancellationToken } from '../../cancellation/index.js';
 import { getRepository } from '../../orm/server/index.js';
 import { TaskProcessResult, TaskQueueProvider, TaskStatus } from '../../task-queue/index.js';
@@ -33,6 +33,7 @@ describe('Worker & Base Class Tests', () => {
         await queue.clear();
         const queueProvider = injector.resolve(TaskQueueProvider);
         await queueProvider.get(otherQueueName).clear();
+        vi.restoreAllMocks();
     });
     afterAll(async () => {
         await injector?.dispose();
@@ -80,7 +81,7 @@ describe('Worker & Base Class Tests', () => {
         const updated = await queue.getTask(task.id);
         expect(updated?.status).toBe(TaskStatus.Retrying); // Should retry
         expect(updated?.tries).toBe(1);
-        expect(updated?.error?.message).toBe('worker error');
+        expect(updated?.errors[0]?.message).toBe('worker error');
     });
     it('should extend lease (heartbeat) during long processing', async () => {
         const task = await queue.enqueue('long', {});
@@ -125,7 +126,7 @@ describe('Worker & Base Class Tests', () => {
         token.set();
         const uFail = await queue.getTask(tFail.id);
         expect(uFail?.status).toBe(TaskStatus.Retrying); // Retry
-        expect(uFail?.error?.message).toBe('explicit fail');
+        expect(uFail?.errors[0]?.message).toBe('explicit fail');
         const uResched = await queue.getTask(tResched.id);
         expect(uResched?.status).toBe(TaskStatus.Pending);
         expect(uResched?.scheduleTimestamp).toBeGreaterThan(Date.now());
@@ -218,7 +219,40 @@ describe('Worker & Base Class Tests', () => {
         const workerPromise = queue.processWorker(token, () => ({ payload: { action: 'magic' } }));
         await expect(workerPromise).rejects.toThrow('Unsupported task result action');
         const updated = await queue.getTask(task.id);
-        expect(updated?.status).toBe(TaskStatus.Retrying);
-        expect(updated?.error?.message).toContain('Unsupported task result action');
+        expect(updated?.status).toBe(TaskStatus.Dead); // Fatal now
+        expect(updated?.errors[0]?.message).toContain('Unsupported task result action');
+    });
+    it('should not crash worker lane if fail() throws', async () => {
+        const t1 = await queue.enqueue('task1', {});
+        const t2 = await queue.enqueue('task2', {});
+        let t1Processed = false;
+        let t2Processed = false;
+        // Mock fail to throw once
+        const failSpy = vi.spyOn(queue, 'fail').mockRejectedValueOnce(new Error('DB DOWN'));
+        queue.process({ cancellationSignal: token }, async (context) => {
+            if (context.id === t1.id) {
+                t1Processed = true;
+                throw new Error('Task 1 failed');
+            }
+            if (context.id === t2.id) {
+                t2Processed = true;
+                return TaskProcessResult.Complete();
+            }
+            return TaskProcessResult.Complete();
+        });
+        // Wait until both tasks are processed
+        // If the bug exists, the worker lane will crash after t1 and t2 will never be processed
+        for (let i = 0; i < 40; i++) {
+            if (t1Processed && t2Processed)
+                break;
+            queue.notify();
+            await timeout(50);
+        }
+        token.set();
+        expect(t1Processed).toBe(true);
+        expect(t2Processed).toBe(true);
+        expect(failSpy).toHaveBeenCalled();
+        const check2 = await queue.getTask(t2.id);
+        expect(check2?.status).toBe(TaskStatus.Completed);
     });
 });

package/tsconfig.json

@@ -5,7 +5,6 @@
     "moduleResolution": "nodenext",
     "lib": ["esnext", "dom"],
     "target": "es2024",
-    "baseUrl": "source/",
     "rootDir": "source/",
     "outDir": "dist/",
     "declaration": true,
@@ -15,7 +14,6 @@
     "removeComments": false,
     "resolveJsonModule": true,
     "sourceMap": false,
-    "downlevelIteration": true,
     "emitDecoratorMetadata": true,
     "experimentalDecorators": true,