awilixify 2.2.1 → 3.0.0

package/dist/lib/di/errors.js

@@ -0,0 +1,148 @@
+export class DuplicateControllersInModuleError extends Error {
+    constructor(moduleName) {
+        super(`Module "${moduleName}" has duplicate controllers in its controllers array.`);
+        this.name = "DuplicateControllersInModuleError";
+    }
+}
+export class ControllerAlreadyRegisteredError extends Error {
+    constructor(controllerName, moduleName) {
+        super(`Controller "${controllerName}" is already registered in module "${moduleName}". ` +
+            `Controllers must be unique across modules. ` +
+            `Exclude controllers from one of the module instances.`);
+        this.name = "ControllerAlreadyRegisteredError";
+    }
+}
+export class DependencyNotFoundError extends Error {
+    constructor(dependencyKey, moduleName) {
+        super(`"${dependencyKey}" does not exist in scope of ${moduleName} module`);
+        this.name = "DependencyNotFoundError";
+    }
+}
+export class CircularDependencyError extends Error {
+    constructor(moduleName, providerKeys) {
+        super(`Circular dependency detected in module "${moduleName}" for providers: ${providerKeys.join(", ")}`);
+        this.name = "CircularDependencyError";
+    }
+}
+export class DuplicateModuleImportError extends Error {
+    constructor(parentModuleName, importedModuleName) {
+        super(`Module "${parentModuleName}" has duplicate import of "${importedModuleName}"`);
+        this.name = "DuplicateModuleImportError";
+    }
+}
+export class ProviderNameConflictError extends Error {
+    constructor(moduleName, conflictingKeys) {
+        super(`Module "${moduleName}" has provider name conflicts with imported modules: ${conflictingKeys.join(", ")}`);
+        this.name = "ProviderNameConflictError";
+    }
+}
+export class ModuleFeatureOverrideNotFoundError extends Error {
+    constructor(moduleName, featureKind, featureKey) {
+        super(`Cannot override ${featureKind} "${featureKey}" in module "${moduleName}" because it is not declared by that module.`);
+        this.name = "ModuleFeatureOverrideNotFoundError";
+    }
+}
+export class ModuleOverrideTargetNotFoundError extends Error {
+    constructor(moduleName) {
+        super(`Module override target "${moduleName}" was not found in the bootstrapped module graph.`);
+        this.name = "ModuleOverrideTargetNotFoundError";
+    }
+}
+export class CircularModuleDependencyError extends Error {
+    constructor(moduleName, chain) {
+        super(`Circular module dependency detected: ${chain.join(" -> ")} -> ${moduleName}`);
+        this.name = "CircularModuleDependencyError";
+    }
+}
+export class GlobalModuleImportsGlobalModuleError extends Error {
+    constructor(moduleName, importedGlobalModuleName) {
+        super(`Global module "${moduleName}" cannot import global module "${importedGlobalModuleName}". ` +
+            `Register both modules in DIContext.globalModules without importing one from another.`);
+        this.name = "GlobalModuleImportsGlobalModuleError";
+    }
+}
+export class HandlerMissingStaticKeyError extends Error {
+    constructor(handlerName) {
+        super(`Handler class "${handlerName}" must have a static "key" property of type string. ` +
+            `Example: static readonly key = "my-handler" as const;`);
+        this.name = "HandlerMissingStaticKeyError";
+    }
+}
+export class FeatureNameConflictError extends Error {
+    constructor(moduleName, featureName, featureKey, existingModuleName) {
+        super(`Module "${moduleName}" has a ${featureName} named "${featureKey}" ` +
+            `that conflicts with a ${featureName} already registered from module "${existingModuleName}". ` +
+            `${featureName} names must be unique within a module scope.`);
+        this.name = "FeatureNameConflictError";
+    }
+}
+export class InvalidProviderDefinitionError extends Error {
+    constructor(moduleName, providerKey) {
+        super(`Module "${moduleName}" has invalid provider definition for key "${providerKey}". ` +
+            `Provider value is undefined or unsupported.`);
+        this.name = "InvalidProviderDefinitionError";
+    }
+}
+export class AsyncFactoryRequiresAsyncCreateError extends Error {
+    constructor(moduleName, providerKey) {
+        super(`Provider "${providerKey}" in module "${moduleName}" uses async useFactory. ` +
+            `Use AsyncDIContext to bootstrap modules with async factory providers.`);
+        this.name = "AsyncFactoryRequiresAsyncCreateError";
+    }
+}
+export class AsyncEagerFactoryRequiresInitError extends Error {
+    constructor(moduleName, providerKey) {
+        super(`Provider "${providerKey}" in module "${moduleName}" uses async useFactory with eager initialization. ` +
+            `Call app.init() before resolving this provider.`);
+        this.name = "AsyncEagerFactoryRequiresInitError";
+    }
+}
+export class AsyncFactoryRequiresSingletonLifetimeError extends Error {
+    constructor(moduleName, providerKey) {
+        super(`Provider "${providerKey}" in module "${moduleName}" uses async useFactory with a non-singleton lifetime. ` +
+            `Async factory providers are resolved during AsyncDIContext bootstrap, so they must use SINGLETON lifetime.`);
+        this.name = "AsyncFactoryRequiresSingletonLifetimeError";
+    }
+}
+export class EagerProviderRequiresSingletonLifetimeError extends Error {
+    constructor(moduleName, providerKey) {
+        super(`Provider "${providerKey}" in module "${moduleName}" uses eager initialization with a non-singleton lifetime. ` +
+            `Eager providers must use SINGLETON lifetime.`);
+        this.name = "EagerProviderRequiresSingletonLifetimeError";
+    }
+}
+export class EagerProviderInitDependencyNotFoundError extends Error {
+    constructor(moduleName, providerKey, dependencyKey) {
+        super(`Provider "${providerKey}" in module "${moduleName}" declares initAfter dependency "${dependencyKey}", ` +
+            `but that dependency is not an eager provider in the current application lifecycle.`);
+        this.name = "EagerProviderInitDependencyNotFoundError";
+    }
+}
+export class CircularProviderInitDependencyError extends Error {
+    constructor(providerKeys) {
+        super(`Circular eager provider init dependency detected: ${providerKeys.join(", ")}`);
+        this.name = "CircularProviderInitDependencyError";
+    }
+}
+export class AsyncModuleRequiresAsyncCreateError extends Error {
+    constructor(moduleName) {
+        super(`Module "${moduleName}" imports an async module. ` +
+            `Use AsyncDIContext to bootstrap modules with async imports.`);
+        this.name = "AsyncModuleRequiresAsyncCreateError";
+    }
+}
+export class DuplicateInitializerTokenError extends Error {
+    constructor(moduleName, initializerName, existingModuleName) {
+        super(`Initializer "${initializerName}" from module "${moduleName}" has a token conflict with an initializer already registered from module "${existingModuleName}". ` +
+            `Initializer tokens must be unique within a module scope.`);
+        this.name = "DuplicateInitializerTokenError";
+    }
+}
+export class MultipleInvokeInitializersPerMethodError extends Error {
+    constructor(moduleName, controllerName, methodName, initializerNames) {
+        super(`Controller method "${controllerName}.${methodName}" in module "${moduleName}" has multiple initializers that receive invoke: ${initializerNames.join(", ")}. ` +
+            `Only one invoke-enabled initializer is allowed per method. ` +
+            `Metadata-only initializers should set usesInvoke = false.`);
+        this.name = "MultipleInvokeInitializersPerMethodError";
+    }
+}

