@tstdl/base 0.92.123 → 0.92.124

package/types/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/types/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/types/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/types/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/types/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/types/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/types/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/types/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/types/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/types/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;

package/types/reflection/registry.d.ts

@@ -0,0 +1,61 @@
+import type { AbstractConstructor } from '../../types.js';
+import { ContextDataMap } from '../data-structures/context-data-map.js';
+import type { DecoratorData } from './types.js';
+export type ReflectionMetadata = TypeMetadata | PropertyMetadata | MethodMetadata | ConstructorParameterMetadata | MethodParameterMetadata;
+export type MetadataType = 'type' | 'property' | 'method' | 'method-parameter' | 'constructor-parameter';
+export type MetadataBase<T extends MetadataType> = {
+    metadataType: T;
+};
+export type TypeMetadata = MetadataBase<'type'> & {
+    readonly constructor: AbstractConstructor;
+    readonly parent: AbstractConstructor | null;
+    /** Undefined if class has no constructor */
+    readonly parameters: ConstructorParameterMetadata[] | undefined;
+    readonly properties: ReadonlyMap<string | symbol, PropertyMetadata>;
+    readonly staticProperties: ReadonlyMap<string | symbol, PropertyMetadata>;
+    readonly methods: ReadonlyMap<string | symbol, MethodMetadata>;
+    readonly staticMethods: ReadonlyMap<string | symbol, MethodMetadata>;
+    readonly data: ContextDataMap;
+};
+export type PropertyMetadata = MetadataBase<'property'> & {
+    key: string | symbol;
+    type: AbstractConstructor;
+    isAccessor: boolean;
+    data: ContextDataMap;
+    inherited: boolean;
+};
+export type MethodMetadata = MetadataBase<'method'> & {
+    parameters: MethodParameterMetadata[];
+    returnType: AbstractConstructor | undefined;
+    data: ContextDataMap;
+    inherited: boolean;
+};
+export type ConstructorParameterMetadata = MetadataBase<'constructor-parameter'> & {
+    type: AbstractConstructor | undefined;
+    index: number;
+    data: ContextDataMap;
+};
+export type MethodParameterMetadata = MetadataBase<'method-parameter'> & {
+    type: AbstractConstructor;
+    index: number;
+    data: ContextDataMap;
+};
+export type ParameterMetadata = ConstructorParameterMetadata | MethodParameterMetadata;
+export declare class ReflectionRegistry {
+    #private;
+    private readonly metadataMap;
+    private readonly finalizedTypesSet;
+    constructor();
+    hasType(type: AbstractConstructor): boolean;
+    getMetadata(type: AbstractConstructor): TypeMetadata | undefined;
+    register(target: object, propertyKey?: string | symbol, descriptorOrParameterIndex?: PropertyDescriptor | number): DecoratorData;
+    registerDecoratorData(data: DecoratorData): ReflectionMetadata;
+    /**
+     * Unregister a type. Can be useful if you replace a class with an decorator.
+     * However, this should not be necessary since WeakRefs are used.
+     * @param type Type to unregister
+     */
+    unregister(type: AbstractConstructor): void;
+    getOrInitializeMetadata(type: AbstractConstructor): TypeMetadata;
+}
+export declare const reflectionRegistry: ReflectionRegistry;

package/types/reflection/types.d.ts

