@tstdl/base 0.92.124 → 0.92.126

package/orm/types.d.ts

@@ -0,0 +1,93 @@
+/**
+ * @module
+ * Defines core ORM types, including tagged types for representing database column types
+ * (like Uuid, Timestamp, Json, etc.) and helper types for working with Drizzle ORM features
+ * like primary keys and default values. It also re-exports common decorators and schemas.
+ */
+import type { $Type, HasDefault as DrizzleHasDefault, IsPrimaryKey as DrizzleIsPrimaryKey } from 'drizzle-orm';
+import type { boolean, doublePrecision, integer, jsonb, PgColumnBuilder, PgColumnBuilderBase, PgEnumColumnBuilderInitial, text, uuid } from 'drizzle-orm/pg-core';
+import { Array, Integer } from '../schema/index.js';
+import type { AbstractConstructor, EnumerationObject, EnumerationValue, ObjectLiteral, UnionToTuple } from '../types.js';
+import type { GetTagMetadata, HasTag, Tagged, UnwrapTagged } from '../types/index.js';
+import type { bytea, numericDate, timestamp } from './data-types/index.js';
+import { Check, Column, Embedded, Encrypted, Index, PrimaryKey, References, Table, Unique } from './decorators.js';
+import { Json, NumericDate, Timestamp, Uuid } from './schemas/index.js';
+/** Tag identifier for column type information. */
+export type ColumnTypeTag = 'column';
+/** Tag identifier for embedded type configuration. */
+export type EmbeddedConfigTag = 'embedded';
+/**
+ * Helper type to tag a column type as being a primary key.
+ * It wraps the original type `T` and associates Drizzle's `IsPrimaryKey` marker
+ * with the underlying Drizzle column builder type stored in the tag metadata.
+ * @template T - The original column type (e.g., Uuid, Integer).
+ */
+export type IsPrimaryKey<T> = T extends Tagged<unknown, ColumnTypeTag, PgColumnBuilderBase> ? Tagged<UnwrapTagged<T>, ColumnTypeTag, DrizzleIsPrimaryKey<GetTagMetadata<T, ColumnTypeTag>>> : Tagged<T, ColumnTypeTag, DrizzleIsPrimaryKey<ColumnBuilder<T>>>;
+/**
+ * Helper type to tag a column type as having a default value.
+ * It wraps the original type `T` and associates Drizzle's `HasDefault` marker
+ * with the underlying Drizzle column builder type stored in the tag metadata.
+ * @template T - The original column type (e.g., Uuid, Timestamp).
+ */
+export type HasDefault<T> = T extends Tagged<unknown, ColumnTypeTag, PgColumnBuilderBase> ? Tagged<UnwrapTagged<T>, ColumnTypeTag, DrizzleHasDefault<GetTagMetadata<T, ColumnTypeTag>>> : Tagged<T, ColumnTypeTag, DrizzleHasDefault<ColumnBuilder<T>>>;
+type EnumColumn<T extends string | number, ColumnName extends string = ''> = PgEnumColumnBuilderInitial<ColumnName, UnionToTuple<`${T}`> extends [string, ...string[]] ? UnionToTuple<`${T}`> : ['NO_VALUES_PROVIDED']>;
+type TextTuple<T extends string> = UnionToTuple<`${T}`> extends [string, ...string[]] ? UnionToTuple<`${T}`> : [string];
+type HandledColumnName<T extends string = never> = [T] extends [never] ? '' : T;
+/**
+ * Utility type to infer the Drizzle column builder type based on a TypeScript type `T`.
+ * Handles primitive types (string, number, boolean), arrays, enums, Uint8Array,
+ * and existing tagged column types.
+ * @template T - The TypeScript type to map to a column builder.
+ * @template ColumnName - Optional column name for context.
+ */
+export type ColumnBuilder<T, ColumnName extends string = never> = HasTag<T> extends true ? T extends Tagged<unknown, ColumnTypeTag, any> ? GetTagMetadata<T, ColumnTypeTag> : never : T extends string ? ReturnType<typeof text<HandledColumnName<ColumnName>, string, TextTuple<T>>> : T extends number ? ReturnType<typeof doublePrecision<HandledColumnName<ColumnName>>> : T extends boolean ? ReturnType<typeof boolean<HandledColumnName<ColumnName>>> : T extends Uint8Array ? ReturnType<typeof bytea<HandledColumnName<ColumnName>>> : T extends EnumerationObject ? EnumColumn<EnumerationValue<T>, HandledColumnName<ColumnName>> : T extends (infer U)[] ? ReturnType<ColumnBuilder<U, HandledColumnName<ColumnName>>['array']> : never;
+/**
+ * Tagged type representing an embedded class configuration.
+ * Stores the embedded type `T` and an optional column name prefix `P`.
+ * @template T - The constructor of the class being embedded.
+ * @template P - An optional prefix for the column names generated from the embedded class properties.
+ */
+export type Embedded<T = AbstractConstructor, P extends string = ''> = Tagged<T, EmbeddedConfigTag, {
+    prefix: P;
+}>;
+/**
+ * Tagged type representing a PostgreSQL array column.
+ * Wraps an existing tagged column type `T` and derives the Drizzle array column builder.
+ * @template T - The tagged type of the array elements.
+ */
+export type Array<T extends Tagged<ObjectLiteral, ColumnTypeTag, PgColumnBuilder<any>>> = Tagged<UnwrapTagged<T>[], ColumnTypeTag, ReturnType<GetTagMetadata<T, ColumnTypeTag>['array']>>;
+/**
+ * Tagged type representing a JSONB column.
+ * Stores the TypeScript type `T` that the JSONB data represents.
+ * @template T - The TypeScript type of the data stored in the JSONB column.
+ */
+export type Json<T> = Tagged<T, ColumnTypeTag, $Type<ReturnType<typeof jsonb>, T>>;
+/**
+ * Tagged type representing a PostgreSQL enum column.
+ * Derives the enum values and the Drizzle enum column builder from the provided enum object `T`.
+ * @template T - The enumeration object type.
+ */
+export type Enum<T extends string | number> = Tagged<T, ColumnTypeTag, EnumColumn<T>>;
+/** Tagged type representing a `text` column. */
+export type Text<T extends string = string> = Tagged<string, ColumnTypeTag, ReturnType<typeof text<string, TextTuple<T>>>>;
+/** Tagged type representing a `uuid` column. Stores the UUID as a string. */
+export type Uuid = Tagged<string, ColumnTypeTag, ReturnType<typeof uuid>>;
+/** Tagged type representing an `integer` column. */
+export type Integer = Tagged<number, ColumnTypeTag, ReturnType<typeof integer>>;
+/** Tagged type representing a `double precision` column. */
+export type DoublePrecision = Tagged<number, ColumnTypeTag, ReturnType<typeof doublePrecision>>;
+/** Tagged type representing a `boolean` column. */
+export type Boolean = Tagged<number, ColumnTypeTag, ReturnType<typeof boolean>>;
+/** Tagged type representing a custom `numericDate` column (stores date as number YYYYMMDD). */
+export type NumericDate = Tagged<number, ColumnTypeTag, ReturnType<typeof numericDate>>;
+/** Tagged type representing a `timestamp` column (stores timestamp as number - milliseconds since epoch). */
+export type Timestamp = Tagged<number, ColumnTypeTag, ReturnType<typeof timestamp>>;
+/** Tagged type representing a `bytea` (byte array) column. */
+export type Bytea = Tagged<Uint8Array, ColumnTypeTag, ReturnType<typeof bytea>>;
+/**
+ * Tagged type representing an encrypted column.
+ * Stores the original TypeScript type `T`, but the underlying database type is `bytea`.
+ * @template T - The original (unencrypted) type of the data.
+ */
+export type Encrypted<T> = Tagged<T, ColumnTypeTag, ReturnType<typeof bytea>>;
+export { Array, Check, Column, Embedded, Encrypted, Index, Integer, Json, NumericDate, PrimaryKey, References, Table, Timestamp, Unique, Uuid };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tstdl/base",
-  "version": "0.92.124",
+  "version": "0.92.126",
   "author": "Patrick Hein",
   "publishConfig": {
     "access": "public"
@@ -28,7 +28,6 @@
     "copy:orm:mail": "rm -rf ./dist/mail/drizzle && cp -r ./source/mail/drizzle ./dist/mail/",
     "copy:orm:queue": "rm -rf ./dist/queue/postgres/drizzle && cp -r ./source/queue/postgres/drizzle ./dist/queue/postgres/"
   },
