@tstdl/base 0.93.140 → 0.93.142

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

@@ -1,16 +1,25 @@
-import { PostgresTask, PostgresTaskArchive } from './task.model.js';
+import { PostgresTask, PostgresTaskArchive, PostgresTaskDependency } from './task.model.js';
 export declare const taskQueueSchema: import("../../orm/server/index.js").DatabaseSchema<"task_queue">;
+export declare const taskDependencyType: import("../../orm/enums.js").PgEnumFromEnumeration<{
+    readonly Schedule: "schedule";
+    readonly Complete: "complete";
+    readonly Child: "child";
+}>;
 export declare const taskStatus: import("../../orm/enums.js").PgEnumFromEnumeration<{
     readonly Pending: "pending";
     readonly Running: "running";
     readonly Completed: "completed";
     readonly Cancelled: "cancelled";
-    readonly Waiting: "waiting";
     readonly Dead: "dead";
-}>;
-export declare const dependencyJoinMode: import("../../orm/enums.js").PgEnumFromEnumeration<{
-    readonly And: "and";
-    readonly Or: "or";
+    readonly Waiting: "waiting";
+    readonly WaitingChildren: "waiting-children";
+    readonly Paused: "paused";
+    readonly Retrying: "retrying";
+    readonly TimedOut: "timed-out";
+    readonly Expired: "expired";
+    readonly Skipped: "skipped";
+    readonly Orphaned: "orphaned";
 }>;
 export declare const task: import("../../orm/server/types.js").PgTableFromType<typeof PostgresTask, "task_queue">;
 export declare const taskArchive: import("../../orm/server/types.js").PgTableFromType<typeof PostgresTaskArchive, "task_queue">;
+export declare const taskDependency: import("../../orm/server/types.js").PgTableFromType<typeof PostgresTaskDependency, "task_queue">;

package/task-queue/postgres/schemas.js

@@ -1,8 +1,9 @@
 import { databaseSchema } from '../../orm/server/index.js';
-import { DependencyJoinMode, TaskStatus } from '../task-queue.js';
-import { PostgresTask, PostgresTaskArchive } from './task.model.js';
+import { TaskDependencyType, TaskStatus } from '../task-queue.js';
+import { PostgresTask, PostgresTaskArchive, PostgresTaskDependency } from './task.model.js';
 export const taskQueueSchema = databaseSchema('task_queue');
+export const taskDependencyType = taskQueueSchema.getEnum(TaskDependencyType);
 export const taskStatus = taskQueueSchema.getEnum(TaskStatus);
-export const dependencyJoinMode = taskQueueSchema.getEnum(DependencyJoinMode);
 export const task = taskQueueSchema.getTable(PostgresTask);
 export const taskArchive = taskQueueSchema.getTable(PostgresTaskArchive);
+export const taskDependency = taskQueueSchema.getTable(PostgresTaskDependency);

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

@@ -3,7 +3,7 @@ import { afterResolve } from '../../injector/index.js';
 import type { Query } from '../../orm/index.js';
 import { type Transaction } from '../../orm/server/index.js';
 import type { OneOrMany } from '../../schema/index.js';
-import { TaskQueue, type EnqueueManyItem, type EnqueueManyOptions, type EnqueueOneOptions, type Task, type TaskQueueWaitOptions, type TaskQueueWaitResult } from '../task-queue.js';
+import { TaskQueue, TaskStatus, type EnqueueManyItem, type EnqueueManyOptions, type EnqueueOneOptions, type Task, type TaskQueueWaitOptions, type TaskQueueWaitResult } from '../task-queue.js';
 import type { TaskData, TaskDefinitionMap, TaskOfType, TaskResult, TasksResults, TasksStates, TaskState, TaskTypes } from '../types.js';
 export declare class PostgresTaskQueue<Definitions extends TaskDefinitionMap = TaskDefinitionMap> extends TaskQueue<Definitions> {
     #private;
@@ -21,7 +21,6 @@ export declare class PostgresTaskQueue<Definitions extends TaskDefinitionMap = T
     readonly rateLimit: number;
     readonly rateInterval: number;
     readonly idempotencyWindow: number;
-    readonly globalConcurrency: number | null;
     [afterResolve](): void;
     enqueue<Type extends TaskTypes<Definitions>>(type: Type, data: TaskData<Definitions, Type>, options?: EnqueueOneOptions): Promise<TaskOfType<Definitions, Type>>;
     enqueueMany<Type extends TaskTypes<Definitions>>(items: EnqueueManyItem<Definitions, Type>[], options?: EnqueueManyOptions & {
@@ -31,12 +30,17 @@ export declare class PostgresTaskQueue<Definitions extends TaskDefinitionMap = T
         returnTasks: true;
     }): Promise<TaskOfType<Definitions, Type>[]>;
     enqueueMany<Type extends TaskTypes<Definitions>>(items: EnqueueManyItem<Definitions, Type>[], options?: EnqueueManyOptions): Promise<TaskOfType<Definitions, Type>[] | undefined>;
+    private incrementCounters;
     has(id: string, options?: {
         transaction?: Transaction;
     }): Promise<boolean>;
     countByTags(tags: OneOrMany<string>, options?: {
         transaction?: Transaction;
     }): Promise<number>;
+    count(options?: {
+        status?: TaskStatus;
+        transaction?: Transaction;
+    }): Promise<number>;
     getTask<Type extends TaskTypes<Definitions> = TaskTypes<Definitions>>(id: string, options?: {
         transaction?: Transaction;
     }): Promise<TaskOfType<Definitions, Type> | undefined>;
@@ -103,35 +107,34 @@ export declare class PostgresTaskQueue<Definitions extends TaskDefinitionMap = T
         fatal?: boolean;
         transaction?: Transaction;
     }): Promise<void>;
-    triggerTagFanIn(tags: string[], options?: {
-        transaction?: Transaction;
-    }): Promise<void>;
     failMany(tasks: Task<Definitions>[], errors: unknown[], options?: {
         transaction?: Transaction;
     }): Promise<void>;
     private resolveDependencies;
+    private resolveDependenciesMany;
     maintenance(options?: {
         transaction?: Transaction;
     }): Promise<void>;
+    private performArchival;
+    private performArchivePurge;
+    private processExpirations;
+    private processZombieRetries;
+    private processZombieExhaustions;
+    private processHardTimeouts;
+    private processPriorityAging;
     restart(id: string, options?: {
         resetState?: boolean;
         transaction?: Transaction;
     }): Promise<void>;
-    notify(): void;
+    notify(namespace?: string): void;
     getConsumer<Type extends TaskTypes<Definitions>>(cancellationSignal: CancellationSignal, options?: {
         forceDequeue?: boolean;
         types?: Type[];
     }): AsyncIterableIterator<TaskOfType<Definitions, Type>>;
     private maintenanceLoop;
-    /**
-     * @internal for internal unit test use only
-     * @param options
-     * @returns
-     */
-    processPendingFanIn(options?: {
-        transaction?: Transaction;
-    }): Promise<number>;
-    private startSystemWorker;
+    private lowFrequencyMaintenanceLoop;
+    private mediumFrequencyMaintenanceLoop;
+    private highFrequencyMaintenanceLoop;
     getBatchConsumer<Type extends TaskTypes<Definitions>>(size: number, cancellationSignal: CancellationSignal, options?: {
         forceDequeue?: boolean;
         types?: Type[];