awilixify 2.2.1 → 3.1.0

package/dist/lib/di/contexts/di-context-async.js

@@ -0,0 +1,118 @@
+import * as GUARGS from "../type-guards.js";
+import { DIContextBase } from "./di-context-base.js";
+export class AsyncDIContext extends DIContextBase {
+    moduleTreePromiseMap = new WeakMap();
+    constructor(options) {
+        super(options);
+    }
+    static async create(module, options) {
+        return new AsyncDIContext(options ?? {}).bootstrap(module);
+    }
+    async bootstrap(module) {
+        const rootModule = await module;
+        await this.initializeGlobalModulesAsync(rootModule);
+        const moduleTree = await this.registerModuleWithScopeAsync(rootModule, this.createContainer(rootModule), []);
+        this.overridesProcessor.ensureAllModuleOverridesApplied();
+        return moduleTree;
+    }
+    async initializeGlobalModulesAsync(rootModule) {
+        const globalModuleImports = (await Promise.all(this.globalModules.map(async (module) => (await this.resolveImportsAsync(module)).map((importedModule) => ({
+            module,
+            importedModule,
+        }))))).flat();
+        this.moduleGraphEnsurer.ensureGlobalModulesDoNotImportGlobalModules({
+            globalModules: this.globalModules,
+            globalModuleImports,
+        });
+        this.globalModulesWithScope = [];
+        this.attachDevtools(rootModule);
+        for (const module of this.globalModules) {
+            const moduleTree = await this.registerModuleWithScopeAsync(module, this.createContainer(module), []);
+            this.globalModulesWithScope.push({
+                module,
+                moduleScope: moduleTree,
+            });
+        }
+    }
+    async registerModuleWithScopeAsync(m, scope, moduleChain) {
+        const existingTree = this.moduleTreeMap.get(m);
+        if (existingTree) {
+            return existingTree;
+        }
+        const imports = await this.resolveImportsAsync(m);
+        const moduleWithOverrides = this.overridesProcessor.applyModuleOverrides(m);
+        const moduleId = this.registerModuleInGraph({
+            module: moduleWithOverrides,
+            scope,
+            importedModules: imports,
+        });
+        this.moduleGraphEnsurer.ensureImportedModulesUniqueness({
+            module: moduleWithOverrides,
+            resolvedImports: imports,
+            globalModules: this.globalModulesWithScope.map((el) => el.module),
+        });
+        this.moduleGraphEnsurer.ensureNoProviderNameConflicts({
+            module: moduleWithOverrides,
+            resolvedImports: imports,
+            globalModules: this.globalModulesWithScope.map((el) => el.module),
+            getExportedProviderKeys: (module) => this.getExportedProviderKeys(module),
+        });
+        this.markModuleIfImportsUseForwardRef(moduleWithOverrides);
+        const isCircular = moduleChain.includes(m);
+        if (isCircular) {
+            this.moduleGraphEnsurer.ensureCircularDependencyHasForwardRef({
+                module: m,
+                moduleChain,
+                forwardRefModules: this.forwardRefModules,
+            });
+            return this.createModuleScope(m.name, this.moduleScopeMap.get(m), []);
+        }
+        const pendingTree = this.moduleTreePromiseMap.get(m);
+        if (pendingTree) {
+            return pendingTree;
+        }
+        const moduleTreePromise = this.registerNewModuleWithScopeAsync(m, moduleWithOverrides, moduleId, scope, imports, moduleChain);
+        this.moduleTreePromiseMap.set(m, moduleTreePromise);
+        return moduleTreePromise;
+    }
+    async registerNewModuleWithScopeAsync(m, moduleWithOverrides, moduleId, scope, imports, moduleChain) {
+        this.moduleScopeMap.set(m, scope);
+        const importedModulesWithScope = [
+            ...this.globalModulesWithScope,
+            ...(await Promise.all(imports.map(async (module) => {
+                const moduleTree = await this.registerModuleWithScopeAsync(module, this.createContainer(module), [...moduleChain, m]);
+                return {
+                    module: this.overridesProcessor.getModuleWithOverrides(module),
+                    moduleScope: moduleTree,
+                };
+            }))),
+        ];
+        this.registerExportedProviders(scope, importedModulesWithScope);
+        const moduleForSorting = {
+            ...moduleWithOverrides,
+            imports: importedModulesWithScope.map((el) => el.module),
+        };
+        this.interceptorProcessor.processInterceptors(moduleWithOverrides, scope, importedModulesWithScope);
+        const providers = this.sorter.sortByDependencies(moduleForSorting);
+        for (const [key, provider] of Object.entries(providers)) {
+            scope.register({
+                [key]: await this.providerResolver.resolveProviderAsync({
+                    key,
+                    moduleId,
+                    provider,
+                    resolutionScope: scope,
+                    module: moduleWithOverrides,
+                }),
+            });
+        }
+        this.lifecycleProcessor.collectEagerProviders(moduleWithOverrides, scope);
+        this.afterRegisterProviders(moduleWithOverrides, scope, importedModulesWithScope);
+        const moduleTree = this.createModuleScope(m.name, scope, importedModulesWithScope);
+        this.moduleTreeMap.set(m, moduleTree);
+        this.moduleTreePromiseMap.delete(m);
+        return moduleTree;
+    }
+    async resolveImportsAsync(m) {
+        return Promise.all((m.imports || []).map((importItem) => GUARGS.isForwardRef(importItem) ? importItem.resolve() : importItem));
+    }
+}