@@ -0,0 +1,90 @@
+import type { AbstractConstructor, Constructor, ConstructorParameterDecorator, Record } from '../../types.js';
+import type { UnionToIntersection } from 'type-fest';
+import type { ConstructorParameterMetadata, MethodMetadata, MethodParameterMetadata, ParameterMetadata, PropertyMetadata, TypeMetadata } from './registry.js';
+export type DecoratorType = 'class' | 'property' | 'accessor' | 'method' | 'parameter' | 'methodParameter' | 'constructorParameter';
+export type DecoratorHandler<T extends DecoratorType = DecoratorType> = (data: DecoratorData<T>, metadata: DecoratorMetadata<T>, originalArguments: Parameters<DecoratorUnion<T>>) => DecoratorHandlerReturnType<T>;
+export type DecoratorHandlerReturnType<T extends DecoratorType = DecoratorType> = DecoratorOptionsTypeMap<DecoratorHandlerReturnTypeMap, T>;
+export type Decorator<T extends DecoratorType = DecoratorType> = DecoratorOptionsTypeMapIntersection<DecoratorMap, T>;
+export type DecoratorUnion<T extends DecoratorType = DecoratorType> = DecoratorOptionsTypeMap<DecoratorMap, T>;
+export type DecoratorData<T extends DecoratorType = DecoratorType> = DecoratorOptionsTypeMap<DecoratorDataMap, T>;
+export type DecoratorMetadata<T extends DecoratorType = DecoratorType> = DecoratorOptionsTypeMap<DecoratorMetadataMap, T>;
+export type CombinedDecoratorParameters = [target: object, propertyKey?: string | symbol, descriptorOrParameterIndex?: PropertyDescriptor | number];
+export type DecoratorTypeMap<T extends Record<DecoratorType> = Record<DecoratorType>> = T;
+export type DecoratorOptionsTypeMap<T extends DecoratorTypeMap, U extends DecoratorType> = {
+    [D in U]: T[D];
+}[U];
+export type DecoratorOptionsTypeMapIntersection<T extends DecoratorTypeMap, U extends DecoratorType> = UnionToIntersection<DecoratorOptionsTypeMap<T, U>>;
+export type DecoratorDataMap = DecoratorTypeMap<{
+    class: ClassDecoratorData;
+    property: PropertyDecoratorData;
+    accessor: AccessorDecoratorData;
+    method: MethodDecoratorData;
+    parameter: ParameterDecoratorData;
+    methodParameter: MethodParameterDecoratorData;
+    constructorParameter: ConstructorParameterDecoratorData;
+}>;
+export type DecoratorMetadataMap = DecoratorTypeMap<{
+    class: TypeMetadata;
+    property: PropertyMetadata;
+    accessor: PropertyMetadata;
+    method: MethodMetadata;
+    parameter: ParameterMetadata;
+    methodParameter: MethodParameterMetadata;
+    constructorParameter: ConstructorParameterMetadata;
+}>;
+export type DecoratorHandlerReturnTypeMap = DecoratorTypeMap<{
+    class: void | undefined | Constructor;
+    property: void;
+    accessor: void | undefined | TypedPropertyDescriptor<any>;
+    method: void | undefined | PropertyDescriptor;
+    parameter: void;
+    methodParameter: void;
+    constructorParameter: void;
+}>;
+export type DecoratorMap = DecoratorTypeMap<{
+    class: ClassDecorator;
+    property: PropertyDecorator;
+    accessor: MethodDecorator;
+    method: MethodDecorator;
+    parameter: ParameterDecorator & ConstructorParameterDecorator;
+    methodParameter: ParameterDecorator;
+    constructorParameter: ConstructorParameterDecorator;
+}>;
+export type DecoratorDataBase<Type extends string> = {
+    type: Type;
+    constructor: AbstractConstructor;
+    prototype: object;
+};
+export type ClassDecoratorData = DecoratorDataBase<'class'>;
+export type PropertyDecoratorData = DecoratorDataBase<'property'> & {
+    static: boolean;
+    propertyKey: string | symbol;
+};
+export type AccessorDecoratorData = DecoratorDataBase<'accessor'> & {
+    static: boolean;
+    propertyKey: string | symbol;
+    descriptor: PropertyDescriptor;
+};
+export type PropertyOrAccessorDecoratorData = PropertyDecoratorData | AccessorDecoratorData;
+export type MethodDecoratorData = DecoratorDataBase<'method'> & {
+    static: boolean;
+    methodKey: string | symbol;
+    descriptor: PropertyDescriptor;
+};
+export type MethodParameterDecoratorData = DecoratorDataBase<'method-parameter'> & {
+    static: boolean;
+    methodKey: string | symbol;
+    index: number;
+};
+export type ConstructorParameterDecoratorData = DecoratorDataBase<'constructor-parameter'> & {
+    index: number;
+};
+export type ParameterDecoratorData = MethodParameterDecoratorData | ConstructorParameterDecoratorData;
+export type ClassDecoratorHandler = DecoratorHandler<'class'>;
+export type PropertyDecoratorHandler = DecoratorHandler<'property'>;
+export type AccessorDecoratorHandler = DecoratorHandler<'accessor'>;
+export type PropertyOrAccessorDecoratorHandler = DecoratorHandler<'property' | 'accessor'>;
+export type MethodDecoratorHandler = DecoratorHandler<'method'>;
+export type ParameterDecoratorHandler = DecoratorHandler<'parameter'>;
+export type ConstructorParameterDecoratorHandler = DecoratorHandler<'constructorParameter'>;
+export type MethodParameterDecoratorHandler = DecoratorHandler<'methodParameter'>;

package/types/reflection/utils.d.ts