package/dist/lib/di/modules/module-def.types.d.ts

@@ -0,0 +1,117 @@
+import type { Mediator } from "../../mediator/mediator.js";
+import type { EmptyObject } from "../common.types.js";
+import type { ClassHandler, DefInitializerMap, DefInterceptorMap, DefPreHandlerMap, DefProviderMap } from "../providers/provider.types.js";
+import type { ImportModule, ModuleDefinition, ModuleImport } from "./module.types.js";
+export interface GlobalDependencies {
+}
+export type NormalizeGlobalDependencies<T> = [keyof T] extends [never] ? EmptyObject : T extends object ? T : EmptyObject;
+export type InferGlobalDependencies<TModuleDef> = TModuleDef extends {
+    exports: infer TExports;
+} ? NormalizeGlobalDependencies<TExports> : EmptyObject;
+type HasDuplicates<T extends readonly unknown[]> = number extends T["length"] ? false : T extends readonly [infer Head, ...infer Tail] ? Head extends Tail[number] ? true : HasDuplicates<Tail> : false;
+type KeysOf<T> = Extract<keyof T, string>;
+type ValidExportKeys<TMap, TKeys> = [TMap] extends [Record<string, unknown>] ? TKeys extends readonly KeysOf<TMap>[] ? HasDuplicates<TKeys> extends true ? never : TKeys : readonly KeysOf<TMap>[] : never;
+export type ModuleDef<D extends {
+    providers?: DefProviderMap;
+    interceptors?: DefInterceptorMap;
+    initializers?: DefInitializerMap;
+    imports?: readonly ModuleImport[];
+    queryHandlers?: readonly any[];
+    commandHandlers?: readonly any[];
+    queryPreHandlers?: DefPreHandlerMap;
+    commandPreHandlers?: DefPreHandlerMap;
+    exportKeys?: ValidExportKeys<D["providers"], D["exportKeys"]>;
+    exportQueryPreHandlerKeys?: ValidExportKeys<D["queryPreHandlers"], D["exportQueryPreHandlerKeys"]>;
+    exportCommandPreHandlerKeys?: ValidExportKeys<D["commandPreHandlers"], D["exportCommandPreHandlerKeys"]>;
+    exportInterceptorKeys?: ValidExportKeys<D["interceptors"], D["exportInterceptorKeys"]>;
+    exportInitializerKeys?: ValidExportKeys<D["initializers"], D["exportInitializerKeys"]>;
+}> = {
+    providers: ExtractProviders<D["providers"]>;
+    exports: ExtractExports<ExtractProviders<D["providers"]>, D["exportKeys"]>;
+    queryPreHandlerExports: ExtractPreHandlerExports<ExtractPreHandlers<D["queryPreHandlers"]>, D["exportQueryPreHandlerKeys"]>;
+    commandPreHandlerExports: ExtractPreHandlerExports<ExtractPreHandlers<D["commandPreHandlers"]>, D["exportCommandPreHandlerKeys"]>;
+    interceptors: ExtractInterceptors<D["interceptors"]>;
+    imports: ExtractImports<D["imports"]>;
+    deps: ExtractDeps<D>;
+    queryHandlers: ExtractHandlers<D["queryHandlers"]>;
+    commandHandlers: ExtractHandlers<D["commandHandlers"]>;
+    queryPreHandlers: ExtractPreHandlers<D["queryPreHandlers"]>;
+    commandPreHandlers: ExtractPreHandlers<D["commandPreHandlers"]>;
+    initializers: ExtractInitializers<D["initializers"]>;
+    exportKeys: ExtractExportKeys<ExtractProviders<D["providers"]>, D["exportKeys"]>;
+    queryPreHandlerExportKeys: ExtractPreHandlerExportKeys<ExtractPreHandlers<D["queryPreHandlers"]>, D["exportQueryPreHandlerKeys"]>;
+    commandPreHandlerExportKeys: ExtractPreHandlerExportKeys<ExtractPreHandlers<D["commandPreHandlers"]>, D["exportCommandPreHandlerKeys"]>;
+    interceptorExportKeys: ExtractInterceptorExportKeys<ExtractInterceptors<D["interceptors"]>, D["exportInterceptorKeys"]>;
+    initializerExportKeys: ExtractInitializerExportKeys<ExtractInitializers<D["initializers"]>, D["exportInitializerKeys"]>;
+};
+type ExtractProviders<TProviders> = TProviders extends DefProviderMap ? TProviders : EmptyObject;
+type ExtractPreHandlerExports<TMap, TKeys> = TMap extends DefPreHandlerMap ? TKeys extends readonly (keyof TMap)[] ? Pick<TMap, TKeys[number]> : EmptyObject : EmptyObject;
+type ExtractPreHandlerExportKeys<TMap, TKeys> = TMap extends DefPreHandlerMap ? TKeys extends readonly (keyof TMap)[] ? TKeys : readonly [] : readonly [];
+type ExtractExports<TProviders, TKeys> = TProviders extends DefProviderMap ? TKeys extends readonly (keyof TProviders)[] ? Pick<TProviders, TKeys[number]> : EmptyObject : EmptyObject;
+type ExtractExportKeys<TProviders, TKeys> = TProviders extends DefProviderMap ? TKeys extends readonly (keyof TProviders)[] ? TKeys : readonly [] : readonly [];
+type ExtractImports<TImports> = TImports extends readonly ModuleImport[] ? TImports : [];
+type ExtractHandlers<THandlers> = THandlers extends readonly any[] ? THandlers : [];
+type ExtractPreHandlers<TPreHandlers> = TPreHandlers extends DefPreHandlerMap ? TPreHandlers : EmptyObject;
+type ExtractInterceptors<TInterceptors> = TInterceptors extends DefInterceptorMap ? TInterceptors : EmptyObject;
+type ExtractInterceptorExportKeys<TInterceptors, TKeys> = TInterceptors extends DefInterceptorMap ? TKeys extends readonly (keyof TInterceptors)[] ? TKeys : readonly [] : readonly [];
+type ExtractInitializers<TInitializers> = TInitializers extends DefInitializerMap ? TInitializers : EmptyObject;
+type ExtractInitializerExportKeys<TInitializers, TKeys> = TInitializers extends DefInitializerMap ? TKeys extends readonly (keyof TInitializers)[] ? TKeys : readonly [] : readonly [];
+type ExtractDeps<D extends {
+    providers?: DefProviderMap;
+    imports?: readonly ModuleImport[];
+    queryHandlers?: readonly any[];
+    commandHandlers?: readonly any[];
+}> = ExtractProviders<D["providers"]> & ExtractImportsExports<D> & ExtractQueryMediator<D> & ExtractCommandMediator<D> & NormalizeGlobalDependencies<GlobalDependencies>;
+type ExtractImportsExports<D extends {
+    imports?: readonly ModuleImport[];
+}> = D["imports"] extends readonly ModuleImport[] ? ExtractExportsFromImports<D["imports"]> : EmptyObject;
+type ExtractModuleDefFromModule<T> = Awaited<T> extends ImportModule<infer TDef extends ModuleDefinition> ? TDef : Awaited<T> extends {
+    exports: infer E;
+} ? {
+    exports: E;
+} : never;
+type ExtractExportsFromImports<T extends readonly ModuleImport[]> = T extends readonly [
+    infer First,
+    ...infer Rest extends readonly ModuleImport[]
+] ? ExtractModuleDefFromModule<First> extends {
+    exports: infer E;
+} ? E & ExtractExportsFromImports<Rest> : ExtractExportsFromImports<Rest> : EmptyObject;
+type MediatorHandlerKey = "queryHandlers" | "commandHandlers";
+type MediatorPreHandlerKey = "queryPreHandlers" | "commandPreHandlers";
+type MediatorKindMap = {
+    query: {
+        handlerKey: "queryHandlers";
+        preHandlerKey: "queryPreHandlers";
+        preHandlerExportsKey: "queryPreHandlerExports";
+        mediatorKey: "queryMediator";
+    };
+    command: {
+        handlerKey: "commandHandlers";
+        preHandlerKey: "commandPreHandlers";
+        preHandlerExportsKey: "commandPreHandlerExports";
+        mediatorKey: "commandMediator";
+    };
+};
+type ExtractQueryMediator<D extends {
+    queryHandlers?: readonly any[];
+    queryPreHandlers?: DefPreHandlerMap;
+    imports?: readonly ModuleImport[];
+}> = ExtractMediator<"query", D>;
+type ExtractCommandMediator<D extends {
+    commandHandlers?: readonly any[];
+    commandPreHandlers?: DefPreHandlerMap;
+    imports?: readonly ModuleImport[];
+}> = ExtractMediator<"command", D>;
+type ExtractMediator<TKind extends keyof MediatorKindMap, D extends Partial<Record<MediatorHandlerKey, readonly any[]>> & Partial<Record<MediatorPreHandlerKey, DefPreHandlerMap>> & {
+    imports?: readonly ModuleImport[];
+}> = D[MediatorKindMap[TKind]["handlerKey"]] extends readonly [any, ...any[]] ? {
+    [K in MediatorKindMap[TKind]["mediatorKey"]]: Mediator<ExtractContractsFromHandlers<D[MediatorKindMap[TKind]["handlerKey"]]>>;
+} : EmptyObject;
+type ExtractContractsFromHandlers<Handlers extends readonly any[]> = Handlers extends readonly [infer First, ...infer Rest] ? ExtractContractFromHandler<First> | ExtractContractsFromHandlers<Rest> : never;
+type UnwrapClassHandler<H> = H extends ClassHandler ? H["useClass"] : H;
+type ExtractContractFromHandler<H> = UnwrapClassHandler<H> extends new (...args: any[]) => infer I ? I extends {
+    contract: infer C;
+} ? C : never : UnwrapClassHandler<H> extends {
+    contract: infer C;
+} ? C : never;
+export {};