package/dist/lib/di/contexts/di-context-base.d.ts

@@ -0,0 +1,19 @@
+import type * as Awilix from "awilix";
+import type { InternalModuleLike as M } from "../modules/runtime-module.types.js";
+import { ControllerProcessor } from "../processors/controller-processor.js";
+import { HandlerProcessor } from "../processors/handler-processor.js";
+import { InitializerProcessor } from "../processors/initializer-processor.js";
+import { InterceptorProcessor } from "../processors/interceptor-processor.js";
+import { ContainerContextBase, type ContainerContextOptions, type RegisteredModuleScope } from "./container-context-base.js";
+export interface DiContextOptions extends ContainerContextOptions {
+    skipRegisterRoutes?: boolean;
+}
+export declare class DIContextBase extends ContainerContextBase<DiContextOptions> {
+    protected readonly controllerProcessor: ControllerProcessor;
+    protected readonly handlerProcessor: HandlerProcessor;
+    protected readonly interceptorProcessor: InterceptorProcessor;
+    protected readonly initializerProcessor: InitializerProcessor;
+    protected constructor(options: DiContextOptions);
+    protected beforeRegisterProviders(m: M, scope: Awilix.AwilixContainer, importedModulesWithScope: RegisteredModuleScope[]): void;
+    protected afterRegisterProviders(m: M, scope: Awilix.AwilixContainer, importedModulesWithScope: RegisteredModuleScope[]): void;
+}

package/dist/lib/di/contexts/di-context-base.js

@@ -0,0 +1,33 @@
+import { ControllerProcessor } from "../processors/controller-processor.js";
+import { HandlerProcessor, HandlerType, } from "../processors/handler-processor.js";
+import { InitializerProcessor } from "../processors/initializer-processor.js";
+import { InterceptorProcessor } from "../processors/interceptor-processor.js";
+import { ProviderResolver } from "../providers/provider-resolver.js";
+import { getOrCreateRequestScope, hasRequestScopeContext, resolveFromRequestScope, } from "../request-scope-context.js";
+import { ContainerContextBase, } from "./container-context-base.js";
+export class DIContextBase extends ContainerContextBase {
+    controllerProcessor;
+    handlerProcessor;
+    interceptorProcessor;
+    initializerProcessor;
+    constructor(options) {
+        super(options, {
+            hasScopeContext: hasRequestScopeContext,
+            resolveFromScope: resolveFromRequestScope,
+        });
+        this.handlerProcessor = new HandlerProcessor(this.options.providerOptions || {}, this.devtoolsProcessorRef);
+        this.interceptorProcessor = new InterceptorProcessor(this.options.providerOptions || {}, this.devtoolsProcessorRef);
+        this.initializerProcessor = new InitializerProcessor(this.devtoolsProcessorRef);
+        this.controllerProcessor = new ControllerProcessor(this.interceptorProcessor, this.options.providerOptions || {}, this.options.skipRegisterRoutes === true);
+        this.providerResolver = new ProviderResolver(this.interceptorProcessor, this.options.providerOptions || {}, this.devtoolsProcessorRef, getOrCreateRequestScope);
+    }
+    beforeRegisterProviders(m, scope, importedModulesWithScope) {
+        this.interceptorProcessor.processInterceptors(m, scope, importedModulesWithScope);
+    }
+    afterRegisterProviders(m, scope, importedModulesWithScope) {
+        this.handlerProcessor.processHandlers(m, scope, importedModulesWithScope, HandlerType.Query);
+        this.handlerProcessor.processHandlers(m, scope, importedModulesWithScope, HandlerType.Command);
+        const controllers = this.controllerProcessor.processControllers(m, scope);
+        this.lifecycleProcessor.addInitializerTask(this.initializerProcessor.collectInitializers(m, scope, importedModulesWithScope, controllers));
+    }
+}