@@ -0,0 +1,33 @@
+import type { AbstractConstructor, Constructor, ConstructorParameterDecorator, OneOrMany, PropertiesOfType, Record, TypedOmit } from '../../types.js';
+import type { CombinedDecoratorParameters, Decorator, DecoratorData, DecoratorHandler, DecoratorMetadata, DecoratorType, DecoratorUnion } from './types.js';
+export type CreateDecoratorTypeOptions = Partial<Record<DecoratorType, boolean>>;
+export type CreateDecoratorOptions = {
+    data?: Record<string | symbol>;
+    /** Merge data values instead of replacing them (requires them to be objects, arrays, maps or sets) */
+    mergeData?: boolean;
+    /** Return values of these decorators are not used */
+    include?: OneOrMany<DecoratorUnion>;
+};
+export type SpecificCreateDecoratorOptions<T extends DecoratorType> = TypedOmit<CreateDecoratorOptions, 'include'> & {
+    handler?: DecoratorHandler<T>;
+    include?: OneOrMany<DecoratorUnion<T>>;
+};
+export type WrapDecoratorOptions = CreateDecoratorOptions & {
+    handler?: (data: DecoratorData, metadata: DecoratorMetadata, originalArguments: CombinedDecoratorParameters) => void;
+};
+type CreateDecoratorType<T extends CreateDecoratorOptions> = Extract<PropertiesOfType<T, true>, DecoratorType>;
+export declare function createDecorator<T extends CreateDecoratorTypeOptions & CreateDecoratorOptions>(options: T, handler?: DecoratorHandler<CreateDecoratorType<T>>): Decorator<CreateDecoratorType<T>>;
+export declare function createClassDecorator(options?: SpecificCreateDecoratorOptions<'class'>): ClassDecorator;
+export declare function createPropertyDecorator(options?: SpecificCreateDecoratorOptions<'property'>): PropertyDecorator;
+export declare function createAccessorDecorator(options?: SpecificCreateDecoratorOptions<'accessor'>): MethodDecorator;
+export declare function createPropertyOrAccessorDecorator(options?: SpecificCreateDecoratorOptions<'property' | 'accessor'>): Decorator<'property' | 'accessor'>;
+export declare function createMethodDecorator(options?: SpecificCreateDecoratorOptions<'method'>): MethodDecorator;
+export declare function createMethodParameterDecorator(options?: SpecificCreateDecoratorOptions<'methodParameter'>): ParameterDecorator;
+export declare function createConstructorParameterDecorator(options?: SpecificCreateDecoratorOptions<'constructorParameter'>): ConstructorParameterDecorator;
+export declare function createParameterDecorator(options?: SpecificCreateDecoratorOptions<'parameter'>): ParameterDecorator & ConstructorParameterDecorator;
+export declare function wrapDecoratorFactory<T extends (...args: any[]) => DecoratorUnion>(decoratorFactory: T, options?: WrapDecoratorOptions): T;
+export declare function wrapDecorator<T extends DecoratorUnion>(decorator: T, options?: WrapDecoratorOptions): T;
+export declare function getConstructor<T extends AbstractConstructor = AbstractConstructor>(constructorOrTarget: object): T;
+export declare function getTypeInfoString(type: AbstractConstructor): string;
+export declare function printType(type: Constructor): void;
+export {};

package/types/rpc/model.d.ts

@@ -0,0 +1,64 @@
+import type { SerializationOptions } from '../../serializer/types.js';
+import type { Constructor, Record } from '../../types.js';
+export type RpcConstructor<T extends Constructor> = T extends Constructor<any, infer R> ? Constructor<Promise<RpcRemote<InstanceType<T>>>, R> : never;
+export type RpcFunction<T extends (...args: any) => any> = T extends (...args: infer Args) => infer R ? (...args: Args) => Promise<Awaited<R>> : never;
+export type RpcObject<T extends Record> = {
+    [P in keyof T]: T[P] extends (...args: any) => any ? RpcFunction<T[P]> : Promise<Awaited<T[P]>>;
+};
+export type RpcRemoteInput = ((...args: any) => any) | Record;
+export type RpcRemote<T extends RpcRemoteInput = RpcRemoteInput> = T extends Constructor ? RpcConstructor<T> : T extends (...args: any) => any ? RpcFunction<T> : RpcObject<T>;
+export type RpcMessageBase<Type extends string = string> = {
+    type: Type;
+};
+export type RpcConnectMessage = RpcMessageBase<'connect'> & {
+    name: string;
+};
+export type RpcControlRequestMessage = RpcConnectMessage;
+export type RpcProxyApplyMessage = RpcMessageBase<'apply'> & {
+    path: PropertyKey[];
+    args: RpcValue[];
+};
+export type RpcProxyConstructMessage = RpcMessageBase<'construct'> & {
+    path: PropertyKey[];
+    args: RpcValue[];
+};
+export type RpcProxyGetMessage = RpcMessageBase<'get'> & {
+    path: PropertyKey[];
+};
+export type RpcProxySetMessage = RpcMessageBase<'set'> & {
+    path: PropertyKey[];
+    value: RpcValue;
+};
+export type RpcProxyRequestMessage = RpcProxyApplyMessage | RpcProxyConstructMessage | RpcProxyGetMessage | RpcProxySetMessage;
+export type RpcMessageRawValue = {
+    type: 'raw';
+    value: any;
+};
+export type RpcMessageSerializedValue = {
+    type: 'serialized';
+    value: any;
+    options?: SerializationOptions;
+};
+export type RpcMessageProxyValue = {
+    type: 'proxy';
+    channel: string;
+};
+export type RpcMessageAdapterValue = {
+    type: 'adapter';
+    adapter: string;
+    channel: string;
+    data: any;
+};
+export type RpcMessageThrowValue = {
+    type: 'throw';
+    error: unknown;
+};
+export type RpcValue = RpcMessageRawValue | RpcMessageSerializedValue | RpcMessageProxyValue | RpcMessageAdapterValue | RpcMessageThrowValue;
+export type RpcPostMessageArrayData = {
+    value: RpcValue[];
+    transfer?: any[];
+};
+export type RpcPostMessageData = {
+    value: RpcValue;
+    transfer?: any[];
+};