package/dist/lib/di/modules/module-def.types.js

@@ -0,0 +1 @@
+export {};

package/dist/lib/di/modules/module-factories.d.ts

@@ -0,0 +1,16 @@
+import type { FactoryProvider } from "../providers/provider.types.js";
+import type { AnyModule, Module, ModuleDefinition } from "./module.types.js";
+import type { GlobalDependencies, NormalizeGlobalDependencies } from "./module-def.types.js";
+import type { ForwardRef } from "./module-ref.types.js";
+export type ModuleOptions = {
+    hashNameFrom?: unknown;
+    hashLength?: number;
+    registerControllers?: boolean;
+};
+export declare function forwardRef<T extends AnyModule>(getter: () => T | Promise<T>): ForwardRef<T>;
+type FactoryDeps<T> = (T extends {
+    deps: infer Deps;
+} ? Deps : T) & NormalizeGlobalDependencies<GlobalDependencies>;
+export declare function createFactoryProvider<TDeps extends Record<string, any>>(): <T extends object, const Keys extends readonly Extract<keyof FactoryDeps<TDeps>, string>[]>(provider: FactoryProvider<T, FactoryDeps<TDeps>, Keys>) => FactoryProvider<T, FactoryDeps<TDeps>, Keys>;
+export declare function createModule<TDef extends ModuleDefinition>(module: Module<TDef>, options?: ModuleOptions): Module<TDef>;
+export {};