-  "types": "types/",
   "exports": {
     "./tsconfig.json": "./tsconfig.json",
     "./eslint.config.js": "./eslint.config.js",

package/password/password-check-result.model.d.ts

@@ -0,0 +1,19 @@
+import { type EnumType } from '../enumeration/enumeration.js';
+export declare const PasswordStrength: {
+    readonly VeryWeak: 0;
+    readonly Weak: 1;
+    readonly Medium: 2;
+    readonly Strong: 3;
+    readonly VeryStrong: 4;
+};
+export type PasswordStrength = EnumType<typeof PasswordStrength>;
+export declare class PasswordCheckResult {
+    strength: PasswordStrength;
+    /**
+     * Count of how many times it appears in the data set from https://haveibeenpwned.com/
+     * Undefined if disabled in options or error occured (either timeout or api error)
+     */
+    pwned?: number;
+    warnings: string[];
+    suggestions: string[];
+}

package/password/password-check.localization.d.ts

@@ -0,0 +1,20 @@
+import type { Localization, LocalizeItem } from '../text/localization.service.js';
+import type zxcvbnTranslationKeys from '@zxcvbn-ts/core/dist/data/translationKeys.js';
+export type PasswordCheckLocalization = Localization<{
+    tstdl: {
+        passwordCheck: {
+            warnings: Record<keyof typeof zxcvbnTranslationKeys['default']['warnings'], LocalizeItem>;
+            suggestions: Record<keyof typeof zxcvbnTranslationKeys['default']['suggestions'], LocalizeItem>;
+        };
+    };
+}>;
+export declare const passwordCheckLocalizationKeys: import("../text/localization.service.js").ProxyLocalizationKeys<{
+    tstdl: {
+        passwordCheck: {
+            warnings: Record<keyof (typeof zxcvbnTranslationKeys)["default"]["warnings"], LocalizeItem>;
+            suggestions: Record<keyof (typeof zxcvbnTranslationKeys)["default"]["suggestions"], LocalizeItem>;
+        };
+    };
+}>;
+export declare const germanPasswordCheckLocalization: PasswordCheckLocalization;
+export declare const englishPasswordCheckLocalization: PasswordCheckLocalization;

package/pdf/pdf.service.d.ts

@@ -0,0 +1,101 @@
+/**
+ * PDF generation
+ *
+ * @module PDF
+ */
+import { BrowserContextController } from '../browser/browser-context-controller.js';
+import type { BrowserControllerArgument } from '../browser/browser-controller.js';
+import { PdfRenderOptions } from '../browser/pdf-options.js';
+import type { Resolvable } from '../injector/index.js';
+import { resolveArgumentType } from '../injector/index.js';
+import { LogLevel } from '../logger/level.js';
+import type { TemplateField } from '../templates/index.js';
+import { Template } from '../templates/index.js';
+export declare class PdfServiceRenderOptions extends PdfRenderOptions {
+    browserContext?: BrowserContextController;
+    locale?: string;
+    /**
+     * @default true
+     */
+    waitForNetworkIdle?: boolean;
+    /**
+     * Delay pdf creation to ensure content has finished rendering
+     * @default 50
+     */
+    delay?: number;
+    /**
+     * @default false
+     */
+    log?: boolean | LogLevel;
+}
+export type PdfTemplateOptions = PdfRenderOptions;
+export declare class PdfTemplate<Context extends object = any> extends Template<{
+    header: false;
+    body: true;
+    footer: false;
+}, PdfRenderOptions, Context> {
+    options?: PdfTemplateOptions;
+}
+export type PdfServiceOptions = {
+    locale?: string;
+};
+export type PdfServiceArgument = PdfServiceOptions & {
+    browserControllerArgument: BrowserControllerArgument;
+};
+export declare class PdfService implements Resolvable<PdfServiceArgument> {
+    private readonly templateService;
+    private readonly browserController;
+    private readonly logger;
+    private readonly defaultLocale;
+    readonly [resolveArgumentType]: PdfServiceArgument;
+    /**
+     * Renders HTML to pdf stream
+     * @param html html to render
+     * @param options render options
+     * @returns pdf stream
+     */
+    renderHtmlStream(html: string, options?: PdfServiceRenderOptions): ReadableStream<Uint8Array>;
+    /**
+     * Renders HTML to pdf
+     * @param html html to render
+     * @param options render options
+     * @returns pdf bytes
+     */
+    renderHtml(html: string, options?: PdfServiceRenderOptions): Promise<Uint8Array>;
+    /**
+     * Renders an url to pdf stream
+     * @param url url to load and render
+     * @param options render options
+     * @returns pdf stream
+     */
+    renderUrlStream(url: string, options?: PdfServiceRenderOptions): ReadableStream<Uint8Array>;
+    /**
+     * Renders an url to pdf
+     * @param url url to load and render
+     * @param options render options
+     * @returns pdf bytes
+     */
+    renderUrl(url: string, options?: PdfServiceRenderOptions): Promise<Uint8Array>;
+    /**
+     * Renders a template to pdf
+     * @param key template key
+     * @param templateContext context for template rendering
+     * @param options additional options, overwrites options specified in template
+     * @returns pdf bytes
+     */
+    renderTemplateStream<Context extends object>(keyOrTemplate: string | PdfTemplate<Context>, templateContext?: Context, options?: PdfServiceRenderOptions): ReadableStream<Uint8Array>;
+    /**
+     * Renders a template to pdf
+     * @param key template key
+     * @param templateContext context for template rendering
+     * @param options additional options, overwrites options specified in template
+     * @returns pdf bytes
+     */
+    renderTemplate(keyOrTemplate: string | PdfTemplate, templateContext?: object, options?: PdfServiceRenderOptions): Promise<Uint8Array>;
+    private renderStream;
+}
+export declare function pdfTemplate(name: string, fields: {
+    body: TemplateField;
+    header?: TemplateField;
+    footer?: TemplateField;
+}, options?: PdfTemplateOptions): PdfTemplate;

package/pool/pool.d.ts

@@ -0,0 +1,49 @@
+import type { AsyncDisposable } from '../disposable/disposable.js';
+import { disposeAsync } from '../disposable/disposable.js';
+import type { Logger } from '../logger/index.js';
+export type PoolOptions = {
+    /**
+     * Maximum number of instances
+     * @default number of cpu cores
+     */
+    size?: number;
+    /**
+     * Dipose used instance on error instead of reusing it.
+     * @default false
+     */
+    disposeOnError?: boolean;
+};
+export type PoolUseOptions = {
+    /**
+     * Dipose used instance on error instead of reusing it. Overwrites pool instance option
+     * @default false
+     */
+    disposeOnError?: boolean;
+};
+export type PoolInstanceFactory<T> = () => T | Promise<T>;
+export type PoolInstanceDisposer<T> = (instance: T) => any | Promise<any>;
+export declare class Pool<T extends object> implements AsyncDisposable {
+    private readonly size;
+    private readonly disposeOnError;
+    private readonly freeInstances;
+    private readonly usedInstances;
+    private readonly factory;
+    private readonly disposer;
+    private readonly logger;
+    private placeholderInstances;
+    private disposed;
+    get length(): number;
+    constructor(factory: PoolInstanceFactory<T>, disposer: PoolInstanceDisposer<T>, logger: Logger, options?: PoolOptions);
+    owns(instance: T): boolean;
+    get(): Promise<T>;
+    release(instance: T): Promise<void>;
+    /**
+     * Get an instance from the pool and use it
+     * @param handler consumer of instance
+     * @returns instance
+     */
+    use<R>(handler: (instance: T) => R | Promise<R>, options?: PoolUseOptions): Promise<R>;
+    disposeInstance(instance: T): Promise<void>;
+    dispose(): Promise<void>;
+    [disposeAsync](): Promise<void>;
+}

package/process-shutdown.d.ts

@@ -0,0 +1,9 @@
+import type { CancellationSignal } from './cancellation/index.js';
+import { CancellationToken } from './cancellation/index.js';
+import type { Logger } from './logger/index.js';
+export declare function getShutdownToken(): CancellationToken;
+export declare function getShutdownSignal(): CancellationSignal;
+export declare function setProcessShutdownLogger(shutdownLogger: Logger): void;
+export declare function requestShutdown(exitCode?: number): void;
+export declare function forceShutdown(exitCode?: number): void;
+export declare function initializeSignals(): void;

package/promise/cancelable-promise.d.ts

@@ -0,0 +1,15 @@
+import { type CancellationSignal } from '../cancellation/token.js';
+import { CustomPromise } from './custom-promise.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 declare class CancelablePromise<T, R = void> extends CustomPromise<CancelablePromiseResult<T, R>> {
+    #private;
+    constructor(executor: CancelablePromiseExecutor<T>);
+    cancel(reason: R): void;
+}

