@tstdl/base 0.92.124 → 0.92.125

package/http/utils.d.ts

@@ -0,0 +1,18 @@
+import type { HttpHeaders } from '../http/http-headers.js';
+import type { UndefinableJson } from '../types.js';
+import type { AnyIterable } from '../utils/any-iterable-iterator.js';
+type Body = Uint8Array | Blob | AnyIterable<Uint8Array> | ReadableStream<Uint8Array>;
+export type ReadBodyOptions = {
+    maxBytes?: number;
+};
+export type ReadBodyAsJsonOptions = ReadBodyOptions & {
+    fallbackToText?: boolean;
+};
+export declare function readBodyAsBinaryStream(body: Body, headers: HttpHeaders, options?: ReadBodyOptions): ReadableStream<Uint8Array>;
+export declare function readBodyAsBuffer(body: Body, headers: HttpHeaders, options?: ReadBodyOptions): Promise<Uint8Array>;
+export declare function readBodyAsText(body: Body, headers: HttpHeaders, options?: ReadBodyOptions): Promise<string>;
+export declare function readBodyAsTextStream(body: Body, headers: HttpHeaders, options?: ReadBodyOptions): ReadableStream<string>;
+export declare function readBodyAsJson(body: Body, headers: HttpHeaders, options?: ReadBodyAsJsonOptions): Promise<UndefinableJson>;
+export declare function readBody(body: Body, headers: HttpHeaders, options?: ReadBodyOptions): Promise<string | UndefinableJson | Uint8Array>;
+export declare function readBodyAsStream(body: Body, headers: HttpHeaders, options?: ReadBodyOptions): ReadableStream<string> | ReadableStream<Uint8Array>;
+export {};

package/image-service/imgproxy/imgproxy-image-service.d.ts

@@ -0,0 +1,24 @@
+import { resolveArgumentType } from '../../injector/index.js';
+import type { Resolvable } from '../../injector/interfaces.js';
+import type { ImageOptions } from '../image-service.js';
+import { ImageService } from '../image-service.js';
+export type ImgproxyImageServiceConfig = {
+    endpoint: string;
+    key: string;
+    salt: string;
+    signatureSize: number;
+};
+export declare const IMGPROXY_IMAGE_SERVICE_CONFIG: import("../../injector/index.js").InjectionToken<ImgproxyImageServiceConfig, never>;
+export declare class ImgproxyImageService extends ImageService implements Resolvable<ImgproxyImageServiceConfig> {
+    #private;
+    readonly endpoint: string;
+    readonly [resolveArgumentType]: ImgproxyImageServiceConfig;
+    constructor(endpoint: string, key: string, salt: string, signatureSize: number);
+    getUrl(resourceUri: string, options?: ImageOptions): Promise<string>;
+}
+/**
+ * configure imgproxy image service module
+ * @param defaultConfig default configuration
+ * @param register whether to register for {@link ImageService}
+ */
+export declare function configureImgproxyImageService(defaultConfig: ImgproxyImageServiceConfig, register?: boolean): void;

package/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Core of tstdl
+ *
+ * @module Core
+ */
+export * from './core.js';
+export * from './import.js';
+export * from './require.js';

package/injector/decorators.d.ts

