@tstdl/base 0.93.140 → 0.93.142

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

@@ -1,19 +1,25 @@
+/** 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 { DependencyJoinMode, type Task, 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'> {
+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;
     status: TaskStatus;
     idempotencyKey: string | null;
     traceId: string | null;
+    parentId: string | null;
     tags: string[];
-    completeAfterTags: string[];
-    scheduleAfterTags: string[];
     failFast: boolean;
-    dependencyJoinMode: DependencyJoinMode;
-    dependencyTriggerStatuses: TaskStatus[];
     priority: number;
+    unresolvedScheduleDependencies: number;
+    unresolvedCompleteDependencies: number;
     token: string | null;
     creationTimestamp: Timestamp;
     priorityAgeTimestamp: Timestamp;
@@ -31,9 +37,14 @@ 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";
+    taskId: string;
+    dependencyTaskId: string;
+    type: TaskDependencyType;
+    requiredStatuses: TaskStatus[];
 }

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

@@ -1,3 +1,4 @@
+/** biome-ignore-all lint/nursery/noExcessiveClassesPerFile: <explanation> */
 var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
     var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
     if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
@@ -7,22 +8,28 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
-import { BaseEntity, Index, JsonProperty, Reference, Table, TimestampProperty, Unique, UuidProperty } from '../../orm/index.js';
+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 { DependencyJoinMode, TaskStatus } from '../task-queue.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;
-    completeAfterTags;
-    scheduleAfterTags;
     failFast;
-    dependencyJoinMode;
-    dependencyTriggerStatuses;
     priority;
+    unresolvedScheduleDependencies;
+    unresolvedCompleteDependencies;
     token;
     creationTimestamp;
     priorityAgeTimestamp;
@@ -59,33 +66,29 @@ __decorate([
     __metadata("design:type", Object)
 ], PostgresTaskBase.prototype, "traceId", void 0);
 __decorate([
-    ArrayProperty(String),
-    __metadata("design:type", Array)
-], PostgresTaskBase.prototype, "tags", void 0);
-__decorate([
-    ArrayProperty(String),
-    __metadata("design:type", Array)
-], PostgresTaskBase.prototype, "completeAfterTags", void 0);
+    UuidProperty({ nullable: true }),
+    __metadata("design:type", Object)
+], PostgresTaskBase.prototype, "parentId", void 0);
 __decorate([
     ArrayProperty(String),
     __metadata("design:type", Array)
-], PostgresTaskBase.prototype, "scheduleAfterTags", void 0);
+], PostgresTaskBase.prototype, "tags", void 0);
 __decorate([
     BooleanProperty(),
     __metadata("design:type", Boolean)
 ], PostgresTaskBase.prototype, "failFast", void 0);
 __decorate([
-    Enumeration(DependencyJoinMode),
-    __metadata("design:type", String)
-], PostgresTaskBase.prototype, "dependencyJoinMode", void 0);
+    Integer(),
+    __metadata("design:type", Number)
+], PostgresTaskBase.prototype, "priority", void 0);
 __decorate([
-    Enumeration(TaskStatus, { array: true }),
-    __metadata("design:type", Array)
-], PostgresTaskBase.prototype, "dependencyTriggerStatuses", void 0);
+    Integer(),
+    __metadata("design:type", Number)
+], PostgresTaskBase.prototype, "unresolvedScheduleDependencies", void 0);
 __decorate([
     Integer(),
     __metadata("design:type", Number)
-], PostgresTaskBase.prototype, "priority", void 0);
+], PostgresTaskBase.prototype, "unresolvedCompleteDependencies", void 0);
 __decorate([
     UuidProperty({ nullable: true }),
     __metadata("design:type", Object)
@@ -144,35 +147,58 @@ __decorate([
 ], PostgresTaskBase.prototype, "error", void 0);
 let PostgresTask = class PostgresTask extends PostgresTaskBase {
     static entityName = 'Task';
-    parentId;
 };
-__decorate([
-    Reference(() => PostgresTask),
-    UuidProperty({ nullable: true }),
-    __metadata("design:type", Object)
-], PostgresTask.prototype, "parentId", void 0);
 PostgresTask = __decorate([
     Table('task', { schema: 'task_queue' }),
     Unique(['namespace', 'idempotencyKey']),
-    Index(['namespace', 'status', 'scheduleTimestamp', 'priority']),
-    Index(['tags'], { using: 'gin' }),
-    Index(['completeAfterTags'], { using: 'gin' }),
-    Index(['scheduleAfterTags'], { using: 'gin' }),
-    Index(['status', 'completeTimestamp']),
-    Index(['status', 'visibilityDeadline']),
-    Index(['parentId'])
+    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'])
 ], PostgresTaskArchive);
 export { PostgresTaskArchive };
+let PostgresTaskDependency = class PostgresTaskDependency extends BaseEntity {
+    static entityName = 'TaskDependency';
+    taskId;
+    dependencyTaskId;
+    type;
+    requiredStatuses;
+};
+__decorate([
+    UuidProperty(),
+    __metadata("design:type", String)
+], PostgresTaskDependency.prototype, "taskId", void 0);
+__decorate([
+    UuidProperty(),
+    __metadata("design:type", String)
+], PostgresTaskDependency.prototype, "dependencyTaskId", void 0);
+__decorate([
+    Enumeration(TaskDependencyType),
+    __metadata("design:type", String)
+], PostgresTaskDependency.prototype, "type", void 0);
+__decorate([
+    Enumeration(TaskStatus, { array: true }),
+    __metadata("design:type", Array)
+], PostgresTaskDependency.prototype, "requiredStatuses", void 0);
+PostgresTaskDependency = __decorate([
+    Table('task_dependency', { schema: 'task_queue' }),
+    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,15 +3,15 @@ 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;
     get type(): Type;
     get parentId(): string | null;
     get tags(): string[];
-    get completeAfterTags(): string[];
-    get scheduleAfterTags(): string[];
+    get unresolvedScheduleDependencies(): number;
+    get unresolvedCompleteDependencies(): number;
     get data(): TaskData<Definitions, Type>;
     get state(): TaskState<Definitions, Type> | null;
     get attempt(): number;
@@ -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;
@@ -24,11 +24,11 @@ export class TaskContext {
     get tags() {
         return this.#task.tags;
     }
-    get completeAfterTags() {
-        return this.#task.completeAfterTags;
+    get unresolvedScheduleDependencies() {
+        return this.#task.unresolvedScheduleDependencies;
     }
-    get scheduleAfterTags() {
-        return this.#task.scheduleAfterTags;
+    get unresolvedCompleteDependencies() {
+        return this.#task.unresolvedCompleteDependencies;
     }
     get data() {
         return this.#task.data;
@@ -76,10 +76,11 @@ export class TaskContext {
     }
     async spawnMany(queueOrItems, itemsOrNothing) {
         const isForOtherQueue = isInstanceOf(queueOrItems, TaskQueue);
-        const items = (isForOtherQueue ? itemsOrNothing : queueOrItems).map((item) => ({ ...item, parentId: this.#task.id }));
         if (isForOtherQueue) {
+            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 });
     }
     async reschedule(timestampOrDelay) {
@@ -95,3 +96,4 @@ export class TaskContext {
         this.#signal.set();
     }
 }
+export const TaskContext = TaskContextImplementation;