package/queue/mongo/job.d.ts

@@ -0,0 +1,12 @@
+import type { Entity, NewEntity } from '../../database/index.js';
+import type { Job } from '../../queue/index.js';
+import type { TypedOmit } from '../../types.js';
+export type MongoJob<T = unknown> = Entity & TypedOmit<Job<T>, 'id'> & {
+    queue: string;
+    jobId: string;
+    enqueueTimestamp: number;
+    tries: number;
+    lastDequeueTimestamp: number;
+    batch: null | string;
+};
+export type NewMongoJob<T> = NewEntity<MongoJob<T>>;

package/queue/mongo/mongo-job.repository.d.ts

@@ -0,0 +1,13 @@
+import type { CollectionArgument } from '../../database/mongo/index.js';
+import { Collection, MongoEntityRepository } from '../../database/mongo/index.js';
+import type { Resolvable } from '../../injector/index.js';
+import { resolveArgumentType } from '../../injector/index.js';
+import { Logger } from '../../logger/index.js';
+import { UniqueTagStrategy } from '../../queue/index.js';
+import type { MongoJob, NewMongoJob } from './job.js';
+export declare class MongoJobRepository<T> extends MongoEntityRepository<MongoJob<T>> implements Resolvable<CollectionArgument<MongoJob<T>>> {
+    readonly [resolveArgumentType]: CollectionArgument<MongoJob<T>>;
+    constructor(collection: Collection<MongoJob<T>>, logger: Logger);
+    insertWithUniqueTagStrategy(newJob: NewMongoJob<T>, uniqueTagStrategy: UniqueTagStrategy): Promise<MongoJob<T>>;
+    bulkInsertWithUniqueTagStrategy(newJobs: NewMongoJob<T>[], uniqueTagStrategy: UniqueTagStrategy): Promise<void>;
+}