@@ -0,0 +1,82 @@
+import { type Decorator } from '../reflection/index.js';
+import type { Constructor, OneOrMany, Record, Simplify, TypedOmit } from '../types.js';
+import type { Provider } from './provider.js';
+import type { InjectionToken } from './token.js';
+import type { InjectMetadata } from './type-info.js';
+import type { ArgumentProvider, ForwardRefInjectionToken, Mapper, RegistrationOptions } from './types.js';
+export type InjectDecorator = Decorator<'accessor' | 'constructorParameter'>;
+export type InjectableOptions<T, A, C extends Record = Record> = RegistrationOptions<T, A, C> & {
+    /** Aliases (tokens) for the class. Useful for example for circular dependencies when you can't use the class itself as a token */
+    alias?: OneOrMany<InjectionToken>;
+    /** Custom provider. Useful for example if initialization is required */
+    provider?: Provider<T, A, C>;
+};
+export type InjectableOptionsWithoutLifecycle<T, A> = Simplify<TypedOmit<InjectableOptions<T, A>, 'lifecycle'>>;
+/**
+ * Helper decorator to replace a class definition with an other
+ * can be used for example to type external classes with the {@link Resolvable} interface
+ * @param constructor class to replace with
+ */
+export declare function ReplaceClass<T>(constructor: Constructor<T>): ClassDecorator;
+/**
+ * Globally registers the class for injection
+ * @param options registration options
+ */
+export declare function Injectable<T = any, A = any, C extends Record = Record>(options?: InjectableOptions<T, A, C>): ClassDecorator;
+/**
+ * Registers the class in the global container with singleton lifecycle. Decorated class is not modified in any way
+ * @param options registration options
+ */
+export declare function Singleton<T = any, A = any>(options?: InjectableOptionsWithoutLifecycle<T, A>): ClassDecorator;
+/**
+ * Registers the class in the global container with scoped lifecycle. Decorated class is not modified in any way
+ * @param options registration options
+ */
+export declare function Scoped<T = any, A = any>(lifecycle: 'resolution' | 'injector', options?: InjectableOptionsWithoutLifecycle<T, A>): ClassDecorator;
+/**
+ * Sets the token used to resolve the parameter
+ * @param token token used for resolving
+ * @param argument resolve argument
+ * @param mapperOrKey map the resolved value. If {@link PropertyKey} is provided, that property of the resolved value will be injected
+ */
+export declare function Inject<T, A>(token?: InjectionToken<T, A>, argument?: A, mapperOrKey?: Mapper<T> | keyof T): InjectDecorator;
+/**
+ * Sets the token used to resolve the parameter. Resolves all providers
+ * @param token token used for resolving
+ * @param argument resolve argument
+ * @param mapperOrKey map the resolved value. If {@link PropertyKey} is provided, that property of the resolved value will be injected
+ */
+export declare function InjectAll<T, A>(token?: InjectionToken<T, A>, argument?: A, mapperOrKey?: Mapper<T> | keyof T): InjectDecorator;
+/**
+ * Sets the argument used for resolving the parameter
+ * @param argument
+ */
+export declare function ResolveArg<T>(argument: T): InjectDecorator;
+/**
+ * Sets the argument provider used for resolving the parameter
+ * @param argumentProvider
+ */
+export declare function ResolveArgProvider<T>(argumentProvider: ArgumentProvider<T>): InjectDecorator;
+/**
+ * Injects the argument used for resolving the class instead of resolving the parameter
+ * @param argument
+ * @param mapperOrKey map the resolved value. If {@link PropertyKey} is provided, that property of the resolved value will be injected
+ */
+export declare function InjectArg<T>(mapperOrKey?: Mapper<T> | keyof T): InjectDecorator;
+/**
+ * Sets the argument used for resolving the decorated parameter to the the argument provided for parent resolve
+ * @param mapper map the argument (for example to select a property instead of forwarding the whole object)
+ */
+export declare function ForwardArg(): InjectDecorator;
+export declare function ForwardArg<T, U>(mapper: Mapper<T, U>): InjectDecorator;
+/**
+ * Marks the argument as optional
+ * @param argument
+ */
+export declare function Optional(): InjectDecorator;
+/**
+ * Resolve using ForwardRef to handle circular dependencies. Resolve logic derefs all ForwardRefs which are direct properties of resolved instances automatically
+ * @param token token to resolve
+ * @param argument resolve argument
+ */
+export declare function ForwardRef<T extends object, A>(token?: ForwardRefInjectionToken<T>, argument?: A, options?: Pick<InjectMetadata, 'forwardRefTypeHint'>): InjectDecorator;

package/injector/injector.d.ts

