@tstdl/base 0.92.124 → 0.92.125

package/orm/server/transactional.d.ts

@@ -0,0 +1,75 @@
+import { Database } from './database.js';
+import { type PgTransaction, type Transaction, type TransactionConfig } from './transaction.js';
+export type TransactionInitOptions = TransactionConfig & {
+    /**
+     * Indicates that an existing transaction should be used if available instead of creating a new one.
+     * @default true
+     */
+    useExisting?: boolean;
+};
+export type TransactionHandler<R> = (transaction: Transaction) => Promise<R>;
+type TransactionalContext<ContextData = unknown> = {
+    session: Database | PgTransaction;
+    cache: WeakMap<Database | PgTransaction, any>;
+    data: ContextData;
+};
+declare const getCurrentTransactionalContext: {
+    (required: true, debugFn: import("../../types.js").Function): TransactionalContext<unknown>;
+    (required?: false, debugFn?: import("../../types.js").Function): TransactionalContext<unknown> | null;
+    (required: boolean, debugFn: import("../../types.js").Function): TransactionalContext<unknown> | null;
+}, runInTransactionalContext: <ReturnT>(context: TransactionalContext<unknown>, fn: () => ReturnT) => ReturnT, isInTransactionalContext: () => boolean;
+export { getCurrentTransactionalContext, isInTransactionalContext, runInTransactionalContext };
+export declare abstract class Transactional<ContextData = unknown> {
+    #private;
+    readonly session: PgTransaction | Database;
+    readonly isInTransaction: boolean;
+    constructor();
+    /**
+     * Starts a new database transaction.
+     * @param config Optional transaction configuration.
+     * @returns A promise that resolves to the new Transaction instance.
+     */
+    startTransaction(config?: TransactionInitOptions): Promise<Transaction>;
+    /**
+     * Returns a new instance of the repository bound to the provided session.
+     * Useful for performing multiple operations within a single database session.
+     * @param session The session to bind to.
+     * @returns A new repository instance bound to the session.
+     */
+    withSession(session: Database | PgTransaction): this;
+    /**
+       * Returns a new instance of the repository bound to the provided transaction, if a transaction is provided.
+       * Otherwise, returns the current instance.
+       * @param transaction The transaction to bind to (optional).
+       * @returns A repository instance bound to the transaction or the current instance.
+       */
+    withOptionalTransaction(transaction: Transaction | undefined): this;
+    /**
+     * Returns a new instance of the repository bound to the provided transaction.
+     * Useful for performing multiple operations within a single database transaction.
+     * @param transaction The transaction to bind to.
+     * @returns A new repository instance bound to the transaction.
+     */
+    withTransaction(transaction: Transaction): this;
+    /**
+     * Executes a handler function within the provided transaction. If no transaction is provided,
+     * it starts a new transaction, executes the handler, and commits or rolls back based on the outcome.
+     * @template R The return type of the handler.
+     * @param existingTransaction The transaction to use (optional). Creates a new one otherwise.
+     * @param handler The function to execute within the transaction.
+     * @returns A promise that resolves to the result of the handler function.
+     */
+    useTransaction<R>(existingTransaction: Transaction | undefined, handler: TransactionHandler<R>): Promise<R>;
+    /**
+     * Starts a new transaction, executes the provided handler function within it,
+     * and automatically commits the transaction if the handler succeeds or rolls it back if it throws an error.
+     * @template R The return type of the handler.
+     * @param handler The function to execute within the transaction.
+     * @param config Optional transaction configuration.
+     * @returns A promise that resolves to the result of the handler function.
+     */
+    transaction<R>(handler: TransactionHandler<R>, config?: TransactionInitOptions): Promise<R>;
+    protected getTransactionalContextData(): ContextData;
+}
+export declare function tryGetTransactionalContextData<T>(_instance?: Transactional<T>): T | undefined;
+export declare function getTransactionalContextData<T>(_instance?: Transactional<T>): T;

package/orm/server/types.d.ts

@@ -0,0 +1,47 @@
+import type { BuildColumns, NotNull } from 'drizzle-orm';
+import type { PgColumnBuilder, PgTableWithColumns } from 'drizzle-orm/pg-core';
+import type { CamelCase, ConditionalPick, SnakeCase } from 'type-fest';
+import type { JsonPath } from '../../json-path/json-path.js';
+import type { Record } from '../../schema/index.js';
+import type { UnionToIntersection } from '../../types.js';
+import type { Tagged } from '../../types/index.js';
+import type { OrmColumnReflectionData } from '../decorators.js';
+import type { EntityType } from '../entity.js';
+import type { ColumnBuilder, EmbeddedConfigTag } from '../types.js';
+export type BuildTypeOptions = {
+    skipPrimaryKey?: boolean;
+};
+export type ColumnDefinition = {
+    name: string;
+    objectPath: JsonPath;
+    reflectionData: OrmColumnReflectionData | undefined;
+    buildType: (options: BuildTypeOptions) => PgColumnBuilder<any, any, any, any>;
+    dereferenceObjectPath: (obj: Record) => any;
+    toDatabase: (value: unknown, context: TransformContext) => any;
+    fromDatabase: (value: unknown, context: TransformContext) => any;
+};
+export type ColumnDefinitionsMap = Map<string, ColumnDefinition>;
+export type TransformContext = {
+    encryptionKey?: CryptoKey;
+};
+type Column<Name extends string, T> = null extends T ? ColumnBuilder<Exclude<T, null>, Name> : NotNull<ColumnBuilder<T, Name>>;
+export type ColumnPrefix<T> = T extends Tagged<unknown, EmbeddedConfigTag, {
+    prefix: infer Prefix;
+}> ? Prefix extends string ? Prefix : '' : '';
+export type PgTableFromType<T extends EntityType = EntityType, S extends string = string, TableName extends string = T extends Required<EntityType> ? SnakeCase<T['entityName']> : string> = PgTableWithColumns<{
+    name: TableName;
+    schema: S;
+    columns: BuildColumns<TableName, {
+        [P in Exclude<keyof InstanceType<T>, keyof EmbeddedProperties<InstanceType<T>>>]: Column<CamelCase<Extract<P, string>>, InstanceType<T>[P]>;
+    } & UnionToIntersection<{
+        [P in keyof EmbeddedProperties<InstanceType<T>>]: EmbeddedColumns<InstanceType<T>[P], ColumnPrefix<InstanceType<T>[P]>>;
+    }[keyof EmbeddedProperties<InstanceType<T>>]>, 'pg'>;
+    dialect: 'pg';
+}>;
+export type EmbeddedProperties<T> = ConditionalPick<T, Tagged<unknown, EmbeddedConfigTag, {
+    prefix: any;
+}>>;
+export type EmbeddedColumns<T, Prefix extends string> = {
+    [P in keyof T as CamelCase<`${Prefix}${Extract<P, string>}`>]: Column<CamelCase<`${Prefix}${Extract<P, string>}`>, T[P]>;
+};
+export {};

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.125",
   "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>;
+}