package/queue/mongo/queue.d.ts

@@ -0,0 +1,38 @@
+import type { CancellationSignal } from '../../cancellation/index.js';
+import { Lock } from '../../lock/index.js';
+import { MessageBusProvider } from '../../message-bus/index.js';
+import type { EnqueueManyItem, EnqueueManyOptions, EnqueueOneOptions, Job, JobTag } from '../../queue/index.js';
+import { Queue, type QueueConfig } from '../../queue/index.js';
+import { MongoJobRepository } from './mongo-job.repository.js';
+export declare class MongoQueue<T = unknown> extends Queue<T> {
+    private readonly repository;
+    private readonly lock;
+    private readonly queueKey;
+    private readonly messageBus;
+    readonly processTimeout: number;
+    readonly maxTries: number;
+    constructor(repository: MongoJobRepository<T>, lock: Lock, messageBusProvider: MessageBusProvider, key: string, config?: QueueConfig);
+    enqueue(data: T, options?: EnqueueOneOptions): Promise<Job<T>>;
+    enqueueMany(items: EnqueueManyItem<T>[], options?: EnqueueManyOptions & {
+        returnJobs?: false;
+    }): Promise<void>;
+    enqueueMany(items: EnqueueManyItem<T>[], options: EnqueueManyOptions & {
+        returnJobs: true;
+    }): Promise<Job<T>[]>;
+    enqueueMany(items: EnqueueManyItem<T>[], options?: EnqueueManyOptions): Promise<void | Job<T>[]>;
+    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>[]>;
+}

