@tstdl/base 0.93.76 → 0.93.78

package/queue/postgres/module.d.ts

@@ -3,7 +3,7 @@ export declare class PostgresQueueModuleConfig {
     database?: DatabaseConfig;
 }
 /**
- * configure mail module
+ * configure queue module
  */
 export declare function configurePostgresQueue(config?: PostgresQueueModuleConfig, register?: boolean): void;
 export declare function migratePostgresQueueSchema(): Promise<void>;

package/queue/postgres/module.js

@@ -9,7 +9,7 @@ export class PostgresQueueModuleConfig {
     database;
 }
 /**
- * configure mail module
+ * configure queue module
  */
 export function configurePostgresQueue(config, register = true) {
     Injector.register(PostgresQueueModuleConfig, { useValue: config });

package/queue/postgres/queue.d.ts

@@ -1,31 +1,60 @@
 import { CancellationSignal } from '../../cancellation/index.js';
+import type { Query } from '../../orm/index.js';
+import { type Transaction } from '../../orm/server/index.js';
 import type { ObjectLiteral } from '../../types/index.js';
-import { Queue, type EnqueueManyItem, type EnqueueManyOptions, type EnqueueOneOptions, type Job, type JobTag } from '../queue.js';
-export declare class PostgresQueue<T extends ObjectLiteral> extends Queue<T> {
+import { Queue, type EnqueueManyItem, type EnqueueManyOptions, type EnqueueOneOptions, type Task, type TaskTag } from '../queue.js';
+export declare class PostgresQueue<Data extends ObjectLiteral, State extends ObjectLiteral, Result extends ObjectLiteral> extends Queue<Data, State, Result> {
     #private;
     readonly processTimeout: number;
+    readonly executionTimeout: number;
     readonly maxTries: number;
-    enqueue(data: T, options?: EnqueueOneOptions): Promise<Job<T>>;
-    enqueueMany(items: EnqueueManyItem<T>[], options?: EnqueueManyOptions & {
-        returnJobs?: false;
+    readonly retryDelayMinimum: number;
+    readonly retryDelayMaximum: number;
+    readonly retryDelayGrowth: number;
+    readonly retentionPeriod: number;
+    readonly globalConcurrency: number | null;
+    enqueue(data: Data, options?: EnqueueOneOptions): Promise<Task<Data, State, Result>>;
+    enqueueMany(items: EnqueueManyItem<Data>[], options?: EnqueueManyOptions & {
+        returnTasks?: false;
     }): Promise<void>;
-    enqueueMany(items: EnqueueManyItem<T>[], options: EnqueueManyOptions & {
-        returnJobs: true;
-    }): Promise<Job<T>[]>;
-    enqueueMany(items: EnqueueManyItem<T>[], options?: EnqueueManyOptions): Promise<Job<T>[] | undefined>;
+    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>;
-    countByTag(tag: JobTag): Promise<number>;
-    get(id: string): Promise<Job<T> | undefined>;
-    getByTag(tag: JobTag): Promise<Job<T>[]>;
-    getByTags(tags: JobTag[]): Promise<Job<T>[]>;
-    cancel(id: string): Promise<void>;
-    cancelMany(ids: string[]): Promise<void>;
-    cancelByTag(tag: JobTag): Promise<void>;
-    cancelByTags(tags: JobTag[]): Promise<void>;
-    dequeue(): Promise<Job<T> | undefined>;
-    dequeueMany(count: number): Promise<Job<T>[]>;
-    acknowledge(job: Job<T>): Promise<void>;
-    acknowledgeMany(jobs: Job<T>[]): Promise<void>;
-    getConsumer(cancellationSignal: CancellationSignal): AsyncIterableIterator<Job<T>>;
-    getBatchConsumer(size: number, cancellationSignal: CancellationSignal): AsyncIterableIterator<Job<T>[]>;
+    countByTag(tag: TaskTag): Promise<number>;
+    get(id: string): Promise<Task<Data, State, Result> | undefined>;
+    getByTag(tag: TaskTag): Promise<Task<Data, State, Result>[]>;
+    getByTags(tags: TaskTag[]): 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>;
+    cancelByTag(tag: TaskTag): Promise<void>;
+    cancelManyByTag(tags: TaskTag[]): Promise<void>;
+    clear(): Promise<void>;
+    dequeue(): Promise<Task<Data, State, Result> | undefined>;
+    dequeueMany(count: number): Promise<Task<Data, State, Result>[]>;
+    reschedule(id: string, timestamp: number, transaction?: Transaction): Promise<void>;
+    rescheduleMany(ids: string[], timestamp: number, transaction?: Transaction): Promise<void>;
+    rescheduleByTag(tag: TaskTag, timestamp: number, transaction?: Transaction): Promise<void>;
+    rescheduleManyByTag(tags: TaskTag[], 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[]>;
+    acknowledge<R>(task: Task<any, any, R>, result?: R, transaction?: Transaction, { skipFanIn }?: {
+        skipFanIn?: boolean;
+    }): Promise<void>;
+    acknowledgeMany<R>(tasks: Task<any, any, R>[], results?: R[], transaction?: Transaction): Promise<void>;
+    fail(task: Task, error: any, fatal?: boolean, transaction?: Transaction, { skipFanIn }?: {
+        skipFanIn?: boolean;
+    }): Promise<void>;
+    failMany(tasks: Task[], errors: any[], transaction?: Transaction): Promise<void>;
+    prune(): Promise<void>;
+    restart(id: string, transaction?: Transaction): Promise<void>;
+    getConsumer(cancellationSignal: CancellationSignal): AsyncIterableIterator<Task<Data, State, Result>>;
+    getBatchConsumer(size: number, cancellationSignal: CancellationSignal): AsyncIterableIterator<Task<Data, State, Result>[]>;
 }