package/dist/lib/di/contexts/di-context.d.ts

@@ -0,0 +1,7 @@
+import type { InternalModuleLike as M } from "../modules/runtime-module.types.js";
+import type { DiContextOptions } from "./di-context-base.js";
+import { DIContextBase } from "./di-context-base.js";
+export declare class DIContext extends DIContextBase {
+    private constructor();
+    static create(module: M, options?: DiContextOptions): import("./container-context-base.js").ModuleScope<import("awilix").AwilixContainer<{}>>;
+}

package/dist/lib/di/contexts/di-context.js

@@ -0,0 +1,9 @@
+import { DIContextBase } from "./di-context-base.js";
+export class DIContext extends DIContextBase {
+    constructor(options) {
+        super(options);
+    }
+    static create(module, options) {
+        return new DIContext(options ?? {}).bootstrapModule(module);
+    }
+}

package/dist/lib/di/contexts/module-graph-ensurer.d.ts

@@ -0,0 +1,32 @@
+import type { InternalModuleLike as M } from "../modules/runtime-module.types.js";
+type EnsureImportedModulesUniquenessParams = {
+    module: M;
+    resolvedImports: M[];
+    globalModules: M[];
+};
+type EnsureGlobalModulesDoNotImportGlobalModulesParams = {
+    globalModules: readonly M[];
+    globalModuleImports: readonly {
+        module: M;
+        importedModule: M;
+    }[];
+};
+type EnsureNoProviderNameConflictsParams = {
+    module: M;
+    resolvedImports: M[];
+    globalModules: M[];
+    getExportedProviderKeys(module: M): string[];
+};
+type EnsureCircularDependencyHasForwardRefParams = {
+    module: M;
+    moduleChain: M[];
+    forwardRefModules: WeakSet<M>;
+};
+export declare class ModuleGraphEnsurer {
+    ensureImportedModulesUniqueness({ module, resolvedImports, globalModules, }: EnsureImportedModulesUniquenessParams): void;
+    ensureGlobalModulesDoNotImportGlobalModules({ globalModules, globalModuleImports, }: EnsureGlobalModulesDoNotImportGlobalModulesParams): void;
+    ensureNoProviderNameConflicts({ module, resolvedImports, globalModules, getExportedProviderKeys, }: EnsureNoProviderNameConflictsParams): void;
+    ensureCircularDependencyHasForwardRef({ module, moduleChain, forwardRefModules, }: EnsureCircularDependencyHasForwardRefParams): void;
+    ensureSingleDevtoolsModule(devtoolsModules: M[]): M | undefined;
+}
+export {};

package/dist/lib/di/contexts/module-graph-ensurer.js

@@ -0,0 +1,50 @@
+import * as ERRORS from "../errors.js";
+export class ModuleGraphEnsurer {
+    ensureImportedModulesUniqueness({ module, resolvedImports, globalModules, }) {
+        const importedNames = new Set();
+        const imports = [...globalModules, ...resolvedImports];
+        for (const imported of imports) {
+            if (importedNames.has(imported.name)) {
+                throw new ERRORS.DuplicateModuleImportError(module.name, imported.name);
+            }
+            importedNames.add(imported.name);
+        }
+    }
+    ensureGlobalModulesDoNotImportGlobalModules({ globalModules, globalModuleImports, }) {
+        const globalModuleNames = new Set();
+        for (const globalModule of globalModules) {
+            if (globalModuleNames.has(globalModule.name)) {
+                throw new ERRORS.DuplicateModuleImportError("globalModules", globalModule.name);
+            }
+            globalModuleNames.add(globalModule.name);
+        }
+        for (const { module, importedModule } of globalModuleImports) {
+            if (globalModuleNames.has(importedModule.name)) {
+                throw new ERRORS.GlobalModuleImportsGlobalModuleError(module.name, importedModule.name);
+            }
+        }
+    }
+    ensureNoProviderNameConflicts({ module, resolvedImports, globalModules, getExportedProviderKeys, }) {
+        const moduleProviderKeys = Object.keys(module.providers || {});
+        const importConflicts = [
+            ...globalModules.flatMap((globalModule) => getExportedProviderKeys(globalModule)),
+            ...resolvedImports.flatMap((importItem) => getExportedProviderKeys(importItem)),
+        ].filter((key) => moduleProviderKeys.includes(key));
+        if (importConflicts.length > 0) {
+            throw new ERRORS.ProviderNameConflictError(module.name, importConflicts);
+        }
+    }
+    ensureCircularDependencyHasForwardRef({ module, moduleChain, forwardRefModules, }) {
+        const hasForwardRefInCycle = forwardRefModules.has(module) ||
+            moduleChain.some((chainModule) => forwardRefModules.has(chainModule));
+        if (hasForwardRefInCycle)
+            return;
+        const chainNames = moduleChain.map((chainModule) => chainModule.name);
+        throw new ERRORS.CircularModuleDependencyError(module.name, chainNames);
+    }
+    ensureSingleDevtoolsModule(devtoolsModules) {
+        if (devtoolsModules.length <= 1)
+            return devtoolsModules[0];
+        throw new ERRORS.DuplicateDevtoolsModuleError(devtoolsModules.map((module) => module.name));
+    }
+}