package/queue/mongo/queue.provider.d.ts

@@ -0,0 +1,22 @@
+import type { CollectionArgument, MongoRepositoryConfig } from '../../database/mongo/index.js';
+import { resolveArgumentType, type Resolvable } from '../../injector/interfaces.js';
+import { LockProvider } from '../../lock/index.js';
+import { MessageBusProvider } from '../../message-bus/index.js';
+import { QueueProvider, type QueueConfig } from '../../queue/index.js';
+import type { MongoJob } from './job.js';
+import { MongoJobRepository } from './mongo-job.repository.js';
+import { MongoQueue } from './queue.js';
+export declare class MongoQueueProvider extends QueueProvider implements Resolvable<CollectionArgument<MongoJob>> {
+    private readonly repository;
+    private readonly lockProvider;
+    private readonly messageBusProvider;
+    readonly [resolveArgumentType]: CollectionArgument<MongoJob>;
+    constructor(repository: MongoJobRepository<any>, lockProvider: LockProvider, messageBusProvider: MessageBusProvider);
+    get<T>(name: string, config?: QueueConfig): MongoQueue<T>;
+}
+/**
+ * configure mongo queue module
+ * @param jobRepositoryConfig repository configuration for jobs
+ * @param register whether to register for {@link Queue} and {@link QueueProvider}
+ */
+export declare function configureMongoQueue(jobRepositoryConfig: MongoRepositoryConfig<MongoJob>, register?: boolean): void;