@@ -0,0 +1,113 @@
+import { type AsyncDisposable } from '../disposable/disposable.js';
+import type { OneOrMany, Record, TypedOmit } from '../types.js';
+import { type InjectOptions } from './inject.js';
+import { type ResolveArgument } from './interfaces.js';
+import { type Provider } from './provider.js';
+import { type InjectionToken } from './token.js';
+import type { RegistrationOptions, ResolveOptions } from './types.js';
+export type ProvidersItem<T = any, A = any, D extends Record = Record> = Provider<T, A, D> & {
+    provide: InjectionToken<T, A>;
+    multi?: boolean;
+};
+export type GlobalRegistration<T = any, A = any> = {
+    token: InjectionToken<T, A>;
+    provider: Provider<T, A>;
+    providers: ProvidersItem[];
+    options: RegistrationOptions<T, A>;
+};
+export type Registration<T = any, A = any> = GlobalRegistration<T, A> & {
+    resolutions: Map<any, T>;
+};
+export type GetRegistrationOptions = {
+    skipSelf?: boolean;
+    onlySelf?: boolean;
+};
+export type ResolveManyArrayItem<T, A> = [token: InjectionToken<T, A>, argument?: ResolveArgument<T, A>, options?: InjectOptions<T, A>];
+export type ResolveManyItem<T, A> = InjectionToken<T, A> | ResolveManyArrayItem<T, A>;
+export type ResolveManyItemReturnType<T extends ResolveManyItem<any, any>> = T extends ResolveManyItem<infer U, any> ? U | (T extends (ResolveManyArrayItem<any, any> & [any, any, {
+    optional: true;
+}]) ? undefined : never) : never;
+export type ResolveManyReturnType<T extends ResolveManyItem<any, any>[]> = {
+    [I in keyof T]: ResolveManyItemReturnType<T[I]>;
+};
+export type AddDisposeHandler = (handler: Disposable | AsyncDisposable | (() => any)) => void;
+export declare class Injector implements AsyncDisposable {
+    #private;
+    readonly name: string;
+    get disposed(): boolean;
+    constructor(name: string, parent?: Injector | null);
+    /**
+     * Globally register a provider for a token
+     * @param token token to register
+     * @param provider provider used to resolve the token
+     * @param options registration options
+     */
+    static register<T, A = any, D extends Record = Record>(token: InjectionToken<T, A>, providers: OneOrMany<Provider<T, A, D>>, options?: RegistrationOptions<T, A, D>): void;
+    /**
+     * Globally register a provider for a token as a singleton. Alias for {@link register} with `singleton` lifecycle
+     * @param token token to register
+     * @param provider provider used to resolve the token
+     * @param options registration options
+     */
+    static registerSingleton<T, A = ResolveArgument<T, any>, C extends Record = Record>(token: InjectionToken<T, A>, providers: OneOrMany<Provider<T, A, C>>, options?: TypedOmit<RegistrationOptions<T, A, C>, 'lifecycle'>): void;
+    dispose(): Promise<void>;
+    [Symbol.asyncDispose](): Promise<void>;
+    fork(name: string): Injector;
+    /**
+     * Register a provider for a token
+     * @param token token to register
+     * @param provider provider used to resolve the token
+     * @param options registration options
+     */
+    register<T, A = any, C extends Record = Record>(token: InjectionToken<T, A>, providers: OneOrMany<Provider<T, A, C>>, options?: RegistrationOptions<T, A, C>): void;
+    /**
+     * Register a provider for a token as a singleton. Alias for {@link register} with `singleton` lifecycle
+     * @param token token to register
+     * @param provider provider used to resolve the token
+     * @param options registration options
+     */
+    registerSingleton<T, A = any, C extends Record = Record>(token: InjectionToken<T, A>, providers: OneOrMany<Provider<T, A, C>>, options?: TypedOmit<RegistrationOptions<T, A, C>, 'lifecycle'>): void;
+    /**
+     * Check if token has a registered provider
+     * @param token token check
+     */
+    hasRegistration(token: InjectionToken, options?: GetRegistrationOptions): boolean;
+    /**
+     * Try to get registration
+     * @param token token to get registration for
+     */
+    tryGetRegistration<T, A>(token: InjectionToken<T, A>, options?: GetRegistrationOptions): Registration<T, A> | Registration<T, A>[] | undefined;
+    /**
+     * Get registration
+     * @param token token to get registration for
+     */
+    getRegistration<T, A>(token: InjectionToken<T, A>, options?: GetRegistrationOptions): Registration<T, A> | Registration<T, A>[];
+    resolve<T, A>(token: InjectionToken<T, A>, argument: ResolveArgument<T, A>, options: ResolveOptions<T, A> & {
+        optional: true;
+    }): T | undefined;
+    resolve<T, A>(token: InjectionToken<T, A>, argument?: ResolveArgument<T, A>, options?: ResolveOptions<T, A>): T;
+    resolveAll<T, A>(token: InjectionToken<T, A>, argument?: ResolveArgument<T, A>, options?: ResolveOptions<T, A>): T[];
+    resolveMany<T extends ResolveManyItem<any, any>[]>(...tokens: T): ResolveManyReturnType<T>;
+    resolveAsync<T, A>(token: InjectionToken<T, A>, argument: ResolveArgument<T, A>, options: ResolveOptions<T, A> & {
+        optional: true;
+    }): Promise<T | undefined>;
+    resolveAsync<T, A>(token: InjectionToken<T, A>, argument?: ResolveArgument<T, A>, options?: ResolveOptions<T, A>): Promise<T>;
+    resolveAllAsync<T, A>(token: InjectionToken<T, A>, argument?: ResolveArgument<T, A>, options?: ResolveOptions<T, A>): Promise<T[]>;
+    resolveManyAsync<T extends ResolveManyItem<any, any>[]>(...tokens: T): Promise<ResolveManyReturnType<T>>;
+    private _resolve;
+    private _resolveAll;
+    private _resolveRegistration;
+    private _resolveProvider;
+    private resolveClassInjection;
+    private resolveInjection;
+    private resolveInjectionAsync;
+    private resolveInjectionAll;
+    private resolveInjectionAllAsync;
+    private getResolveContext;
+    private getAfterResolveContext;
+    private getInjectionContext;
+    private assertNotDisposed;
+}
+export declare function provide<T = any, A = any, D extends Record = Record>(token: InjectionToken<T, A>, provider: Provider<T, A, D> & {
+    multi?: boolean;
+}): ProvidersItem<T, A, D>;