package/dist/lib/di/modules/module-factories.js

@@ -0,0 +1,46 @@
+import { createHash } from "node:crypto";
+export function forwardRef(getter) {
+    return {
+        __forward_ref__: true,
+        resolve: getter,
+    };
+}
+export function createFactoryProvider() {
+    return (provider) => {
+        return provider;
+    };
+}
+export function createModule(module, options) {
+    const withOptions = {
+        ...module,
+        registerControllers: options?.registerControllers ?? true,
+    };
+    if (options?.hashNameFrom === undefined) {
+        return withOptions;
+    }
+    const hash = createHash("sha256")
+        .update(stableStringify(options.hashNameFrom))
+        .digest("hex")
+        .slice(0, Math.max(4, options.hashLength ?? 8));
+    return {
+        ...withOptions,
+        name: `${withOptions.name}_${hash}`,
+    };
+}
+function stableStringify(value) {
+    return JSON.stringify(sortRecursively(value));
+}
+function sortRecursively(value) {
+    if (Array.isArray(value)) {
+        return value.map(sortRecursively);
+    }
+    if (value && typeof value === "object") {
+        return Object.keys(value)
+            .sort()
+            .reduce((acc, key) => {
+            acc[key] = sortRecursively(value[key]);
+            return acc;
+        }, {});
+    }
+    return value;
+}