package/queue/postgres/job.model.d.ts

@@ -0,0 +1,13 @@
+import { EntityWithoutMetadata } from '../../orm/entity.js';
+import { Integer, Json, Timestamp } from '../../orm/index.js';
+import type { ObjectLiteral } from '../../types.js';
+import type { Job } from '../queue.js';
+export declare class PostgresJob<T extends ObjectLiteral = ObjectLiteral> extends EntityWithoutMetadata implements Job<T> {
+    queue: string;
+    tag: string | null;
+    priority: Integer;
+    enqueueTimestamp: Timestamp;
+    tries: Integer;
+    lastDequeueTimestamp: Timestamp | null;
+    data: Json<T>;
+}

package/queue/postgres/module.d.ts

@@ -0,0 +1,9 @@
+import { type DatabaseConfig } from '../../orm/server/index.js';
+export declare class PostgresQueueModuleConfig {
+    database?: DatabaseConfig;
+}
+/**
+ * configure mail module
+ */
+export declare function configurePostgresQueue(config?: PostgresQueueModuleConfig, register?: boolean): void;
+export declare function migratePostgresQueueSchema(): Promise<void>;

package/queue/postgres/queue.d.ts

@@ -0,0 +1,31 @@
+import { CancellationSignal } from '../../cancellation/index.js';
+import type { ObjectLiteral } from '../../types.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> {
+    #private;
+    readonly processTimeout: number;
+    readonly maxTries: number;
+    enqueue(data: T, options?: EnqueueOneOptions): Promise<Job<T>>;
+    enqueueMany(items: EnqueueManyItem<T>[], options?: EnqueueManyOptions & {
+        returnJobs?: false;
+    }): Promise<void>;
+    enqueueMany(items: EnqueueManyItem<T>[], options: EnqueueManyOptions & {
+        returnJobs: true;
+    }): Promise<Job<T>[]>;
+    enqueueMany(items: EnqueueManyItem<T>[], options?: EnqueueManyOptions): Promise<Job<T>[] | 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>[]>;
+}

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