package/types/rpc/rpc.adapter.d.ts

@@ -0,0 +1,19 @@
+import type { NonPrimitive } from '../../serializer/types.js';
+import type { RpcChannel } from './rpc.endpoint.js';
+export type AdaptSourceResult<Data> = Data extends void ? (void | {
+    data?: undefined;
+    transfer?: any[];
+}) : {
+    data: Data;
+    transfer?: any[];
+};
+export type RpcAdapterNonPrimitive = NonPrimitive<string, RpcAdapterNonPrimitiveData>;
+export type RpcAdapterNonPrimitiveData = {
+    channel: string;
+    data: any;
+};
+export interface RpcAdapter<T extends object = any, Data = any, ChannelData = any, Req = any, Res = any> {
+    name: string;
+    adaptSource(value: T, channel: RpcChannel<ChannelData, Req, Res>): AdaptSourceResult<Data>;
+    adaptTarget(data: Data, channel: RpcChannel<ChannelData, Req, Res>): T;
+}

package/types/rpc/rpc.d.ts

@@ -0,0 +1,21 @@
+import { type SerializationOptions } from '../../serializer/index.js';
+import type { RpcRemote, RpcRemoteInput } from './model.js';
+import type { RpcAdapter } from './rpc.adapter.js';
+import type { RpcEndpoint } from './rpc.endpoint.js';
+export declare const Rpc: {
+    listen(endpoint: RpcEndpoint): void;
+    connect<T extends RpcRemoteInput>(endpoint: RpcEndpoint, name?: string): Promise<RpcRemote<T>>;
+    expose(object: RpcRemoteInput, name?: string): void;
+    registerAdapter<T extends object, Data>(adapter: RpcAdapter<T, Data>): void;
+    /**
+     * mark object for proxy forward
+     * @param object object to forward as proxy
+     * @param root if object is a child of the actual passed value (to function calls, returns or whatever), this must be set to to mark the parent for serialization (required for children proxies)
+     * @returns
+     */
+    proxy<T extends object>(object: T, root?: object): T;
+    transfer<T extends object>(object: T, transfer: any[]): T;
+    serialize<T extends object>(object: T, options?: SerializationOptions): T;
+    adapt<T extends object>(object: T, adapter: RpcAdapter<T>, root?: object): T;
+    isProxied(object: object): boolean;
+};

package/types/rpc/rpc.error.d.ts

@@ -0,0 +1,8 @@
+import { CustomError } from '../../errors/custom.error.js';
+export declare class RpcError extends CustomError {
+    static readonly errorName = "RpcError";
+    constructor(message: string, cause?: any);
+}
+export declare class RpcRemoteError extends CustomError {
+    constructor(error: unknown);
+}

package/types/rxjs-utils/retry-backoff.d.ts

@@ -0,0 +1,4 @@
+import { type BackoffOptions } from '../../utils/backoff.js';
+import { type MonoTypeOperatorFunction, type ObservableInput } from 'rxjs';
+export declare function retryBackoff<T>(count: number, options: BackoffOptions): MonoTypeOperatorFunction<T>;
+export declare function retryBackoffHandled<T>(count: number, options: BackoffOptions, handler: (error: Error, count: number) => void | undefined | ObservableInput<void>): MonoTypeOperatorFunction<T>;