package/injector/interfaces.d.ts

@@ -0,0 +1,17 @@
+import type { Record, Type } from '../types.js';
+import type { ArgumentedInjectionToken, InjectionTokenArgument, ReifyingInjectionToken } from './token.js';
+import type { AfterResolveContext } from './types.js';
+export declare const resolveArgumentType: unique symbol;
+export declare const afterResolve: unique symbol;
+export type ResolveArgumentType = typeof resolveArgumentType;
+export type ResolveArgument<T, Fallback = undefined> = undefined | (T extends Resolvable<infer U> ? (U | undefined) : T extends Type<Resolvable<infer U>> ? (U | undefined) : T extends (ArgumentedInjectionToken<any, any> | ReifyingInjectionToken) ? InjectionTokenArgument<T> : Fallback);
+export interface Resolvable<A = unknown, D extends Record = Record> extends Partial<AfterResolve<A, D>> {
+    /**
+     * Type of resolve argument
+     * @deprecated only used for type inference
+     */
+    readonly [resolveArgumentType]?: A;
+}
+export interface AfterResolve<A = unknown, D extends Record = Record> {
+    [afterResolve](argument: NoInfer<A>, context: AfterResolveContext<NoInfer<D>>): void | Promise<void>;
+}

package/injector/provider.d.ts

@@ -0,0 +1,57 @@
+import type { Constructor, Record, TypedOmit } from '../types.js';
+import type { ResolveArgument } from './interfaces.js';
+import type { InjectionToken } from './token.js';
+import type { AfterResolveContext, ResolveContext } from './types.js';
+export type Factory<T, A = any, D extends Record = Record> = (argument: ResolveArgument<T, A>, context: ResolveContext<D>) => T;
+export type ProviderWithArgument<T, A> = {
+    defaultArgument?: ResolveArgument<T, A>;
+    defaultArgumentProvider?: () => ResolveArgument<T, A>;
+};
+export type ProviderWithInitializer<T, A, D extends Record> = {
+    afterResolve?: (value: T, argument: A, context: AfterResolveContext<D>) => void | Promise<void>;
+};
+export type Provider<T = any, A = any, D extends Record = Record> = ClassProvider<T, A, D> | ValueProvider<T> | TokenProvider<T, A, D> | FactoryProvider<T, A, D>;
+export type ClassProvider<T = any, A = any, D extends Record = Record> = ProviderWithArgument<T, A> & ProviderWithInitializer<T, A, D> & {
+    useClass: Constructor<T>;
+};
+export type ValueProvider<T = any> = {
+    useValue: T;
+};
+export type TokenProvider<T = any, A = any, D extends Record = Record> = ProviderWithArgument<T, A> & ProviderWithInitializer<T, A, D> & ({
+    useToken: InjectionToken<T, A>;
+    useTokenProvider?: undefined;
+    resolveAll?: false;
+} | {
+    useToken?: undefined;
+    useTokenProvider: () => InjectionToken<T, A>;
+    resolveAll?: false;
+} | {
+    useToken: InjectionToken<T extends (infer U)[] ? U : T, A>;
+    useTokenProvider?: undefined;
+    resolveAll: true;
+} | {
+    useToken?: undefined;
+    useTokenProvider: () => InjectionToken<T extends (infer U)[] ? U : T, A>;
+    resolveAll: true;
+});
+export type FactoryProvider<T = any, A = unknown, D extends Record = Record> = ProviderWithArgument<T, A> & ProviderWithInitializer<T, A, D> & {
+    useFactory: Factory<T, A, D>;
+};
+export declare function classProvider<T, A, D extends Record>(constructor: Constructor<T>, options?: TypedOmit<ClassProvider<T, A, D>, 'useClass'>): ClassProvider<T, A, D>;
+export declare function valueProvider<T>(value: T, options?: TypedOmit<ValueProvider<T>, 'useValue'>): ValueProvider<T>;
+export declare function tokenProvider<T, A, D extends Record>(token: InjectionToken<T, A>, options: TypedOmit<TokenProvider<T, A, D>, 'useToken' | 'useTokenProvider'> & {
+    resolveAll: true;
+}): TokenProvider<T[]>;
+export declare function tokenProvider<T, A, D extends Record>(token: InjectionToken<T, A>, options?: TypedOmit<TokenProvider<T, A, D>, 'useToken' | 'useTokenProvider'>): TokenProvider<T>;
+export declare function factoryProvider<T, A, D extends Record>(factory: Factory<T, A, D>, options?: TypedOmit<FactoryProvider<T, A, D>, 'useFactory'>): FactoryProvider<T, A, D>;
+export declare function isClassProvider<T, A>(value: Provider<T, A>): value is ClassProvider<T, A>;
+export declare function isClassProvider<T, A>(value: unknown): value is ClassProvider<T, A>;
+export declare function isValueProvider<T>(value: Provider<T>): value is ValueProvider<T>;
+export declare function isValueProvider<T>(value: unknown): value is ValueProvider<T>;
+export declare function isTokenProvider<T, A>(value: Provider<T, A>): value is TokenProvider<T, A>;
+export declare function isTokenProvider<T, A>(value: unknown): value is TokenProvider<T, A>;
+export declare function isFactoryProvider<T, A>(value: Provider<T, A>): value is FactoryProvider<T, A>;
+export declare function isFactoryProvider<T, A>(value: unknown): value is FactoryProvider<T, A>;
+export declare function isProvider<T, A>(value: Provider<T, A>): value is Provider<T, A>;
+export declare function isProvider<T, A>(value: unknown): value is Provider<T, A>;
+export declare function isProviderWithInitializer<T, A, C extends Record>(value: Provider<T, A, C>): value is Extract<Provider<T, A, C>, ProviderWithInitializer<T, A, C>>;