package/dist/lib/di/errors.d.ts

@@ -0,0 +1,69 @@
+export declare class DuplicateControllersInModuleError extends Error {
+    constructor(moduleName: string);
+}
+export declare class ControllerAlreadyRegisteredError extends Error {
+    constructor(controllerName: string, moduleName: string);
+}
+export declare class DependencyNotFoundError extends Error {
+    constructor(dependencyKey: string, moduleName: string);
+}
+export declare class CircularDependencyError extends Error {
+    constructor(moduleName: string, providerKeys: string[]);
+}
+export declare class DuplicateModuleImportError extends Error {
+    constructor(parentModuleName: string, importedModuleName: string);
+}
+export declare class DuplicateDevtoolsModuleError extends Error {
+    constructor(moduleNames: string[]);
+}
+export declare class ProviderNameConflictError extends Error {
+    constructor(moduleName: string, conflictingKeys: string[]);
+}
+export declare class ModuleFeatureOverrideNotFoundError extends Error {
+    constructor(moduleName: string, featureKind: string, featureKey: string);
+}
+export declare class ModuleOverrideTargetNotFoundError extends Error {
+    constructor(moduleName: string);
+}
+export declare class CircularModuleDependencyError extends Error {
+    constructor(moduleName: string, chain: string[]);
+}
+export declare class GlobalModuleImportsGlobalModuleError extends Error {
+    constructor(moduleName: string, importedGlobalModuleName: string);
+}
+export declare class HandlerMissingStaticKeyError extends Error {
+    constructor(handlerName: string);
+}
+export declare class FeatureNameConflictError extends Error {
+    constructor(moduleName: string, featureName: string, featureKey: string, existingModuleName: string);
+}
+export declare class InvalidProviderDefinitionError extends Error {
+    constructor(moduleName: string, providerKey: string);
+}
+export declare class AsyncFactoryRequiresAsyncCreateError extends Error {
+    constructor(moduleName: string, providerKey: string);
+}
+export declare class AsyncEagerFactoryRequiresInitError extends Error {
+    constructor(moduleName: string, providerKey: string);
+}
+export declare class AsyncFactoryRequiresSingletonLifetimeError extends Error {
+    constructor(moduleName: string, providerKey: string);
+}
+export declare class EagerProviderRequiresSingletonLifetimeError extends Error {
+    constructor(moduleName: string, providerKey: string);
+}
+export declare class EagerProviderInitDependencyNotFoundError extends Error {
+    constructor(moduleName: string, providerKey: string, dependencyKey: string);
+}
+export declare class CircularProviderInitDependencyError extends Error {
+    constructor(providerKeys: string[]);
+}
+export declare class AsyncModuleRequiresAsyncCreateError extends Error {
+    constructor(moduleName: string);
+}
+export declare class DuplicateInitializerTokenError extends Error {
+    constructor(moduleName: string, initializerName: string, existingModuleName: string);
+}
+export declare class MultipleInvokeInitializersPerMethodError extends Error {
+    constructor(moduleName: string, controllerName: string, methodName: string, initializerNames: string[]);
+}

package/dist/lib/di/errors.js

@@ -0,0 +1,154 @@
+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 DuplicateDevtoolsModuleError extends Error {
+    constructor(moduleNames) {
+        super(`Only one devtools module can be registered. Found: ${moduleNames.join(", ")}`);
+        this.name = "DuplicateDevtoolsModuleError";
+    }
+}
+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 {};