@tstdl/base 0.93.86 → 0.93.89

package/task-queue/postgres/schemas.js

@@ -0,0 +1,8 @@
+import { databaseSchema } from '../../orm/server/index.js';
+import { DependencyJoinMode, TaskState } from '../task-queue.js';
+import { PostgresTask, PostgresTaskArchive } from './task.model.js';
+export const taskQueueSchema = databaseSchema('task_queue');
+export const taskState = taskQueueSchema.getEnum(TaskState);
+export const dependencyJoinMode = taskQueueSchema.getEnum(DependencyJoinMode);
+export const task = taskQueueSchema.getTable(PostgresTask);
+export const taskArchive = taskQueueSchema.getTable(PostgresTaskArchive);

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

@@ -0,0 +1,83 @@
+import { CancellationSignal } from '../../cancellation/index.js';
+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 type { ObjectLiteral } from '../../types/index.js';
+import { TaskQueue, type EnqueueManyItem, type EnqueueManyOptions, type EnqueueOneOptions, type Task } from '../task-queue.js';
+export declare class PostgresQueue<Data extends ObjectLiteral, State extends ObjectLiteral, Result extends ObjectLiteral> extends TaskQueue<Data, State, Result> {
+    #private;
+    readonly visibilityTimeout: number;
+    readonly maxExecutionTime: number;
+    readonly maxTries: number;
+    readonly retryDelayMinimum: number;
+    readonly retryDelayMaximum: number;
+    readonly retryDelayGrowth: number;
+    readonly retention: number;
+    readonly archiveRetention: number;
+    readonly priorityAgingInterval: number;
+    readonly priorityAgingStep: number;
+    readonly defaultTimeToLive: number;
+    readonly rateLimit: number;
+    readonly rateInterval: number;
+    readonly idempotencyWindow: number;
+    readonly globalConcurrency: number | null;
+    [afterResolve](): void;
+    enqueue(type: string, data: Data, options?: EnqueueOneOptions): Promise<Task<Data, State, Result>>;
+    enqueueMany(items: EnqueueManyItem<Data>[], options?: EnqueueManyOptions & {
+        returnTasks?: false;
+    }): Promise<void>;
+    enqueueMany(items: EnqueueManyItem<Data>[], options: EnqueueManyOptions & {
+        returnTasks: true;
+    }): Promise<Task<Data, State, Result>[]>;
+    enqueueMany(items: EnqueueManyItem<Data>[], options?: EnqueueManyOptions): Promise<Task<Data, State, Result>[] | undefined>;
+    has(id: string): Promise<boolean>;
+    countByTags(tags: OneOrMany<string>): Promise<number>;
+    getTask(id: string): Promise<Task<Data, State, Result> | undefined>;
+    getManyByTags(tags: OneOrMany<string>): Promise<Task<Data, State, Result>[]>;
+    getTree(idOrIds: string | string[], transaction?: Transaction): Promise<Task<unknown, unknown, unknown>[]>;
+    getTreeByQuery(query: Query<Task>, transaction?: Transaction): Promise<Task<unknown, unknown, unknown>[]>;
+    cancel(id: string, transaction?: Transaction): Promise<void>;
+    cancelMany(ids: string[], transaction?: Transaction): Promise<void>;
+    cancelManyByTags(tags: OneOrMany<string>): Promise<void>;
+    clear(): Promise<void>;
+    dequeue(options?: {
+        forceDequeue?: boolean;
+        types?: string[];
+    }): Promise<Task<Data, State, Result> | undefined>;
+    dequeueMany(count: number, options?: {
+        forceDequeue?: boolean;
+        types?: string[];
+    }): Promise<Task<Data, State, Result>[]>;
+    reschedule(id: string, timestamp: number, transaction?: Transaction): Promise<void>;
+    rescheduleMany(ids: string[], timestamp: number, transaction?: Transaction): Promise<void>;
+    rescheduleManyByTags(tags: OneOrMany<string>, timestamp: number, transaction?: Transaction): Promise<void>;
+    touch(task: Task, options?: {
+        progress?: number;
+        state?: State;
+        transaction?: Transaction;
+    }): Promise<Task<Data, State, Result> | undefined>;
+    touchMany(tasks: Task[], progresses?: number[], states?: State[], transaction?: Transaction): Promise<string[]>;
+    complete<R>(task: Task<any, any, R>, result?: R, transaction?: Transaction): Promise<void>;
+    completeMany<R>(tasks: Task<any, any, R>[], results?: R[], transaction?: Transaction): Promise<void>;
+    fail(task: Task, error: any, fatal?: boolean, transaction?: Transaction): Promise<void>;
+    triggerTagFanIn(tags: string[], transaction?: Transaction): Promise<void>;
+    failMany(tasks: Task[], errors: any[], transaction?: Transaction): Promise<void>;
+    resolveDependencies(targetTags: string[]): Promise<void>;
+    maintenance(): Promise<void>;
+    restart(id: string, options?: {
+        resetState?: boolean;
+        transaction?: Transaction;
+    }): Promise<void>;
+    getConsumer(cancellationSignal: CancellationSignal, options?: {
+        forceDequeue?: boolean;
+        types?: string[];
+    }): AsyncIterableIterator<Task<Data, State, Result>>;
+    maintenanceLoop(): Promise<void>;
+    processPendingFanIn(transaction?: Transaction): Promise<number>;
+    startSystemWorker(): void;
+    getBatchConsumer(size: number, cancellationSignal: CancellationSignal, options?: {
+        forceDequeue?: boolean;
+        types?: string[];
+    }): AsyncIterableIterator<Task<Data, State, Result>[]>;
+}