package/dist/lib/di/modules/module-overrides.d.ts

@@ -0,0 +1,70 @@
+import type { BuildResolverOptions, Constructor } from "awilix";
+import type { EmptyObject } from "../common.types.js";
+import type { AnyInitializer, AnyInterceptor, DefInitializerMap, DefInterceptorMap, DefPreHandlerMap, DefProviderMap, Provider } from "../providers/provider.types.js";
+import type { RawValueObject } from "./module.types.js";
+import type { InternalModuleLike } from "./runtime-module.types.js";
+type OwnProviderMap<TModule> = TModule extends {
+    providers: infer TProviders extends DefProviderMap;
+} ? TProviders : EmptyObject;
+type OwnQueryPreHandlerMap<TModule> = TModule extends {
+    queryPreHandlers: infer TPreHandlers extends DefPreHandlerMap;
+} ? TPreHandlers : EmptyObject;
+type OwnCommandPreHandlerMap<TModule> = TModule extends {
+    commandPreHandlers: infer TPreHandlers extends DefPreHandlerMap;
+} ? TPreHandlers : EmptyObject;
+type OwnInterceptorMap<TModule> = TModule extends {
+    interceptors: infer TInterceptors extends DefInterceptorMap;
+} ? TInterceptors : EmptyObject;
+type OwnInitializerMap<TModule> = TModule extends {
+    initializers: infer TInitializers extends DefInitializerMap;
+} ? TInitializers : EmptyObject;
+type ModuleDeps<TModule> = TModule extends {
+    deps: infer TDeps extends Record<string, unknown>;
+} ? TDeps : Record<string, unknown>;
+type RuntimeProviderValue<T> = T extends {
+    useFactory: (...args: any[]) => infer R;
+} ? Awaited<R> : T extends {
+    useClass: infer C extends new (...args: any[]) => any;
+} ? InstanceType<C> : T extends new (...args: any[]) => infer I ? I : T;
+type PublicShape<T> = Pick<T, keyof T>;
+type ProviderOverride<TValue, TDeps extends Record<string, unknown>> = RuntimeProviderValue<TValue> extends object ? (Provider<PublicShape<RuntimeProviderValue<TValue>>, TDeps> & {
+    initAfter?: readonly Extract<keyof TDeps, string>[];
+}) | RawValueObject<PublicShape<RuntimeProviderValue<TValue>>> : RuntimeProviderValue<TValue>;
+type ProviderOverridesFor<TModule> = {
+    [K in Extract<keyof OwnProviderMap<TModule>, string>]?: ProviderOverride<OwnProviderMap<TModule>[K], ModuleDeps<TModule>>;
+};
+type MiddlewareOverride<TValue> = TValue extends object ? Constructor<PublicShape<RuntimeProviderValue<TValue>>> | ({
+    useClass: Constructor<PublicShape<RuntimeProviderValue<TValue>>>;
+} & BuildResolverOptions<any>) : RuntimeProviderValue<TValue> extends object ? never : RuntimeProviderValue<TValue>;
+type PreHandlerOverridesFor<TMap> = {
+    [K in Extract<keyof TMap, string>]?: MiddlewareOverride<TMap[K]>;
+};
+type InterceptorOverridesFor<TModule> = {
+    [K in Extract<keyof OwnInterceptorMap<TModule>, string>]?: AnyInterceptor;
+};
+type InitializerOverridesFor<TModule> = {
+    [K in Extract<keyof OwnInitializerMap<TModule>, string>]?: AnyInitializer;
+};
+export type ModuleFeatureOverridesFor<TModule> = {
+    providers?: ProviderOverridesFor<TModule>;
+    queryPreHandlers?: PreHandlerOverridesFor<OwnQueryPreHandlerMap<TModule>>;
+    commandPreHandlers?: PreHandlerOverridesFor<OwnCommandPreHandlerMap<TModule>>;
+    interceptors?: InterceptorOverridesFor<TModule>;
+    initializers?: InitializerOverridesFor<TModule>;
+};
+export type ModuleOverride<TModule extends InternalModuleLike = InternalModuleLike> = {
+    module: TModule;
+    overrides: ModuleFeatureOverridesFor<TModule>;
+};
+export type AnyModuleOverride = {
+    module: InternalModuleLike;
+    overrides: {
+        providers?: Record<string, unknown>;
+        queryPreHandlers?: Record<string, unknown>;
+        commandPreHandlers?: Record<string, unknown>;
+        interceptors?: Record<string, unknown>;
+        initializers?: Record<string, unknown>;
+    };
+};
+export declare function overrideModule<TModule extends InternalModuleLike>(module: TModule, overrides: ModuleFeatureOverridesFor<TModule>): ModuleOverride<TModule>;
+export {};

