@tstdl/base 0.93.35 → 0.93.36

package/source/promise/README.md

@@ -0,0 +1,209 @@
+# Advanced Promises
+
+This module provides a set of advanced Promise implementations for handling more complex asynchronous scenarios, such as cancellation, deferred resolution, and lazy execution.
+
+## Table of Contents
+
+- [Features](#features)
+- [Core Concepts](#core-concepts)
+  - [DeferredPromise](#deferredpromise)
+  - [CancelablePromise](#cancelablepromise)
+  - [LazyPromise](#lazypromise)
+- [Usage](#usage)
+  - [DeferredPromise](#deferredpromise-1)
+  - [CancelablePromise](#cancelablepromise-1)
+  - [LazyPromise](#lazypromise-1)
+- [API Summary](#api-summary)
+
+## Features
+
+- **Deferred Resolution**: Control promise resolution and rejection from outside the executor function with `DeferredPromise`.
+- **Cancellable Operations**: Create promises for long-running operations that can be gracefully canceled using `CancelablePromise`.
+- **Lazy Execution**: Defer the execution of a promise's logic until it is actually awaited with `LazyPromise`.
+
+## Core Concepts
+
+This module extends the standard `Promise` functionality to cover common patterns that are cumbersome to implement manually.
+
+### DeferredPromise
+
+A `DeferredPromise` decouples the promise's creation from its resolution or rejection. This is useful in scenarios where one part of your code needs to wait for a signal or event triggered by another, unrelated part. You can create the promise, pass it around, and then call `resolve()` or `reject()` on it later when the condition is met. It also supports being `reset()` to a pending state to be awaited again.
+
+### CancelablePromise
+
+A `CancelablePromise` wraps an asynchronous operation and exposes a `cancel()` method. When awaited, it resolves to an object indicating whether the operation completed successfully (`{ canceled: false, value: T }`) or was canceled (`{ canceled: true, reason: R }`). The executor function receives a `cancellationSignal` that can be used to stop the ongoing work prematurely.
+
+### LazyPromise
+
+A `LazyPromise` defers the execution of its executor function until `.then()`, `.catch()`, or `.finally()` is called on it (or it is `await`ed). This is ideal for deferring resource-intensive operations, like network requests or file I/O, until the result is actually needed, preventing unnecessary work.
+
+## Usage
+
+### DeferredPromise
+
+A `DeferredPromise` is useful when you need to resolve a promise from outside its initial scope.
+
+**Basic Usage**
+
+```typescript
+import { DeferredPromise } from '@tstdl/base/promise';
+import { CancellationToken } from '@tstdl/base/cancellation';
+import { cancelableTimeout } from '@tstdl/base/utils';
+
+// Somewhere in your application, a signal is created
+const readySignal = new DeferredPromise<void>();
+
+async function waitForReady() {
+  console.log('Waiting for the system to be ready...');
+  await readySignal;
+  console.log('System is ready!');
+}
+
+async function initializeSystem() {
+  await cancelableTimeout(1000, CancellationToken.None); // Simulate work
+  console.log('System initialized, resolving signal.');
+  readySignal.resolve();
+}
+
+waitForReady();
+initializeSystem();
+
+// Output:
+// Waiting for the system to be ready...
+// System initialized, resolving signal.
+// System is ready!
+```
+
+**Resetting a DeferredPromise**
+
+You can reset a `DeferredPromise` to its pending state to be awaited again.
+
+```typescript
+import { DeferredPromise } from '@tstdl/base/promise';
+
+const promise = new DeferredPromise<string>();
+
+async function run() {
+  promise.resolve('First resolution');
+  const result1 = await promise;
+  console.log(result1); // 'First resolution'
+
+  promise.reset();
+
+  promise.resolve('Second resolution');
+  const result2 = await promise;
+  console.log(result2); // 'Second resolution'
+}
+
+run();
+```
+
+### CancelablePromise
+
+A `CancelablePromise` is perfect for operations that might need to be aborted.
+
+```typescript
+import { CancelablePromise } from '@tstdl/base/promise';
+import { CancellationToken } from '@tstdl/base/cancellation';
+import { cancelableTimeout } from '@tstdl/base/utils';
+
+async function fetchUserData(id: string, cancellationSignal: CancellationToken): Promise<{ id: string, name: string }> {
+  console.log(`Fetching data for user ${id}...`);
+  await cancelableTimeout(2000, cancellationSignal); // Simulate a network request
+  return { id, name: 'John Doe' };
+}
+
+const promise = new CancelablePromise<Awaited<ReturnType<typeof fetchUserData>>, string>(
+  (resolve, reject, cancellationSignal) => {
+    fetchUserData('123', cancellationSignal)
+      .then(resolve)
+      .catch(reject);
+  }
+);
+
+// Example 1: Operation completes successfully
+async function runSuccessful() {
+  const result = await promise;
+
+  if (result.canceled) {
+    console.log(`Operation was canceled with reason: ${result.reason}`);
+  } else {
+    console.log('User data fetched:', result.value);
+  }
+}
+
+// runSuccessful();
+// Output:
+// Fetching data for user 123...
+// User data fetched: { id: '123', name: 'John Doe' }
+
+// Example 2: Operation is canceled
+async function runCanceled() {
+  setTimeout(() => {
+    console.log('Canceling fetch operation...');
+    promise.cancel('User navigated away');
+  }, 500);
+
+  const result = await promise;
+
+  if (result.canceled) {
+    console.log(`Operation was canceled with reason: ${result.reason}`);
+  } else {
+    console.log('User data fetched:', result.value);
+  }
+}
+
+runCanceled();
+// Output:
+// Fetching data for user 123...
+// Canceling fetch operation...
+// Operation was canceled with reason: User navigated away
+```
+
+### LazyPromise
+
+A `LazyPromise` delays execution until the result is consumed.
+
+```typescript
+import { LazyPromise } from '@tstdl/base/promise';
+import { CancellationToken } from '@tstdl/base/cancellation';
+import { cancelableTimeout } from '@tstdl/base/utils';
+
+console.log('Creating LazyPromise...');
+const lazyPromise = new LazyPromise<string>(async (resolve) => {
+  console.log('LazyPromise executor is now running!');
+  await cancelableTimeout(500, CancellationToken.None);
+  resolve('Lazy data is ready.');
+});
+
+async function consumeLazy() {
+  console.log('About to await the LazyPromise...');
+  const result = await lazyPromise;
+  console.log(result);
+}
+
+console.log('Script started.');
+consumeLazy();
+console.log('consumeLazy() called, but executor has not run yet.');
+
+// Output:
+// Creating LazyPromise...
+// Script started.
+// About to await the LazyPromise...
+// consumeLazy() called, but executor has not run yet.
+// LazyPromise executor is now running!
+// Lazy data is ready.
+```
+
+## API Summary
+
+| Class/Function | Signature | Return Type | Description |
+| :--- | :--- | :--- | :--- |
+| **`DeferredPromise<T>`** | `new <T>(executor?: PromiseExecutor<T>)` | `DeferredPromise<T>` | Creates a new deferred promise. |
+| | `resolve(value: T)` | `void` | Resolves the promise with a value. Throws if not pending. |
+| | `resolveIfPending(value: T)` | `void` | Resolves the promise only if it is in a pending state. |
+| | `reject(reason?: any)` | `void` | Rejects the promise with a reason. Throws if not pending. |
+| | `reset()` | `void` | Resets the promise to a pending state if it was settled. |
+| **`CancelablePromise<T, R>`** | `new <T, R>(executor: CancelablePromiseExecutor<T>)` | `CancelablePromise<T, R>` | Creates a new cancelable promise. |
+| | `cancel(reason: R)` | `void` | Cancels the promise, causing it to resolve with a `canceled: true` result. |
+| **`LazyPromise<T>`** | `new <T>(executor: PromiseExecutor<T>)` | `LazyPromise<T>` | Creates a new lazy promise. The executor runs only when awaited. |

package/source/promise/cancelable-promise.ts

@@ -0,0 +1,46 @@
+import { CancellationToken, type CancellationSignal } from '#/cancellation/token.js';
+import { CustomPromise } from './custom-promise.js';
+import type { PromiseRejectFunction, PromiseResolveFunction } from './types.js';
+
+export type CancelablePromiseExecutor<T> = (resolve: (value: T | PromiseLike<T>) => void, reject: (reason?: any) => void, cancellationSignal: CancellationSignal) => void;
+
+export type CancelablePromiseResult<T, R> =
+  | { canceled: true, reason: R }
+  | { canceled: false, value: T };
+
+export class CancelablePromise<T, R = void> extends CustomPromise<CancelablePromiseResult<T, R>> {
+  readonly #cancellationToken = new CancellationToken();
+  readonly #resolve: PromiseResolveFunction<CancelablePromiseResult<T, R>>;
+  readonly #reject: PromiseRejectFunction;
+
+  #pending = true;
+
+  constructor(executor: CancelablePromiseExecutor<T>) {
+    super();
+
+    this.#resolve = (value) => {
+      if (this.#pending) {
+        this.resolve(value);
+        this.#pending = false;
+      }
+    };
+
+    this.#reject = (reason) => {
+      if (this.#pending) {
+        this.reject(reason);
+        this.#pending = false;
+      }
+    };
+
+    executor(
+      (value) => this.#resolve(Promise.resolve(value).then((result) => ({ canceled: false, value: result }))),
+      this.#reject,
+      this.#cancellationToken.signal
+    );
+  }
+
+  cancel(reason: R): void {
+    this.#cancellationToken.set();
+    this.#resolve({ canceled: true, reason });
+  }
+}

package/source/promise/custom-promise.ts

@@ -0,0 +1,21 @@
+import type { PromiseRejectFunction, PromiseResolveFunction } from './types.js';
+
+export class CustomPromise<T> extends Promise<T> {
+  static override readonly [Symbol.species] = Promise;
+
+  protected readonly resolve: PromiseResolveFunction<T>;
+  protected readonly reject: PromiseRejectFunction;
+
+  constructor() {
+    let _resolve!: PromiseResolveFunction<T>;
+    let _reject!: PromiseRejectFunction;
+
+    super((resolve, reject) => {
+      _resolve = resolve;
+      _reject = reject;
+    });
+
+    this.resolve = _resolve;
+    this.reject = _reject;
+  }
+}

package/source/promise/deferred-promise.ts

@@ -0,0 +1,102 @@
+import type { PromiseExecutor } from './types.js';
+
+export const enum PromiseState {
+  Pending = 0,
+  Resolved = 1,
+  Rejected = 2,
+}
+
+export class DeferredPromise<T = void> extends Promise<T> {
+  private backingPromise: Promise<T>;
+  private resolvePromise: (value: T | PromiseLike<T>) => void;
+  private rejectPromise: (reason?: any) => void;
+
+  private state: PromiseState;
+
+  override readonly [Symbol.toStringTag] = 'DeferredPromise';
+
+  get resolved(): boolean {
+    return this.state == PromiseState.Resolved;
+  }
+
+  get rejected(): boolean {
+    return this.state == PromiseState.Rejected;
+  }
+
+  get pending(): boolean {
+    return this.state == PromiseState.Pending;
+  }
+
+  get settled(): boolean {
+    return this.state != PromiseState.Pending;
+  }
+
+  constructor(executor?: PromiseExecutor<T>) {
+    super(() => { /* noop */ });
+
+    this.reset();
+
+    if (executor != undefined) {
+      executor((value) => this.resolve(value), (reason) => this.reject(reason));
+    }
+  }
+
+  override async then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null): Promise<TResult1 | TResult2> {
+    return await this.backingPromise.then(onfulfilled, onrejected);
+  }
+
+  override async catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null): Promise<T | TResult> {
+    return await this.backingPromise.catch(onrejected);
+  }
+
+  override async finally(onfinally?: (() => void) | null): Promise<T> {
+    return await this.backingPromise.finally(onfinally);
+  }
+
+  resolve(value: T | PromiseLike<T>): void {
+    this.ensurePendingState();
+    this.resolveIfPending(value);
+  }
+
+  resolveIfPending(value: T | PromiseLike<T>): void {
+    if (this.pending) {
+      this.resolvePromise(value);
+      this.state = PromiseState.Resolved;
+    }
+  }
+
+  resolveAndReset(value: T | PromiseLike<T>): void {
+    this.resolve(value);
+    this.reset();
+  }
+
+  reject(reason?: unknown): void {
+    this.ensurePendingState();
+
+    this.rejectPromise(reason);
+    this.state = PromiseState.Rejected;
+  }
+
+  reset(): void {
+    if (this.pending) {
+      return;
+    }
+
+    this.backingPromise = new Promise<T>((resolve, reject) => {
+      this.resolvePromise = resolve;
+      this.rejectPromise = reject;
+    });
+
+    this.state = PromiseState.Pending;
+  }
+
+  private ensurePendingState(): void {
+    if (this.resolved) {
+      throw new Error('Promise already resolved.');
+    }
+
+    if (this.rejected) {
+      throw new Error('Promise already rejected.');
+    }
+  }
+}

package/source/promise/index.ts

@@ -0,0 +1,10 @@
+/**
+ * Advanced Promises
+ *
+ * @module Promise
+ */
+
+export * from './cancelable-promise.js';
+export * from './deferred-promise.js';
+export * from './lazy-promise.js';
+export * from './types.js';

package/source/promise/lazy-promise.ts

@@ -0,0 +1,46 @@
+import { isPromiseLike } from '#/utils/type-guards.js';
+import { CustomPromise } from './custom-promise.js';
+import type { PromiseExecutor } from './types.js';
+
+export class LazyPromise<T> extends CustomPromise<T> {
+  #executed = false;
+
+  readonly #executorOrPromiseProvider: PromiseExecutor<T> | (() => PromiseLike<T>);
+
+  override readonly [Symbol.toStringTag] = 'LazyPromise';
+
+  constructor(executorOrPromiseProvider: PromiseExecutor<T> | (() => PromiseLike<T>)) {
+    super();
+
+    this.#executorOrPromiseProvider = executorOrPromiseProvider;
+  }
+
+  override async then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null): Promise<TResult1 | TResult2> {
+    this.execute();
+    return super.then(onfulfilled, onrejected);
+  }
+
+  override async catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null): Promise<T | TResult> {
+    this.execute();
+    return super.catch(onrejected);
+  }
+
+  override async finally(onfinally?: (() => void) | null): Promise<T> {
+    this.execute();
+    return super.finally(onfinally);
+  }
+
+  private execute(): void {
+    if (this.#executed) {
+      return;
+    }
+
+    this.#executed = true;
+
+    const result = this.#executorOrPromiseProvider(this.resolve, this.reject);
+
+    if (isPromiseLike(result)) {
+      this.resolve(result);
+    }
+  }
+}

package/source/promise/types.ts

@@ -0,0 +1,3 @@
+export type PromiseExecutor<T> = ConstructorParameters<typeof Promise<T>>[0];
+export type PromiseResolveFunction<T> = (value: T | PromiseLike<T>) => void;
+export type PromiseRejectFunction = (reason?: any) => void;

package/source/queue/README.md

@@ -0,0 +1,235 @@
+# Queue
+
+A robust, multi-backend queueing system for managing and processing background jobs.
+
+## Table of Contents
+
+- [Features](#features)
+- [Core Concepts](#core-concepts)
+- [Usage](#usage)
+  - [Backend Configuration](#backend-configuration)
+  - [Getting a Queue Instance](#getting-a-queue-instance)
+  - [Enqueueing Jobs](#enqueueing-jobs)
+  - [Processing Jobs (Workers)](#processing-jobs-workers)
+- [API Summary](#api-summary)
+  - [Class: Queue<T>](#class-queuet)
+  - [Configuration Functions](#configuration-functions)
+
+## Features
+
+- **Multi-Backend Support**: Seamlessly switch between PostgreSQL and MongoDB backends.
+- **Simplified Workers**: Easily create robust workers with the `process()` and `processBatch()` methods, which handle job fetching, acknowledging, and retries automatically.
+- **Job Prioritization**: Assign priorities to jobs to ensure important tasks are processed first.
+- **Unique Jobs**: Prevent duplicate jobs using tags with configurable strategies (`KeepOld` or `TakeNew`).
+- **Batch Operations**: Enqueue multiple jobs in a single, efficient operation using `enqueueMany` or the `batch()` helper.
+- **Automatic Retries**: Failed jobs are automatically retried up to a configurable number of times with exponential backoff.
+- **Configurable Timeouts**: Set a processing timeout for each queue to prevent jobs from getting stuck.
+- **Robust Consumer Patterns**: For advanced use cases, create custom consumers using async iterators (`getConsumer` and `getBatchConsumer`).
+
+## Core Concepts
+
+### Queue
+
+The `Queue<T>` class is the central point of interaction. Each queue is identified by a unique name and handles a specific type of job data (`T`). It provides methods for enqueueing, processing, and managing jobs.
+
+### Job
+
+A `Job` represents a single unit of work. It contains the data payload to be processed, a priority level, an optional tag for identification, and metadata such as the number of tries and timestamps.
+
+### Provider (`QueueProvider`)
+
+The `QueueProvider` is a factory responsible for creating `Queue` instances. This abstraction allows the system to support different storage backends. Implementations like `PostgresQueueProvider` or `MongoQueueProvider` are used to get queue instances connected to the appropriate database.
+
+### Worker (Consumer)
+
+A worker is a process that fetches jobs from a queue and executes them. This module simplifies worker creation with the `process()` and `processBatch()` methods, which encapsulate the logic for fetching jobs, executing the handler, acknowledging success, and handling failures for retries.
+
+### Unique Tags
+
+You can assign a `tag` (a string) to a job. When combined with a `uniqueTag` strategy, this mechanism prevents duplicate jobs from being enqueued.
+
+- **`UniqueTagStrategy.KeepOld`**: If a job with the same tag already exists, the new job is discarded.
+- **`UniqueTagStrategy.TakeNew`**: If a job with the same tag already exists, it is overwritten by the new job.
+
+## Usage
+
+### Backend Configuration
+
+First, configure the queue provider in your application's setup file.
+
+#### PostgreSQL
+
+```typescript
+// In your application's bootstrap file
+import { configurePostgresQueue } from '@tstdl/base/queue/postgres';
+
+// This will use the default database configuration.
+// You can provide a specific database configuration if needed.
+configurePostgresQueue();
+```
+
+### Getting a Queue Instance
+
+Use the dependency injector to get an instance of a specific queue by its name. The job's data type should be provided as a generic argument.
+
+```typescript
+import { Queue } from '@tstdl/base/queue';
+import { Injector } from '@tstdl/base/injector';
+
+type ProcessProductImageJob = {
+  productId: string;
+  imageUrl: string;
+};
+
+// Get a queue named 'image-processing'
+const imageQueue = Injector.resolve<Queue<ProcessProductImageJob>>(Queue, 'image-processing');
+```
+
+### Enqueueing Jobs
+
+#### Enqueueing a Single Job
+
+Add a new job to the queue with the required data payload.
+
+```typescript
+await imageQueue.enqueue({
+  productId: 'prod-123',
+  imageUrl: 'https://example.com/image.jpg'
+});
+
+console.log('Image processing job enqueued.');
+```
+
+#### Enqueueing with Options
+
+You can specify options like priority, tags, and unique job strategies.
+
+```typescript
+import { UniqueTagStrategy } from '@tstdl/base/queue';
+
+// This job has a high priority (lower number is higher).
+// If a job with the tag 'product-image-prod-456' already exists, it will be replaced.
+await imageQueue.enqueue(
+  { productId: 'prod-456', imageUrl: 'https://example.com/another.jpg' },
+  {
+    priority: 100, // Default is 1000
+    tag: 'product-image-prod-456',
+    uniqueTag: UniqueTagStrategy.TakeNew
+  }
+);
+```
+
+#### Enqueueing a Batch of Jobs
+
+For performance, you can enqueue multiple jobs at once using `enqueueMany` or the `batch()` helper.
+
+**Using `enqueueMany`:**
+
+```typescript
+await imageQueue.enqueueMany([
+  { data: { productId: 'prod-789', imageUrl: '...' } },
+  { data: { productId: 'prod-101', imageUrl: '...' }, priority: 500 }
+]);
+```
+
+**Using the `batch()` helper:**
+
+```typescript
+const batch = imageQueue.batch();
+
+batch.add({ productId: 'prod-789', imageUrl: '...' });
+batch.add({ productId: 'prod-101', imageUrl: '...' }, { priority: 500 });
+
+await batch.enqueue(); // Enqueues all added jobs in one operation
+```
+
+### Processing Jobs (Workers)
+
+Workers are responsible for executing the logic for jobs on the queue. The `process` and `processBatch` methods provide a simple and robust way to create them. These methods automatically handle fetching jobs, acknowledging them on success, and allowing them to be retried on failure.
+
+#### Processing Jobs One by One
+
+Create a worker to process jobs individually. You can run multiple workers in parallel by adjusting the `concurrency` option.
+
+```typescript
+import { CancellationSignal } from '@tstdl/base/cancellation';
+import { Logger } from '@tstdl/base/logger';
+
+// A function to simulate processing an image
+async function processImage(url: string): Promise<void> {
+  console.log(`Processing image from ${url}...`);
+  // Add image processing logic here. If this throws, the job will be retried.
+  await new Promise(resolve => setTimeout(resolve, 500));
+}
+
+function startImageWorker(cancellationSignal: CancellationSignal): void {
+  const logger = Injector.resolve(Logger);
+  logger.info('Image worker started. Waiting for jobs...');
+
+  imageQueue.process(
+    { concurrency: 5, cancellationSignal },
+    async (job) => {
+      logger.verbose(`Processing job ${job.id} for product ${job.data.productId}`);
+      await processImage(job.data.imageUrl);
+    },
+    logger
+  );
+}
+```
+
+#### Processing Jobs in Batches
+
+For high-throughput scenarios, you can process jobs in batches to reduce overhead.
+
+```typescript
+function startBatchImageWorker(cancellationSignal: CancellationSignal): void {
+  const logger = Injector.resolve(Logger);
+  logger.info('Batch image worker started.');
+
+  imageQueue.processBatch(
+    { batchSize: 50, concurrency: 2, cancellationSignal },
+    async (jobs) => {
+      logger.verbose(`Processing a batch of ${jobs.length} jobs.`);
+      const imagePromises = jobs.map(job => processImage(job.data.imageUrl));
+      await Promise.all(imagePromises);
+    },
+    logger
+  );
+}
+```
+
+## API Summary
+
+### Class: `Queue<T>`
+
+The main class for interacting with a queue.
+
+| Method | Arguments | Return Type | Description |
+| :--- | :--- | :--- | :--- |
+| `enqueue` | `data: T`, `options?: EnqueueOneOptions` | `Promise<Job<T>>` | Adds a single job to the queue. |
+| `enqueueMany` | `items: EnqueueManyItem<T>[]`, `options?: EnqueueManyOptions` | `Promise<void \| Job<T>[]>` | Adds multiple jobs. Can optionally return the created jobs. |
+| `batch` | | `QueueEnqueueBatch<T>` | Creates a batch enqueue helper for better performance. |
+| `dequeue` | | `Promise<Job<T> \| undefined>` | Retrieves a single available job for processing. |
+| `dequeueMany` | `count: number` | `Promise<Job<T>[]>` | Retrieves a batch of available jobs. |
+| `acknowledge` | `job: Job<T>` | `Promise<void>` | Marks a job as completed, removing it from the queue. |
+| `acknowledgeMany`| `jobs: Job<T>[]` | `Promise<void>` | Acknowledges a batch of jobs. |
+| `process` | `options`, `handler`, `logger` | `void` | Starts a worker to process jobs one by one. |
+| `processBatch` | `options`, `handler`, `logger` | `void` | Starts a worker to process jobs in batches. |
+| `getConsumer` | `cancellationSignal` | `AsyncIterableIterator<Job<T>>` | **Advanced:** Returns an async iterator that yields jobs. |
+| `getBatchConsumer`| `size`, `cancellationSignal` | `AsyncIterableIterator<Job<T>[]>` | **Advanced:** Returns an async iterator that yields batches of jobs. |
+| `get` | `id: string` | `Promise<Job<T> \| undefined>` | Retrieves a job by its ID. |
+| `getByTag` | `tag: JobTag` | `Promise<Job<T>[]>` | Retrieves all jobs with a specific tag. |
+| `getByTags` | `tags: JobTag[]` | `Promise<Job<T>[]>` | Retrieves all jobs with any of the specified tags. |
+| `has` | `id: string` | `Promise<boolean>` | Checks if a job with the given ID exists. |
+| `countByTag` | `tag: JobTag` | `Promise<number>` | Counts jobs with a specific tag. |
+| `cancel` | `id: string` | `Promise<void>` | Cancels and deletes a job by its ID. |
+| `cancelMany` | `ids: string[]` | `Promise<void>` | Cancels and deletes multiple jobs by their IDs. |
+| `cancelByTag` | `tag: JobTag` | `Promise<void>` | Cancels all jobs with a specific tag. |
+| `cancelByTags` | `tags: JobTag[]` | `Promise<void>` | Cancels all jobs with any of the specified tags. |
+
+### Configuration Functions
+
+| Function | Description |
+| :--- | :--- |
+| `configurePostgresQueue(config?: PostgresQueueModuleConfig)` | Configures the module to use a PostgreSQL backend. |
+| `configureMongoQueue(config: MongoRepositoryConfig<MongoJob>)` | Configures the module to use a MongoDB backend. |