package/types/schema/converters/openapi-converter.d.ts

@@ -0,0 +1,3 @@
+import type { UndefinableJsonObject } from '../../../types.js';
+import type { SchemaTestable } from '../schema.js';
+export declare function convertToOpenApiSchema(testable: SchemaTestable): UndefinableJsonObject;

package/types/schema/decorators/class.d.ts

@@ -0,0 +1,3 @@
+import { type Decorator } from '../../../reflection/index.js';
+import type { SchemaTypeReflectionData } from './types.js';
+export declare function Class(options?: SchemaTypeReflectionData): Decorator<'class'>;

package/types/schema/decorators/description.d.ts

@@ -0,0 +1,3 @@
+import { type Decorator } from '../../../reflection/index.js';
+import type { SchemaTypeReflectionData } from './types.js';
+export declare function Description(options?: SchemaTypeReflectionData): Decorator<'class' | 'property'>;

package/types/schema/decorators/schema.d.ts

@@ -0,0 +1,21 @@
+import type { SetRequired } from 'type-fest';
+import { type Decorator } from '../../../reflection/index.js';
+import type { TypedOmit } from '../../../types.js';
+import type { SchemaTestable } from '../schema.js';
+import type { CombinedSchemaDecorator, SchemaReflectionData, SchemaTestableProvider } from './types.js';
+export type SchemaDecoratorOptions = SchemaReflectionData;
+export type SchemaDecoratorOptionsWithRequiredSchema = SetRequired<SchemaReflectionData, 'schema'>;
+export type SchemaDecoratorOptionsWithoutSchema = TypedOmit<SchemaReflectionData, 'schema'>;
+export declare function createSchemaDecorator(data?: SchemaReflectionData): CombinedSchemaDecorator;
+export declare function SchemaDecorator(schema: SchemaTestable, options?: SchemaDecoratorOptionsWithoutSchema): CombinedSchemaDecorator;
+export declare function SchemaDecorator(options: SchemaDecoratorOptionsWithRequiredSchema): CombinedSchemaDecorator;
+export declare function Parameter(name: string, schema: SchemaTestable, options?: SchemaDecoratorOptionsWithoutSchema): Decorator<'parameter'>;
+export declare function Parameter(name: string, options: SchemaDecoratorOptions): Decorator<'parameter'>;
+export declare const Property: typeof SchemaDecorator;
+/**
+ * @deprecated use @Property instead
+ * @param schemaTestableProvider
+ * @param options
+ * @returns
+ */
+export declare function PropertySchema(schemaTestableProvider: SchemaTestableProvider, options?: SchemaDecoratorOptionsWithoutSchema): CombinedSchemaDecorator;

package/types/schema/decorators/types.d.ts

@@ -0,0 +1,24 @@
+import type { Decorator } from '../../../reflection/types.js';
+import type { SchemaOptions, SchemaTestable } from '../schema.js';
+import type { ObjectSchemaFactory, ObjectSchemaOptions } from '../schemas/object.js';
+export type SchemaClassDecorator = Decorator<'class'>;
+export type SchemaPropertyDecorator = Decorator<'property' | 'accessor'>;
+export type SchemaMethodDecorator = Decorator<'method'>;
+export type CombinedSchemaDecorator = Decorator<'property' | 'accessor' | 'parameter'>;
+export type SchemaTypeReflectionData = Partial<Pick<ObjectSchemaOptions, 'mask' | 'unknownProperties' | 'unknownPropertiesKey' | 'description' | 'example'>> & {
+    schema?: SchemaTestable;
+    factory?: ObjectSchemaFactory<any>;
+};
+export type SchemaTestableProvider = (data: SchemaReflectionData) => SchemaTestable;
+export type SchemaReflectionData = Partial<Pick<SchemaOptions<any>, 'description' | 'example'>> & {
+    schema?: SchemaTestableProvider;
+    array?: boolean;
+    optional?: boolean;
+    nullable?: boolean;
+    method?: {
+        returnType?: SchemaTestableProvider;
+    };
+    parameter?: {
+        name?: string;
+    };
+};

package/types/schema/decorators/utils.d.ts

@@ -0,0 +1,7 @@
+import type { AbstractConstructor } from '../../../types.js';
+import type { SchemaTestable } from '../schema.js';
+import type { SchemaReflectionData } from './types.js';
+export declare function schemaReflectionDataToSchema(reflectionData: SchemaReflectionData | undefined, fallbackType: AbstractConstructor | null, source: {
+    type: AbstractConstructor;
+    key: string | symbol;
+}): SchemaTestable;