@@ -0,0 +1,7 @@
+import { QueueProvider, type QueueConfig } from '../../queue/index.js';
+import type { ObjectLiteral } from '../../types.js';
+import { PostgresQueue } from './queue.js';
+export declare class PostgresQueueProvider extends QueueProvider {
+    #private;
+    get<T extends ObjectLiteral>(name: string, config?: QueueConfig): PostgresQueue<T>;
+}

package/queue/postgres/schemas.d.ts

@@ -0,0 +1,3 @@
+import { PostgresJob } from './job.model.js';
+export declare const queueSchema: import("../../orm/server/database-schema.js").DatabaseSchema<"queue">;
+export declare const job: import("../../orm/server/types.js").PgTableFromType<typeof PostgresJob, "queue">;

package/queue/provider.d.ts

@@ -0,0 +1,5 @@
+import type { ObjectLiteral } from '../types.js';
+import type { Queue, QueueConfig } from './queue.js';
+export declare abstract class QueueProvider {
+    abstract get<T extends ObjectLiteral>(key: string, config?: QueueConfig): Queue<T>;
+}

package/queue/queue.d.ts

@@ -0,0 +1,91 @@
+import type { CancellationSignal } from '../cancellation/token.js';
+import { type EnumType } from '../enumeration/enumeration.js';
+import type { Resolvable, resolveArgumentType } from '../injector/interfaces.js';
+import type { Logger } from '../logger/logger.js';
+import { QueueEnqueueBatch } from './enqueue-batch.js';
+export type ProcessWorker<T> = (job: Job<T>) => void | Promise<void>;
+export type ProcessBatchWorker<T> = (jobs: Job<T>[]) => void | Promise<void>;
+export type JobTag = string | null;
+export type Job<T> = {
+    id: string;
+    /**
+     * The lower the number, the higher the priority.
+     * @default 1000
+     */
+    priority: number;
+    tag: JobTag;
+    data: T;
+    enqueueTimestamp: number;
+    lastDequeueTimestamp: number | null;
+    tries: number;
+};
+export declare const defaultJobPriority = 1000;
+export declare const UniqueTagStrategy: {
+    readonly KeepOld: 0;
+    readonly TakeNew: 1;
+};
+export type UniqueTagStrategy = EnumType<typeof UniqueTagStrategy>;
+export type EnqueueOptions = {
+    tag?: JobTag;
+    priority?: number;
+};
+export type EnqueueOneOptions = {
+    tag?: JobTag;
+    uniqueTag?: UniqueTagStrategy;
+    priority?: number;
+};
+export type EnqueueManyItem<T> = EnqueueOptions & {
+    data: T;
+};
+export type EnqueueManyOptions = {
+    uniqueTag?: UniqueTagStrategy;
+    returnJobs?: boolean;
+};
+export type QueueConfig = {
+    processTimeout?: number;
+    maxTries?: number;
+};
+export type QueueArgument = string | (QueueConfig & {
+    name: string;
+});
+export declare const defaultQueueConfig: Required<QueueConfig>;
+export declare abstract class Queue<T> implements Resolvable<QueueArgument> {
+    readonly [resolveArgumentType]: QueueArgument;
+    abstract readonly processTimeout: number;
+    abstract readonly maxTries: number;
+    batch(): QueueEnqueueBatch<T>;
+    abstract enqueue(data: T, options?: EnqueueOneOptions): Promise<Job<T>>;
+    abstract enqueueMany(items: EnqueueManyItem<T>[], options?: EnqueueManyOptions & {
+        returnJobs?: false;
+    }): Promise<void>;
+    abstract enqueueMany(items: EnqueueManyItem<T>[], options: EnqueueManyOptions & {
+        returnJobs: true;
+    }): Promise<Job<T>[]>;
+    abstract enqueueMany(items: EnqueueManyItem<T>[], options?: EnqueueManyOptions): Promise<Job<T>[] | undefined>;
+    abstract has(id: string): Promise<boolean>;
+    abstract countByTag(tag: JobTag): Promise<number>;
+    abstract get(id: string): Promise<Job<T> | undefined>;
+    abstract getByTag(tag: JobTag): Promise<Job<T>[]>;
+    abstract getByTags(tags: JobTag[]): Promise<Job<T>[]>;
+    abstract cancel(id: string): Promise<void>;
+    abstract cancelMany(ids: string[]): Promise<void>;
+    abstract cancelByTag(tag: JobTag): Promise<void>;
+    abstract cancelByTags(tags: JobTag[]): Promise<void>;
+    abstract dequeue(): Promise<Job<T> | undefined>;
+    abstract dequeueMany(count: number): Promise<Job<T>[]>;
+    abstract acknowledge(job: Job<T>): Promise<void>;
+    abstract acknowledgeMany(jobs: Job<T>[]): Promise<void>;
+    abstract getConsumer(cancellationSignal: CancellationSignal): AsyncIterableIterator<Job<T>>;
+    abstract getBatchConsumer(size: number, cancellationSignal: CancellationSignal): AsyncIterableIterator<Job<T>[]>;
+    process({ concurrency, cancellationSignal }: {
+        concurrency?: number;
+        cancellationSignal: CancellationSignal;
+    }, handler: ProcessWorker<T>, logger: Logger): void;
+    processBatch({ batchSize, concurrency, cancellationSignal }: {
+        batchSize?: number;
+        concurrency?: number;
+        cancellationSignal: CancellationSignal;
+    }, handler: ProcessBatchWorker<T>, logger: Logger): void;
+    private processWorker;
+    private processBatchWorker;
+}