package/dist/lib/di/modules/module-overrides.js

@@ -0,0 +1,3 @@
+export function overrideModule(module, overrides) {
+    return { module, overrides };
+}

package/dist/lib/di/modules/module-ref.types.d.ts

@@ -0,0 +1,13 @@
+export type ForwardRef<T = any> = {
+    __forward_ref__: true;
+    resolve: () => T | Promise<T>;
+};
+declare const moduleRefMarker: unique symbol;
+export type ModuleRef<T> = {
+    [moduleRefMarker]: true;
+    exports: T extends {
+        exports: infer E;
+    } ? E : never;
+};
+export type AnyModuleRef = ModuleRef<any>;
+export {};

package/dist/lib/di/modules/module-ref.types.js

@@ -0,0 +1 @@
+export {};

package/dist/lib/di/modules/module.types.d.ts

@@ -0,0 +1,178 @@
+import type { BuildResolverOptions, Constructor, ContainerOptions } from "awilix";
+import type { EmptyObject } from "../common.types.js";
+import type { AnyController, AnyInterceptor, ClassHandler, ClassMiddleware, DefInitializerMap, DefInterceptorMap, DefPreHandlerMap, DefProviderMap, Provider } from "../providers/provider.types.js";
+import type { ForwardRef, ModuleRef } from "./module-ref.types.js";
+import type { InternalModuleLike } from "./runtime-module.types.js";
+declare const importModuleDefMarker: unique symbol;
+export type ImportModule<TDef extends ModuleDefinition = ModuleDefinition> = {
+    name: string;
+    imports?: readonly unknown[];
+    exports?: readonly string[];
+    [importModuleDefMarker]?: TDef;
+};
+export type AnyModule = InternalModuleLike & ImportModule<any>;
+export type ModuleImport = AnyModule | Promise<AnyModule> | ModuleRef<any>;
+export type ModuleDefinition = {
+    providers?: DefProviderMap;
+    exports?: DefProviderMap;
+    imports?: ModuleImport[];
+    queryHandlers?: readonly any[];
+    commandHandlers?: readonly any[];
+    queryPreHandlers?: DefPreHandlerMap;
+    commandPreHandlers?: DefPreHandlerMap;
+    interceptors?: DefInterceptorMap;
+    initializers?: DefInitializerMap;
+    exportKeys?: readonly string[];
+    queryPreHandlerExportKeys?: readonly string[];
+    commandPreHandlerExportKeys?: readonly string[];
+    interceptorExportKeys?: readonly string[];
+    initializerExportKeys?: readonly string[];
+};
+type NormalizeModuleDef<Def extends ModuleDefinition> = {
+    deps: Def extends {
+        deps: infer D extends Record<string, unknown>;
+    } ? D : Record<string, unknown>;
+    providers: Def["providers"] extends DefProviderMap ? Def["providers"] : EmptyObject;
+    exports: Def["exports"] extends DefProviderMap ? Def["exports"] : EmptyObject;
+    imports: Def["imports"] extends readonly unknown[] ? Def["imports"] : readonly [];
+    queryHandlers: Def["queryHandlers"] extends readonly any[] ? Def["queryHandlers"] : readonly [];
+    commandHandlers: Def["commandHandlers"] extends readonly any[] ? Def["commandHandlers"] : readonly [];
+    queryPreHandlers: Def["queryPreHandlers"] extends DefPreHandlerMap ? Def["queryPreHandlers"] : EmptyObject;
+    commandPreHandlers: Def["commandPreHandlers"] extends DefPreHandlerMap ? Def["commandPreHandlers"] : EmptyObject;
+    initializers: Def["initializers"] extends DefInitializerMap ? Def["initializers"] : EmptyObject;
+    interceptors: Def["interceptors"] extends DefInterceptorMap ? Def["interceptors"] : EmptyObject;
+    exportKeys: Def["exportKeys"] extends readonly string[] ? Def["exportKeys"] : readonly [];
+    queryPreHandlerExportKeys: Def["queryPreHandlerExportKeys"] extends readonly string[] ? Def["queryPreHandlerExportKeys"] : readonly [];
+    commandPreHandlerExportKeys: Def["commandPreHandlerExportKeys"] extends readonly string[] ? Def["commandPreHandlerExportKeys"] : readonly [];
+    initializerExportKeys: Def["initializerExportKeys"] extends readonly string[] ? Def["initializerExportKeys"] : readonly [];
+    interceptorExportKeys: Def["interceptorExportKeys"] extends readonly string[] ? Def["interceptorExportKeys"] : readonly [];
+};
+export type Module<Def extends ModuleDefinition> = {
+    name: string;
+    controllers?: AnyController[];
+    containerOptions?: ContainerOptions;
+    providerOptions?: Partial<BuildResolverOptions<any>>;
+    [importModuleDefMarker]?: Def;
+} & ModuleFromNormalized<NormalizeModuleDef<Def>>;
+type ModuleFromNormalized<Def extends {
+    deps: Record<string, unknown>;
+    providers: DefProviderMap | EmptyObject;
+    exports: DefProviderMap | EmptyObject;
+    imports: readonly unknown[];
+    queryHandlers: readonly any[];
+    commandHandlers: readonly any[];
+    interceptors: DefInterceptorMap | EmptyObject;
+    initializers: DefInitializerMap | EmptyObject;
+    queryPreHandlers: DefPreHandlerMap | EmptyObject;
+    commandPreHandlers: DefPreHandlerMap | EmptyObject;
+    exportKeys: readonly string[];
+    queryPreHandlerExportKeys: readonly string[];
+    commandPreHandlerExportKeys: readonly string[];
+    initializerExportKeys: readonly string[];
+    interceptorExportKeys: readonly string[];
+}> = WithProviders<Def["providers"], Def["deps"]> & WithImports<Def["imports"]> & WithQueryHandlers<Def["queryHandlers"]> & WithCommandHandlers<Def["commandHandlers"]> & WithQueryPreHandlers<Def["queryPreHandlers"]> & WithCommandPreHandlers<Def["commandPreHandlers"]> & WithInitializers<Def["initializers"]> & WithInterceptors<Def["interceptors"]> & WithExports<Def["exportKeys"]> & WithQueryPreHandlerExports<Def["queryPreHandlerExportKeys"]> & WithCommandPreHandlerExports<Def["commandPreHandlerExportKeys"]> & WithInitializerExports<Def["initializerExportKeys"]> & WithInterceptorExports<Def["interceptorExportKeys"]>;
+type WithProviders<TProviders extends DefProviderMap | EmptyObject, TDeps extends Record<string, unknown>> = TProviders extends EmptyObject ? {
+    providers?: EmptyObject;
+} : {
+    providers: ToModuleProviderMap<TProviders, TDeps>;
+};
+type WithExports<TKeys extends readonly string[]> = TKeys extends readonly [] ? {
+    exports?: readonly [];
+} : {
+    exports: TKeys;
+};
+type ToModuleProviderMap<T extends DefProviderMap, DepsMap extends Record<string, unknown> = Record<string, unknown>> = [keyof T] extends [never] ? EmptyObject : {
+    [K in keyof T]: T[K] extends object ? (Provider<T[K], DepsMap> & {
+        initAfter?: readonly Extract<keyof DepsMap, string>[];
+    }) | RawValueObject<T[K]> : T[K];
+};
+export type RawValueObject<T> = T & {
+    useClass?: never;
+    useFactory?: never;
+    lifetime?: never;
+    allowCircular?: never;
+    eager?: never;
+    initAfter?: never;
+};
+type WithQueryHandlers<THandlers extends readonly any[]> = THandlers extends readonly [] ? {
+    queryHandlers?: readonly [];
+} : {
+    queryHandlers: ToModuleHandlerArray<THandlers>;
+};
+type WithCommandHandlers<THandlers extends readonly any[]> = THandlers extends readonly [] ? {
+    commandHandlers?: readonly [];
+} : {
+    commandHandlers: ToModuleHandlerArray<THandlers>;
+};
+type ToModuleHandlerArray<T extends readonly any[]> = T extends readonly [] ? readonly [] : {
+    readonly [K in keyof T]: Constructor<T[K]> | ClassHandler<Constructor<T[K]>>;
+};
+type ToModulePreHandlerMap<T extends DefPreHandlerMap> = [keyof T] extends [
+    never
+] ? EmptyObject : {
+    [K in keyof T]: Constructor<T[K]> | ClassMiddleware<Constructor<T[K]>>;
+};
+type WithQueryPreHandlers<TPreHandlers extends DefPreHandlerMap | EmptyObject> = TPreHandlers extends EmptyObject ? {
+    queryPreHandlers?: EmptyObject;
+} : {
+    queryPreHandlers: ToModulePreHandlerMap<TPreHandlers>;
+};
+type WithCommandPreHandlers<TPreHandlers extends DefPreHandlerMap | EmptyObject> = TPreHandlers extends EmptyObject ? {
+    commandPreHandlers?: EmptyObject;
+} : {
+    commandPreHandlers: ToModulePreHandlerMap<TPreHandlers>;
+};
+type WithQueryPreHandlerExports<TKeys extends readonly string[]> = TKeys extends readonly [] ? {
+    queryPreHandlerExports?: readonly [];
+} : {
+    queryPreHandlerExports: TKeys;
+};
+type WithCommandPreHandlerExports<TKeys extends readonly string[]> = TKeys extends readonly [] ? {
+    commandPreHandlerExports?: readonly [];
+} : {
+    commandPreHandlerExports: TKeys;
+};
+type WithInitializers<TInitializers extends DefInitializerMap | EmptyObject> = TInitializers extends EmptyObject ? {
+    initializers?: EmptyObject;
+} : {
+    initializers: TInitializers;
+};
+type WithInitializerExports<TKeys extends readonly string[]> = TKeys extends readonly [] ? {
+    initializerExports?: readonly [];
+} : {
+    initializerExports: TKeys;
+};
+type ToModuleInterceptorMap<T extends DefInterceptorMap> = [keyof T] extends [
+    never
+] ? EmptyObject : {
+    [K in keyof T]: AnyInterceptor;
+};
+type WithInterceptors<TInterceptors extends DefInterceptorMap | EmptyObject> = TInterceptors extends EmptyObject ? {
+    interceptors?: EmptyObject;
+} : {
+    interceptors: ToModuleInterceptorMap<TInterceptors>;
+};
+type WithInterceptorExports<TKeys extends readonly string[]> = TKeys extends readonly [] ? {
+    interceptorExports?: readonly [];
+} : {
+    interceptorExports: TKeys;
+};
+type WithImports<TImports extends readonly unknown[]> = 0 extends 1 & TImports ? {
+    imports?: (AnyModule | Promise<AnyModule> | ForwardRef)[];
+} : TImports extends readonly [] ? {
+    imports?: [];
+} : {
+    imports: WithForwardRefImports<TImports>;
+};
+type WithForwardRefImports<T extends readonly unknown[]> = {
+    [K in keyof T]: T[K] extends ModuleRef<infer MDef> ? ForwardRef<ForwardRefModule<MDef>> : Awaited<T[K]> extends ImportModule<any> ? T[K] : T[K];
+};
+type ForwardRefModule<MDef> = MDef extends {
+    exports: infer E extends DefProviderMap;
+    providers: infer P extends DefProviderMap;
+} ? {
+    name: string;
+    exports: readonly Extract<keyof E, string>[];
+    providers: ToModuleProviderMap<P, any>;
+} : AnyModule;
+export {};

