@tstdl/base 0.93.92 → 0.93.94

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

@@ -1,7 +1,6 @@
-import { TaskQueueProvider, type QueueConfig } from '../../task-queue/index.js';
-import type { ObjectLiteral } from '../../types/index.js';
-import { PostgresQueue } from './task-queue.js';
+import { TaskQueueProvider, type QueueConfig, type TaskDefinitionMap } from '../../task-queue/index.js';
+import { PostgresTaskQueue } from './task-queue.js';
 export declare class PostgresTaskQueueProvider extends TaskQueueProvider {
     #private;
-    get<Data extends ObjectLiteral, State extends ObjectLiteral, Result extends ObjectLiteral>(namespace: string, config?: QueueConfig): PostgresQueue<Data, State, Result>;
+    get<Definitions extends TaskDefinitionMap = TaskDefinitionMap>(namespace: string, config?: QueueConfig): PostgresTaskQueue<Definitions>;
 }

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

@@ -8,11 +8,11 @@ import { Singleton } from '../../injector/decorators.js';
 import { inject } from '../../injector/inject.js';
 import { Injector } from '../../injector/injector.js';
 import { TaskQueueProvider } from '../../task-queue/index.js';
-import { PostgresQueue } from './task-queue.js';
+import { PostgresTaskQueue } from './task-queue.js';
 let PostgresTaskQueueProvider = class PostgresTaskQueueProvider extends TaskQueueProvider {
     #injector = inject(Injector);
     get(namespace, config) {
-        return this.#injector.resolve((PostgresQueue), { ...config, namespace });
+        return this.#injector.resolve((PostgresTaskQueue), { ...config, namespace });
     }
 };
 PostgresTaskQueueProvider = __decorate([

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

@@ -1,10 +1,10 @@
 import { BaseEntity, type Json, type Timestamp } from '../../orm/index.js';
 import type { ObjectLiteral, TypedOmit } from '../../types/types.js';
-import { DependencyJoinMode, type Task, TaskState } 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<Data, State, Result>, 'parentId'> {
+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'> {
     namespace: string;
     type: string;
-    status: TaskState;
+    status: TaskStatus;
     idempotencyKey: string | null;
     traceId: string | null;
     tags: string[];
@@ -12,7 +12,7 @@ export declare abstract class PostgresTaskBase<Data extends ObjectLiteral = Obje
     scheduleAfterTags: string[];
     failFast: boolean;
     dependencyJoinMode: DependencyJoinMode;
-    dependencyTriggerStates: TaskState[];
+    dependencyTriggerStatuses: TaskStatus[];
     priority: number;
     token: string | null;
     creationTimestamp: Timestamp;
@@ -29,7 +29,7 @@ export declare abstract class PostgresTaskBase<Data extends ObjectLiteral = Obje
     result: Json<Result> | null;
     error: Json<ObjectLiteral> | null;
 }
-export declare class PostgresTask<Data extends ObjectLiteral = ObjectLiteral, State extends ObjectLiteral = ObjectLiteral, Result extends ObjectLiteral = ObjectLiteral> extends PostgresTaskBase<Data, State, Result> implements Task<Data, State, Result> {
+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;
 }

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

@@ -9,7 +9,7 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 };
 import { BaseEntity, Index, JsonProperty, Reference, Table, TimestampProperty, Unique, UuidProperty } from '../../orm/index.js';
 import { Array as ArrayProperty, BooleanProperty, Enumeration, Integer, NumberProperty, StringProperty } from '../../schema/index.js';
-import { DependencyJoinMode, TaskState } from '../task-queue.js';
+import { DependencyJoinMode, TaskStatus } from '../task-queue.js';
 export class PostgresTaskBase extends BaseEntity {
     namespace;
     type;
@@ -21,7 +21,7 @@ export class PostgresTaskBase extends BaseEntity {
     scheduleAfterTags;
     failFast;
     dependencyJoinMode;
-    dependencyTriggerStates;
+    dependencyTriggerStatuses;
     priority;
     token;
     creationTimestamp;
@@ -47,7 +47,7 @@ __decorate([
     __metadata("design:type", String)
 ], PostgresTaskBase.prototype, "type", void 0);
 __decorate([
-    Enumeration(TaskState),
+    Enumeration(TaskStatus),
     __metadata("design:type", String)
 ], PostgresTaskBase.prototype, "status", void 0);
 __decorate([
@@ -79,9 +79,9 @@ __decorate([
     __metadata("design:type", String)
 ], PostgresTaskBase.prototype, "dependencyJoinMode", void 0);
 __decorate([
-    Enumeration(TaskState, { array: true }),
+    Enumeration(TaskStatus, { array: true }),
     __metadata("design:type", Array)
-], PostgresTaskBase.prototype, "dependencyTriggerStates", void 0);
+], PostgresTaskBase.prototype, "dependencyTriggerStatuses", void 0);
 __decorate([
     Integer(),
     __metadata("design:type", Number)

package/task-queue/provider.d.ts

@@ -1,5 +1,5 @@
-import type { ObjectLiteral } from '../types/index.js';
 import type { TaskQueue, QueueConfig } from './task-queue.js';
+import type { TaskDefinitionMap } from './types.js';
 export declare abstract class TaskQueueProvider {
-    abstract get<Data extends ObjectLiteral, State extends ObjectLiteral, Result extends ObjectLiteral>(key: string, config?: QueueConfig): TaskQueue<Data, State, Result>;
+    abstract get<Definitions extends TaskDefinitionMap = TaskDefinitionMap>(key: string, config?: QueueConfig): TaskQueue<Definitions>;
 }

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

@@ -1,38 +1,58 @@
 import type { CancellationSignal, CancellationToken } from '../cancellation/index.js';
 import type { Logger } from '../logger/index.js';
 import type { Transaction } from '../orm/server/index.js';
-import { type EnqueueManyItem, type EnqueueOptions, TaskQueue, type Task } from './task-queue.js';
-export declare class TaskContext<Data, State = unknown, Result = unknown> {
+import { TaskQueue, type EnqueueManyItem, type EnqueueOptions } from './task-queue.js';
+import type { TaskData, TaskDefinitionMap, TaskOfType, TaskResult, TaskState, TaskTypes, TasksStates } from './types.js';
+export declare class TaskContext<Definitions extends TaskDefinitionMap, Type extends TaskTypes<Definitions>> {
     #private;
-    constructor(queue: TaskQueue<Data, State, Result>, task: Task<Data, State, Result>, signal: CancellationToken, logger: Logger);
+    constructor(queue: TaskQueue<Definitions>, task: TaskOfType<Definitions, Type>, signal: CancellationToken, logger: Logger);
     get id(): string;
-    get data(): Data;
+    get type(): Type;
+    get parentId(): string | null;
+    get tags(): string[];
+    get completeAfterTags(): string[];
+    get scheduleAfterTags(): string[];
+    get data(): TaskData<Definitions, Type>;
+    get state(): TaskState<Definitions, Type> | null;
     get attempt(): number;
     get triesLeft(): number;
     get signal(): CancellationSignal;
     get logger(): Logger;
-    complete(result?: Result, transaction?: Transaction): Promise<void>;
+    complete(result?: TaskResult<Definitions, Type>, options?: {
+        transaction?: Transaction;
+    }): Promise<void>;
     checkpoint(options: {
         progress?: number;
-        state?: State;
+        state?: TaskState<Definitions, Type>;
+        transaction?: Transaction;
     }): Promise<void>;
-    spawn(type: string, data: Data, options?: Omit<EnqueueOptions, 'parentId'>): Promise<Task<Data, State, Result>>;
-    spawn<D, S, R>(queue: TaskQueue<D, S, R>, type: string, data: D, options?: Omit<EnqueueOptions, 'parentId'>): Promise<Task<D, S, R>>;
-    spawnMany(items: EnqueueManyItem<Data>[]): Promise<Task<Data, State, Result>[]>;
-    spawnMany<D = Data, S = any, R = any>(queue: TaskQueue<D, S, R>, items: EnqueueManyItem<D>[]): Promise<Task<D, S, R>[]>;
+    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>[]>;
     /** Stop execution and reschedule the task for later without incrementing tries if possible */
-    reschedule(timestamp: number): Promise<void>;
-    reschedule(options: {
+    reschedule(timestamp: number, options?: {
+        transaction?: Transaction;
+    }): Promise<void>;
+    reschedule(rescheduleOptions: {
         delay: number;
+        transaction?: Transaction;
+    }): Promise<void>;
+    fail(error: unknown, options?: {
+        fatal?: boolean;
+        transaction?: Transaction;
     }): Promise<void>;
-    fail(error: any, fatal?: boolean, transaction?: Transaction): Promise<void>;
 }
-export declare class BatchTaskContext<Data, State, Result> {
+export declare class BatchTaskContext<Definitions extends TaskDefinitionMap, Type extends TaskTypes<Definitions>> {
     #private;
-    constructor(queue: TaskQueue<Data, State, Result>, tasks: Task<Data, State, Result>[], signal: CancellationToken, logger: Logger);
-    get tasks(): Task<Data, State, Result>[];
+    constructor(queue: TaskQueue<Definitions>, tasks: TaskOfType<Definitions, Type>[], signal: CancellationToken, logger: Logger);
+    get tasks(): TaskOfType<Definitions, Type>[];
     get signal(): CancellationSignal;
     get logger(): Logger;
-    for(task: Task<Data, State, Result>): TaskContext<Data, State, Result>;
-    checkpointAll(progresses?: number[], states?: State[]): Promise<void>;
+    for<Type extends TaskTypes<Definitions>>(task: TaskOfType<Definitions, Type>): TaskContext<Definitions, Type>;
+    checkpointAll(options?: {
+        progresses?: number[];
+        states?: TasksStates<TaskOfType<Definitions, Type>[]>;
+        transaction?: Transaction;
+    }): Promise<void>;
 }

package/task-queue/task-context.js

@@ -15,9 +15,27 @@ export class TaskContext {
     get id() {
         return this.#task.id;
     }
+    get type() {
+        return this.#task.type;
+    }
+    get parentId() {
+        return this.#task.parentId;
+    }
+    get tags() {
+        return this.#task.tags;
+    }
+    get completeAfterTags() {
+        return this.#task.completeAfterTags;
+    }
+    get scheduleAfterTags() {
+        return this.#task.scheduleAfterTags;
+    }
     get data() {
         return this.#task.data;
     }
+    get state() {
+        return this.#task.state;
+    }
     get attempt() {
         return this.#task.tries;
     }
@@ -30,8 +48,8 @@ export class TaskContext {
     get logger() {
         return this.#logger;
     }
-    async complete(result, transaction) {
-        await this.#queue.complete(this.#task, result, transaction);
+    async complete(result, options) {
+        await this.#queue.complete(this.#task, { result, ...options });
     }
     async checkpoint(options) {
         const updatedTask = await this.#queue.touch(this.#task, options);
@@ -44,10 +62,14 @@ export class TaskContext {
         }
     }
     async spawn(queueOrType, typeOrData, dataOrOptionsOrNothing, optionsOrNothing) {
-        if (isInstanceOf(queueOrType, TaskQueue)) {
-            return await queueOrType.enqueue(typeOrData, dataOrOptionsOrNothing, { ...optionsOrNothing, parentId: this.#task.id });
+        const isForOtherQueue = isInstanceOf(queueOrType, TaskQueue);
+        const type = (isForOtherQueue ? typeOrData : queueOrType);
+        const data = isForOtherQueue ? dataOrOptionsOrNothing : typeOrData;
+        const options = (isForOtherQueue ? optionsOrNothing : dataOrOptionsOrNothing);
+        if (isForOtherQueue) {
+            return await queueOrType.enqueue(type, data, { ...options, parentId: this.#task.id });
         }
-        return await this.#queue.enqueue(queueOrType, typeOrData, { ...dataOrOptionsOrNothing, 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);
@@ -58,15 +80,15 @@ export class TaskContext {
         return await this.#queue.enqueueMany(items, { returnTasks: true });
     }
     async reschedule(timestampOrDelay) {
-        const timestamp = isNumber(timestampOrDelay)
-            ? timestampOrDelay
-            : currentTimestamp() + timestampOrDelay.delay;
+        const isTimestamp = isNumber(timestampOrDelay);
+        const timestamp = isTimestamp ? timestampOrDelay : (currentTimestamp() + timestampOrDelay.delay);
+        const transaction = isTimestamp ? undefined : timestampOrDelay.transaction;
         this.#logger.debug(`Rescheduling task for ${new Date(timestamp).toISOString()}.`);
-        await this.#queue.reschedule(this.#task.id, timestamp);
+        await this.#queue.reschedule(this.#task.id, timestamp, { transaction });
         this.#signal.set();
     }
-    async fail(error, fatal, transaction) {
-        await this.#queue.fail(this.#task, error, fatal, transaction);
+    async fail(error, options) {
+        await this.#queue.fail(this.#task, error, options);
         this.#signal.set();
     }
 }
@@ -93,8 +115,8 @@ export class BatchTaskContext {
     for(task) {
         return new TaskContext(this.#queue, task, this.#signal, this.#logger);
     }
-    async checkpointAll(progresses, states) {
-        const validIds = await this.#queue.touchMany(this.#tasks, progresses, states);
+    async checkpointAll(options) {
+        const validIds = await this.#queue.touchMany(this.#tasks, options);
         if (validIds.length < this.#tasks.length) {
             this.#logger.warn(`${this.#tasks.length - validIds.length} tasks in batch lost their lease during checkpoint`);
         }