@tstdl/base 0.93.141 → 0.93.143

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

@@ -1,15 +1,22 @@
 /** biome-ignore-all lint/nursery/noExcessiveClassesPerFile: <explanation> */
 import { BaseEntity, type Json, type Timestamp } from '../../orm/index.js';
-import type { ObjectLiteral, TypedOmit } from '../../types/types.js';
+import type { ObjectLiteral } from '../../types/types.js';
 import { type Task, TaskDependencyType, TaskStatus } from '../task-queue.js';
-export declare abstract class PostgresTaskBase<Data extends ObjectLiteral = ObjectLiteral, State extends ObjectLiteral = ObjectLiteral, Result extends ObjectLiteral = ObjectLiteral> extends BaseEntity implements TypedOmit<Task, 'parentId'> {
+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;
     status: TaskStatus;
     idempotencyKey: string | null;
     traceId: string | null;
+    parentId: string | null;
     tags: string[];
-    failFast: boolean;
+    abortOnDependencyFailure: boolean;
     priority: number;
     unresolvedScheduleDependencies: number;
     unresolvedCompleteDependencies: number;
@@ -30,15 +37,12 @@ export declare abstract class PostgresTaskBase<Data extends ObjectLiteral = Obje
 }
 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";
-    parentId: string | null;
 }
 export declare class PostgresTaskArchive<Data extends ObjectLiteral = ObjectLiteral, State extends ObjectLiteral = ObjectLiteral, Result extends ObjectLiteral = ObjectLiteral> extends PostgresTaskBase<Data, State, Result> implements PostgresTask<Data, State, Result> {
     static readonly entityName = "TaskArchive";
-    parentId: string | null;
 }
 export declare class PostgresTaskDependency extends BaseEntity {
     static readonly entityName = "TaskDependency";
-    namespace: string;
     taskId: string;
     dependencyTaskId: string;
     type: TaskDependencyType;

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

@@ -10,15 +10,23 @@ 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];
 export class PostgresTaskBase extends BaseEntity {
     namespace;
     type;
     status;
     idempotencyKey;
     traceId;
+    parentId;
     tags;
-    failFast;
+    abortOnDependencyFailure;
     priority;
     unresolvedScheduleDependencies;
     unresolvedCompleteDependencies;
@@ -57,6 +65,10 @@ __decorate([
     StringProperty({ nullable: true }),
     __metadata("design:type", Object)
 ], PostgresTaskBase.prototype, "traceId", void 0);
+__decorate([
+    UuidProperty({ nullable: true }),
+    __metadata("design:type", Object)
+], PostgresTaskBase.prototype, "parentId", void 0);
 __decorate([
     ArrayProperty(String),
     __metadata("design:type", Array)
@@ -64,7 +76,7 @@ __decorate([
 __decorate([
     BooleanProperty(),
     __metadata("design:type", Boolean)
-], PostgresTaskBase.prototype, "failFast", void 0);
+], PostgresTaskBase.prototype, "abortOnDependencyFailure", void 0);
 __decorate([
     Integer(),
     __metadata("design:type", Number)
@@ -135,32 +147,25 @@ __decorate([
 ], PostgresTaskBase.prototype, "error", void 0);
 let PostgresTask = class PostgresTask extends PostgresTaskBase {
     static entityName = 'Task';
-    parentId;
 };
-__decorate([
-    UuidProperty({ nullable: true }),
-    __metadata("design:type", Object)
-], PostgresTask.prototype, "parentId", void 0);
 PostgresTask = __decorate([
     Table('task', { schema: 'task_queue' }),
     Unique(['namespace', 'idempotencyKey']),
-    Unique(['namespace', 'id']),
-    Index(['namespace', 'status', 'scheduleTimestamp', 'priority']),
-    Index(['tags'], { using: 'gin' }),
-    Index(['status', 'completeTimestamp']),
-    Index(['status', 'visibilityDeadline']),
-    Index(['parentId']),
-    ForeignKey(() => PostgresTask, ['namespace', 'parentId'], ['namespace', 'id'])
+    Index(['namespace', 'tags'], { using: 'gin' }),
+    Index(['namespace', 'priority', 'scheduleTimestamp'], { where: () => ({ status: { $in: queueableStatuses } }) }),
+    Index(['namespace', 'type', 'priority', 'scheduleTimestamp'], { where: () => ({ status: { $in: queueableStatuses } }) }),
+    Index(['namespace', 'priorityAgeTimestamp'], { where: () => ({ status: { $in: queueableStatuses } }) }),
+    Index(['namespace', 'timeToLive'], { where: () => ({ status: { $in: queueableOrWaitableStatuses } }) }),
+    Index(['namespace', 'visibilityDeadline'], { where: () => ({ status: TaskStatus.Running }) }),
+    Index(['namespace', 'startTimestamp'], { where: () => ({ status: TaskStatus.Running }) }),
+    Index(['namespace', 'completeTimestamp'], { where: () => ({ status: { $in: terminalStatuses } }) }),
+    Index(['parentId'], { where: (table) => isNotNull(table.parentId) }),
+    ForeignKey(() => PostgresTask, ['parentId'], ['id'])
 ], PostgresTask);
 export { PostgresTask };
 let PostgresTaskArchive = class PostgresTaskArchive extends PostgresTaskBase {
     static entityName = 'TaskArchive';
-    parentId;
 };
-__decorate([
-    UuidProperty({ nullable: true }),
-    __metadata("design:type", Object)
-], PostgresTaskArchive.prototype, "parentId", void 0);
 PostgresTaskArchive = __decorate([
     Table('task_archive', { schema: 'task_queue' }),
     Index(['namespace', 'completeTimestamp'])
@@ -168,16 +173,11 @@ PostgresTaskArchive = __decorate([
 export { PostgresTaskArchive };
 let PostgresTaskDependency = class PostgresTaskDependency extends BaseEntity {
     static entityName = 'TaskDependency';
-    namespace;
     taskId;
     dependencyTaskId;
     type;
     requiredStatuses;
 };
-__decorate([
-    StringProperty(),
-    __metadata("design:type", String)
-], PostgresTaskDependency.prototype, "namespace", void 0);
 __decorate([
     UuidProperty(),
     __metadata("design:type", String)
@@ -196,9 +196,9 @@ __decorate([
 ], PostgresTaskDependency.prototype, "requiredStatuses", void 0);
 PostgresTaskDependency = __decorate([
     Table('task_dependency', { schema: 'task_queue' }),
-    Unique(['namespace', 'taskId', 'dependencyTaskId', 'type']),
-    Index(['namespace', 'dependencyTaskId', 'type']),
-    ForeignKey(() => PostgresTask, ['namespace', 'taskId'], ['namespace', 'id'], { onDelete: 'cascade' }),
-    ForeignKey(() => PostgresTask, ['namespace', 'dependencyTaskId'], ['namespace', 'id'], { onDelete: 'cascade' })
+    Unique(['taskId', 'dependencyTaskId', 'type']),
+    Index(['dependencyTaskId', 'type']),
+    ForeignKey(() => PostgresTask, ['taskId'], ['id'], { onDelete: 'cascade' }),
+    ForeignKey(() => PostgresTask, ['dependencyTaskId'], ['id'], { onDelete: 'cascade' })
 ], PostgresTaskDependency);
 export { PostgresTaskDependency };

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

@@ -3,7 +3,7 @@ import type { Logger } from '../logger/index.js';
 import type { Transaction } from '../orm/server/index.js';
 import { TaskQueue, type EnqueueManyItem, type EnqueueOptions } from './task-queue.js';
 import type { TaskData, TaskDefinitionMap, TaskOfType, TaskResult, TaskState, TaskTypes } from './types.js';
-export declare class TaskContext<Definitions extends TaskDefinitionMap, Type extends TaskTypes<Definitions> = TaskTypes<Definitions>> {
+declare class TaskContextImplementation<Definitions extends TaskDefinitionMap, Type extends TaskTypes<Definitions> = TaskTypes<Definitions>> {
     #private;
     constructor(queue: TaskQueue<Definitions>, task: TaskOfType<Definitions, Type>, signal: CancellationToken, logger: Logger);
     get id(): string;
@@ -27,10 +27,10 @@ export declare class TaskContext<Definitions extends TaskDefinitionMap, Type ext
         state?: TaskState<Definitions, Type>;
         transaction?: Transaction;
     }): Promise<void>;
-    spawn<Type extends TaskTypes<Definitions>>(type: Type, data: TaskData<Definitions, Type>, options?: Omit<EnqueueOptions, 'parentId'>): Promise<TaskOfType<Definitions, Type>>;
-    spawn<OtherDefinitions extends TaskDefinitionMap, T extends TaskTypes<OtherDefinitions>>(queue: TaskQueue<OtherDefinitions>, type: T, data: OtherDefinitions[T]['data'], options?: Omit<EnqueueOptions, 'parentId'>): Promise<TaskOfType<OtherDefinitions, T>>;
-    spawnMany<Type extends TaskTypes<Definitions>>(items: EnqueueManyItem<Definitions, Type>[]): Promise<TaskOfType<Definitions, Type>[]>;
-    spawnMany<OtherDefinitions extends TaskDefinitionMap, Type extends TaskTypes<OtherDefinitions>>(queue: TaskQueue<OtherDefinitions>, items: EnqueueManyItem<OtherDefinitions, Type>[]): Promise<TaskOfType<OtherDefinitions, Type>[]>;
+    spawn<SpawnType extends TaskTypes<Definitions>>(type: SpawnType, data: TaskData<Definitions, SpawnType>, options?: Omit<EnqueueOptions, 'parentId'>): Promise<TaskOfType<Definitions, SpawnType>>;
+    spawn<OtherDefinitions extends TaskDefinitionMap, SpawnType extends TaskTypes<OtherDefinitions>>(queue: TaskQueue<OtherDefinitions>, type: SpawnType, data: OtherDefinitions[SpawnType]['data'], options?: Omit<EnqueueOptions, 'parentId'>): Promise<TaskOfType<OtherDefinitions, SpawnType>>;
+    spawnMany<SpawnType extends TaskTypes<Definitions>>(items: EnqueueManyItem<Definitions, SpawnType>[]): Promise<TaskOfType<Definitions, SpawnType>[]>;
+    spawnMany<OtherDefinitions extends TaskDefinitionMap, SpawnType extends TaskTypes<OtherDefinitions>>(queue: TaskQueue<OtherDefinitions>, items: EnqueueManyItem<OtherDefinitions, SpawnType>[]): Promise<TaskOfType<OtherDefinitions, SpawnType>[]>;
     /** Stop execution and reschedule the task for later without incrementing tries if possible */
     reschedule(timestamp: number, options?: {
         transaction?: Transaction;
@@ -44,3 +44,8 @@ export declare class TaskContext<Definitions extends TaskDefinitionMap, Type ext
         transaction?: Transaction;
     }): Promise<void>;
 }
+export type TaskContext<Definitions extends TaskDefinitionMap, Type extends TaskTypes<Definitions> = TaskTypes<Definitions>> = Type extends any ? TaskContextImplementation<Definitions, Type> : never;
+export declare const TaskContext: {
+    new <Definitions extends TaskDefinitionMap, Type extends TaskTypes<Definitions>>(queue: TaskQueue<Definitions>, task: TaskOfType<Definitions, Type>, signal: CancellationToken, logger: Logger): TaskContext<Definitions, Type>;
+};
+export {};

package/task-queue/task-context.js

@@ -1,7 +1,7 @@
 import { currentTimestamp } from '../utils/date-time.js';
 import { isInstanceOf, isNumber, isUndefined } from '../utils/type-guards.js';
 import { TaskQueue } from './task-queue.js';
-export class TaskContext {
+class TaskContextImplementation {
     #queue;
     #logger;
     #signal;
@@ -70,14 +70,15 @@ export class TaskContext {
         const data = isForOtherQueue ? dataOrOptionsOrNothing : typeOrData;
         const options = (isForOtherQueue ? optionsOrNothing : dataOrOptionsOrNothing);
         if (isForOtherQueue) {
-            return await queueOrType.enqueue(type, data, options);
+            return await queueOrType.enqueue(type, data, { ...options, parentId: this.#task.id });
         }
         return await this.#queue.enqueue(type, data, { ...options, parentId: this.#task.id });
     }
     async spawnMany(queueOrItems, itemsOrNothing) {
         const isForOtherQueue = isInstanceOf(queueOrItems, TaskQueue);
         if (isForOtherQueue) {
-            return await queueOrItems.enqueueMany(itemsOrNothing, { returnTasks: true });
+            const items = itemsOrNothing.map((item) => ({ ...item, parentId: this.#task.id }));
+            return await queueOrItems.enqueueMany(items, { returnTasks: true });
         }
         const items = queueOrItems.map((item) => ({ ...item, parentId: this.#task.id }));
         return await this.#queue.enqueueMany(items, { returnTasks: true });
@@ -95,3 +96,4 @@ export class TaskContext {
         this.#signal.set();
     }
 }
+export const TaskContext = TaskContextImplementation;