package/injector/resolution.d.ts

@@ -0,0 +1,15 @@
+import type { Record } from '../types.js';
+import type { Resolvable } from './interfaces.js';
+import type { AfterResolveContext } from './types.js';
+export type AfterResolveHandler<A, D extends Record> = (argument: A, context: AfterResolveContext<D>) => void | Promise<void>;
+export type ResolutionContext<A> = {
+    afterResolveRegistrations: AfterResolveHandler<A, any>[];
+};
+declare const assertInResolutionContext: (debugFnOrMessage: import("../types.js").Function | string) => void, getCurrentResolutionContext: {
+    (required: true, debugFn: import("../types.js").Function): ResolutionContext<any>;
+    (required?: false, debugFn?: import("../types.js").Function): ResolutionContext<any> | null;
+    (required: boolean, debugFn: import("../types.js").Function): ResolutionContext<any> | null;
+}, runInResolutionContext: <ReturnT>(context: ResolutionContext<any>, fn: () => ReturnT) => ReturnT;
+export declare function registerAfterResolve(handler: AfterResolveHandler<unknown, Record>): void;
+export declare function registerAfterResolve<A, D extends Record>(_this: Resolvable<A, D>, handler: AfterResolveHandler<A, D>): void;
+export { assertInResolutionContext, getCurrentResolutionContext, runInResolutionContext };

package/injector/resolve-chain.d.ts

@@ -0,0 +1,34 @@
+import type { AbstractConstructor } from '../types.js';
+import type { InjectionToken } from './token.js';
+export type ResolveChainNodeBase<Type extends string> = {
+    type: Type;
+    forwardRef?: true;
+};
+export type ResolveChainNode = ResolveChainNodeBase<'token'> & {
+    token: InjectionToken;
+} | ResolveChainNodeBase<'inject'> & {
+    token: InjectionToken;
+    index: number;
+} | ResolveChainNodeBase<'parameter'> & {
+    constructor: AbstractConstructor;
+    index: number;
+    token: InjectionToken;
+} | ResolveChainNodeBase<'property'> & {
+    constructor: AbstractConstructor;
+    property: PropertyKey;
+    token: InjectionToken;
+};
+export declare class ResolveChain {
+    readonly nodes: readonly ResolveChainNode[];
+    get length(): number;
+    /** @deprecated internal */
+    constructor(nodes: ResolveChainNode[]);
+    static startWith(token: InjectionToken): ResolveChain;
+    addToken(token: InjectionToken): ResolveChain;
+    addInject(token: InjectionToken, index: number): ResolveChain;
+    addParameter(constructor: AbstractConstructor, index: number, token: InjectionToken): ResolveChain;
+    addProperty(constructor: AbstractConstructor, property: PropertyKey, token: InjectionToken): ResolveChain;
+    markAsForwardRef(forwardToken: InjectionToken): ResolveChain;
+    format(truncate?: number): string;
+    truncate(tokenCount: number): ResolveChain;
+}