package/dist/lib/di/modules/module.types.js

@@ -0,0 +1 @@
+export {};

package/dist/lib/di/modules/provider-overrides.types.d.ts

@@ -0,0 +1,19 @@
+import type { EmptyObject } from "../common.types.js";
+import type { Module, ModuleDefinition, RawValueObject } from "./module.types.js";
+import type { AnyProvider, DefProviderMap, Provider } from "../providers/provider.types.js";
+type ModuleDefFrom<TModule> = TModule extends Module<infer TDef extends ModuleDefinition> ? TDef : never;
+type OwnProviderMap<TModule> = ModuleDefFrom<TModule> extends {
+    providers: infer TProviders extends DefProviderMap;
+} ? TProviders : EmptyObject;
+type ModuleDeps<TModule> = ModuleDefFrom<TModule> extends {
+    deps: infer TDeps extends Record<string, unknown>;
+} ? TDeps : Record<string, unknown>;
+type PublicShape<T> = Pick<T, keyof T>;
+type ProviderOverride<TValue, TDeps extends Record<string, unknown>> = TValue extends object ? (Provider<PublicShape<TValue>, TDeps> & {
+    initAfter?: readonly Extract<keyof TDeps, string>[];
+}) | RawValueObject<PublicShape<TValue>> : TValue;
+export type ProviderOverridesFor<TModule> = {
+    [K in Extract<keyof OwnProviderMap<TModule>, string>]?: ProviderOverride<OwnProviderMap<TModule>[K], ModuleDeps<TModule>>;
+};
+export type AnyProviderOverrides = Record<string, AnyProvider>;
+export {};