package/reflection/decorators.d.ts

@@ -0,0 +1,15 @@
+import 'reflect-metadata/lite';
+import type { ConstructorParameterDecorator } from '../types.js';
+import type { Decorator, DecoratorHandler } from './types.js';
+import { type CreateDecoratorOptions, type SpecificCreateDecoratorOptions } from './utils.js';
+export declare function Decorate({ handler, ...options }?: CreateDecoratorOptions & {
+    handler?: DecoratorHandler;
+}): Decorator;
+export declare function Class(options?: SpecificCreateDecoratorOptions<'class'>): ClassDecorator;
+export declare function Property(options?: SpecificCreateDecoratorOptions<'property'>): PropertyDecorator;
+export declare function Accessor(options?: SpecificCreateDecoratorOptions<'accessor'>): MethodDecorator;
+export declare function PropertyOrAccessor(options?: SpecificCreateDecoratorOptions<'property' | 'accessor'>): Decorator<'property' | 'accessor'>;
+export declare function Method(options?: SpecificCreateDecoratorOptions<'method'>): MethodDecorator;
+export declare function MethodParameter(options?: SpecificCreateDecoratorOptions<'methodParameter'>): ParameterDecorator;
+export declare function ConstructorParameter(options?: SpecificCreateDecoratorOptions<'constructorParameter'>): ConstructorParameterDecorator;
+export declare function Parameter(options?: SpecificCreateDecoratorOptions<'parameter'>): ParameterDecorator & ConstructorParameterDecorator;