package/injector/resolve.error.d.ts

@@ -0,0 +1,5 @@
+import { CustomError } from '../errors/custom.error.js';
+import type { ResolveChain } from './resolve-chain.js';
+export declare class ResolveError extends CustomError {
+    constructor(message: string, chain: ResolveChain, cause?: Error);
+}

package/injector/token.d.ts

@@ -0,0 +1,25 @@
+import type { AbstractConstructor } from '../types.js';
+declare const type: unique symbol;
+declare const argument: unique symbol;
+export type SimpleInjectionToken<T> = AbstractConstructor<T>;
+export type ArgumentedInjectionToken<T, A> = SimpleInjectionToken<T> & {
+    [argument]: A;
+};
+export type InjectionToken<T = any, A = any> = SimpleInjectionToken<T> | ArgumentedInjectionToken<T, A> | ReifyingInjectionToken<T, A>;
+export type InjectionTokenArgument<T extends ArgumentedInjectionToken<any, any> | ReifyingInjectionToken> = T[typeof argument];
+export declare class ReifyingInjectionToken<T = any, A = any> {
+    /**
+     * @deprecated for internal typing
+     */
+    readonly [type]: T;
+    /**
+     * @deprecated for internal typing
+     */
+    readonly [argument]: A;
+    readonly description: string;
+    constructor(description: string);
+    toString(): string;
+}
+export declare function injectionToken<T, A = never>(description: string): InjectionToken<T, A>;
+export declare function getTokenName(token: InjectionToken | undefined): string;
+export {};

package/injector/type-info.d.ts

@@ -0,0 +1,22 @@
+import type { ForwardRefTypeHint } from '../utils/object/forward-ref.js';
+import type { InjectionToken } from './token.js';
+import type { ArgumentProvider, ForwardRefInjectionToken, Mapper } from './types.js';
+export type InjectMetadata = {
+    /** Token overwrite by inject decorator */
+    injectToken?: InjectionToken;
+    /** If defined, resolve the token or ForwardRefToken using ForwardRef strategy instead of resolving the token directly */
+    forwardRef?: boolean | ForwardRefInjectionToken;
+    forwardRefTypeHint?: ForwardRefTypeHint;
+    /** Whether injection is optional if token is not registered. Set by optional decorator */
+    optional?: boolean;
+    /** Whether injection should resolve all providers */
+    resolveAll?: boolean;
+    /** Mapper to map resolved value */
+    mapper?: Mapper;
+    /** Provider to get resolve argument */
+    resolveArgumentProvider?: ArgumentProvider;
+    /** If defined, map the resolve argument and use the returned value as the value to inject */
+    injectArgumentMapper?: Mapper;
+    /** If defined, use the provided argument, map it and pass it to the resolution of the token */
+    forwardArgumentMapper?: Mapper;
+};

package/injector/types.d.ts