package/dist/lib/di/modules/provider-overrides.types.js

@@ -0,0 +1 @@
+export {};

package/dist/lib/di/modules/runtime-module.types.d.ts

@@ -0,0 +1,25 @@
+import type { BuildResolverOptions, ContainerOptions } from "awilix";
+import type { AnyController, AnyInitializer, AnyInterceptor, AnyMiddleware, AnyProvider } from "../providers/provider.types.js";
+import type { ForwardRef } from "./module-ref.types.js";
+export interface InternalModuleLike {
+    name: string;
+    imports?: readonly (InternalModuleLike | Promise<InternalModuleLike> | ForwardRef<InternalModuleLike>)[];
+    providers?: Record<string, AnyProvider>;
+    exports?: readonly string[];
+    components?: Record<string, (...args: any[]) => unknown>;
+    componentExports?: readonly string[];
+    controllers?: AnyController[];
+    registerControllers?: boolean;
+    containerOptions?: ContainerOptions;
+    providerOptions?: Partial<BuildResolverOptions<any>>;
+    queryHandlers?: readonly any[];
+    commandHandlers?: readonly any[];
+    queryPreHandlers?: Record<string, AnyMiddleware>;
+    commandPreHandlers?: Record<string, AnyMiddleware>;
+    queryPreHandlerExports?: readonly string[];
+    commandPreHandlerExports?: readonly string[];
+    interceptors?: Record<string, AnyInterceptor>;
+    interceptorExports?: readonly string[];
+    initializers?: Record<string, AnyInitializer>;
+    initializerExports?: readonly string[];
+}