@@ -0,0 +1,64 @@
+import type { CancellationSignal } from '../cancellation/index.js';
+import type { AsyncDisposeHandler } from '../disposable/async-disposer.js';
+import type { Record } from '../types.js';
+import type { ForwardRefTypeHint } from '../utils/object/forward-ref.js';
+import type { Injector, ProvidersItem } from './injector.js';
+import type { ResolveArgument } from './interfaces.js';
+import type { InjectionToken } from './token.js';
+/**
+ * Transient: new resolution for every resolve
+ * resolution: one resolution per resolve tree
+ * injector: one resolution per injector
+ * singleton: one resolution at injector where token is registered
+ */
+export type Lifecycle = 'transient' | 'resolution' | 'injector' | 'singleton';
+export type ResolveContext<D extends Record> = Pick<Injector, 'resolve' | 'resolveAll'> & {
+    readonly data: ResolveContextData<D>;
+    readonly cancellationSignal: CancellationSignal;
+    addDisposeHandler(handler: AsyncDisposeHandler): void;
+};
+export type AfterResolveContext<D extends Record> = {
+    readonly data: ResolveContextData<D>;
+    readonly cancellationSignal: CancellationSignal;
+    addDisposeHandler(handler: AsyncDisposeHandler): void;
+};
+export type Mapper<T = any, U = unknown> = (value: T) => U;
+export type ArgumentProvider<T = unknown, D extends Record = Record> = (context: ResolveContext<D>) => T;
+export type ForwardRefInjectionToken<T = any, A = any> = Exclude<InjectionToken<T, A>, Function> | (() => InjectionToken<T, A>);
+export type ResolveOptions<T, A> = {
+    optional?: boolean;
+    skipSelf?: boolean;
+    onlySelf?: boolean;
+    /** If defined, resolve the token using ForwardRef strategy instead of resolving the token directly can be used to circumvent circular dependency problems */
+    forwardRef?: boolean | ForwardRefInjectionToken<T, A>;
+    forwardRefTypeHint?: ForwardRefTypeHint;
+};
+/**
+ * Data to store between different stages like resolve and afterResolve
+ */
+export type ResolveContextData<T extends Record> = T;
+export type RegistrationOptions<T, A = unknown, D extends Record = Record> = {
+    lifecycle?: Lifecycle;
+    /** Local providers for inner resolutions */
+    providers?: ProvidersItem[];
+    /** Default resolve argument used when neither token nor explicit resolve argument is provided */
+    defaultArgument?: ResolveArgument<T, A>;
+    /** Default resolve argument used when neither token nor explicit resolve argument is provided */
+    defaultArgumentProvider?: ArgumentProvider<ResolveArgument<T, A>, D>;
+    /**
+     * Value to distinguish scoped and singleton instances based on argument
+     * by default it uses strict equality (===) on the original argument,
+     * so modifications to argument objects and literal objects in the call
+     * may not yield the expected result.
+     *
+     * Hint: {@link JSON.stringify} is a simple solution for many use cases,
+     * but will fail if properties have different order
+     */
+    argumentIdentityProvider?: Mapper<ResolveArgument<T, A>>;
+    /** Function which gets called after a resolve */
+    afterResolve?: (instance: T, argument: ResolveArgument<T, A>, context: AfterResolveContext<D>) => any;
+    /** Whether multiple values can be resolved or not (used with {@link Injector.resolveAll}). If false, previous registrations are removed */
+    multi?: boolean;
+    /** Custom metadata */
+    metadata?: Record;
+};

package/key-value-store/key-value.store.d.ts

@@ -0,0 +1,23 @@
+import { type Resolvable, resolveArgumentType } from '../injector/interfaces.js';
+import type { StringMap } from '../types.js';
+/** Key value store module */
+export type KeyValueStoreArgument = string;
+export declare abstract class KeyValueStore<KV extends StringMap> implements Resolvable<KeyValueStoreArgument> {
+    readonly module: string;
+    readonly [resolveArgumentType]: KeyValueStoreArgument;
+    constructor(module: string);
+    /** Get value of key */
+    abstract get<K extends keyof KV>(key: K): Promise<KV[K] | undefined>;
+    /** Get value of key */
+    abstract get<K extends keyof KV, D>(key: K, defaultValue: D): Promise<KV[K] | D>;
+    /** Set key */
+    abstract set<K extends keyof KV>(key: K, value: KV[K]): Promise<void>;
+    /** Set multiple keys */
+    abstract setMany(keyValues: Partial<KV>): Promise<void>;
+    /** Delete key */
+    abstract delete(key: keyof KV): Promise<boolean>;
+    /** Delete multiple keys */
+    abstract deleteMany(keys: (keyof KV)[]): Promise<void>;
+    /** Delete all keys */
+    abstract clear(): Promise<void>;
+}

package/key-value-store/mongo/module.d.ts

@@ -0,0 +1,8 @@
+import type { MongoRepositoryConfig } from '../../database/mongo/index.js';
+import type { MongoKeyValue } from './mongo-key-value.model.js';
+/**
+ * configure mongo queue module
+ * @param keyValueRepositoryConfig repository configuration for jobs
+ * @param register whether to register for {@link Queue} and {@link QueueProvider}
+ */
+export declare function configureMongoKeyValueStore(keyValueRepositoryConfig: MongoRepositoryConfig<MongoKeyValue>, register?: boolean): void;

package/key-value-store/mongo/mongo-key-value-store.provider.d.ts

@@ -0,0 +1,8 @@
+import type { KeyValueStore, KeyValueStoreProvider } from '../../key-value-store/index.js';
+import type { StringMap } from '../../types.js';
+import { MongoKeyValueRepository } from './mongo-key-value.repository.js';
+export declare class MongoKeyValueStoreProvider implements KeyValueStoreProvider {
+    private readonly keyValueRepository;
+    constructor(keyValueRepository: MongoKeyValueRepository);
+    get<KV extends StringMap>(module: string): KeyValueStore<KV>;
+}

package/key-value-store/mongo/mongo-key-value.model.d.ts

@@ -0,0 +1,7 @@
+import type { Entity } from '../../database/index.js';
+export type MongoKeyValue<T = unknown> = Entity & {
+    module: string;
+    key: string;
+    value: T;
+    updated: number;
+};

package/key-value-store/mongo/mongo-key-value.repository.d.ts

@@ -0,0 +1,10 @@
+import type { CollectionArgument } from '../../database/mongo/index.js';
+import { Collection, MongoEntityRepository } from '../../database/mongo/index.js';
+import { resolveArgumentType } from '../../injector/index.js';
+import type { Resolvable } from '../../injector/interfaces.js';
+import { Logger } from '../../logger/index.js';
+import type { MongoKeyValue } from './mongo-key-value.model.js';
+export declare class MongoKeyValueRepository extends MongoEntityRepository<MongoKeyValue> implements Resolvable<CollectionArgument<MongoKeyValue>> {
+    readonly [resolveArgumentType]: CollectionArgument<MongoKeyValue, MongoKeyValue>;
+    constructor(collection: Collection<MongoKeyValue>, logger: Logger);
+}

package/key-value-store/mongo/mongo-key-value.store.d.ts

@@ -0,0 +1,14 @@
+import { KeyValueStore } from '../../key-value-store/index.js';
+import type { StringMap } from '../../types.js';
+import { MongoKeyValueRepository } from './mongo-key-value.repository.js';
+export declare class MongoKeyValueStore<KV extends StringMap> extends KeyValueStore<KV> {
+    private readonly keyValueRepository;
+    constructor(keyValueRepository: MongoKeyValueRepository, module: string);
+    get<K extends keyof KV>(key: K): Promise<KV[K] | undefined>;
+    get<K extends keyof KV, D>(key: K, defaultValue: D): Promise<D | KV[K]>;
+    set<K extends keyof KV>(key: K, value: KV[K]): Promise<void>;
+    setMany(keyValues: Partial<KV>): Promise<void>;
+    delete(key: keyof KV): Promise<boolean>;
+    deleteMany(keys: (keyof KV)[]): Promise<void>;
+    clear(): Promise<void>;
+}

package/key-value-store/mongo/tokens.d.ts

@@ -0,0 +1,3 @@
+import type { MongoRepositoryConfig } from '../../database/mongo/types.js';
+import type { MongoKeyValue } from './mongo-key-value.model.js';
+export declare const DEFAULT_KEY_VALUE_REPOSITORY_CONFIG: import("../../injector/token.js").InjectionToken<MongoRepositoryConfig<MongoKeyValue>, never>;

package/lock/lock.d.ts

@@ -0,0 +1,48 @@
+import type { Resolvable } from '../injector/index.js';
+import { resolveArgumentType } from '../injector/index.js';
+export type LockedFunction<R> = (controller: LockController) => R | Promise<R>;
+export type AcquireResult<Throw extends boolean> = Throw extends true ? LockController : (LockController | false);
+export type UsingResult<Throw extends boolean, R> = Throw extends true ? ({
+    success: true;
+    result: R;
+}) : ({
+    success: true;
+    result: R;
+} | {
+    success: false;
+    result: undefined;
+});
+export interface LockController {
+    /**
+     * whether the the lock is lost or not. Can happen for example if it couldn't be renewed
+     * because the network connection is lost (depending on implementation)
+     */
+    readonly lost: boolean;
+    /** manually release lock */
+    release(): void | Promise<void>;
+}
+/** resource */
+export type LockArgument = string | {
+    prefix?: string;
+    resource: string;
+};
+export declare abstract class Lock implements Resolvable<LockArgument> {
+    readonly resource: string;
+    readonly [resolveArgumentType]: LockArgument;
+    constructor(resource: string);
+    /**
+     * acquire a lock for the resource, it must be manually released
+     * @param timeout how long to try to get a lock. If undefined it's tries forever
+     * @param throwOnFail throw if resource is locked and we couldn't acquire it in the specified timeout
+     */
+    abstract acquire<Throw extends boolean>(timeout: number | undefined, throwOnFail: Throw): Promise<AcquireResult<Throw>>;
+    /**
+     * acquire a lock for the resource and release it automatically after the provided function has returned or thrown
+     * @param timeout how long to try to get a lock. If undefined it's tries forever
+     * @param throwOnFail throw if resource is locked and we couldn't acquire it in the specified timeout
+     * @param func function to run when lock is acquired
+     */
+    abstract use<Throw extends boolean, R>(timeout: number | undefined, throwOnFail: Throw, func: LockedFunction<R>): Promise<UsingResult<Throw, R>>;
+    /** check if resource is locked */
+    abstract exists(): Promise<boolean>;
+}