awilixify 2.2.1 → 3.1.0

package/dist/lib/di/processors/initializer-processor.js

@@ -0,0 +1,95 @@
+import { resolveDecoratorState } from "../../decorators/decorator-state.js";
+import { getControllerMethodNames } from "../../devtools/helpers.js";
+import * as ERRORS from "../errors.js";
+import { runInRequestScopeContext } from "../request-scope-context.js";
+import { KeyedFeatureRegistrar } from "./keyed-feature-registrar.js";
+export class InitializerProcessor {
+    devtoolsProcessorRef;
+    keyedFeatureRegistrar = new KeyedFeatureRegistrar({});
+    resolversByModule = new WeakMap();
+    constructor(devtoolsProcessorRef) {
+        this.devtoolsProcessorRef = devtoolsProcessorRef;
+    }
+    collectInitializers(m, scope, importedModulesWithScope, controllers) {
+        this.resolversByModule.set(m, this.keyedFeatureRegistrar.register({
+            featureKind: "initializers",
+            module: m,
+            scope,
+            importedModulesWithScope,
+        }));
+        const initializers = [
+            ...(this.resolversByModule.get(m) ??
+                new Map()).entries(),
+        ];
+        if (initializers.length === 0 || controllers.length === 0)
+            return null;
+        this.devtoolsProcessorRef.current?.graphCollector.collectModuleRoutes({
+            module: m,
+            controllers,
+            initializers,
+        });
+        return async (options) => {
+            const activeInitializers = this.filterActiveInitializers(initializers, options);
+            if (activeInitializers.length === 0)
+                return;
+            for (const controller of controllers) {
+                for (const methodName of getControllerMethodNames(controller.controllerClass)) {
+                    const invoke = (...args) => this.devtoolsProcessorRef.current?.tracer.traceInitializer({
+                        args,
+                        callback: () => runInRequestScopeContext(() => controller.resolve()[methodName](...args)),
+                        controllerName: controller.controllerClass.name,
+                        getStatusCode: () => getStatusCode(args),
+                        methodName: String(methodName),
+                        moduleName: m.name,
+                    }) ??
+                        runInRequestScopeContext(() => controller.resolve()[methodName](...args));
+                    this.ensureNoMultiInvokableInitializersPerMethod(m.name, methodName, controller, activeInitializers);
+                    for (const [, resolveInitializer] of activeInitializers) {
+                        const initializer = resolveInitializer();
+                        const decoratorState = resolveDecoratorState(controller.controllerClass, initializer.token);
+                        if (decoratorState === null)
+                            continue;
+                        const metadata = decoratorState.methods.get(methodName);
+                        if (metadata === undefined)
+                            continue;
+                        await initializer.initialize({
+                            moduleName: m.name,
+                            target: controller.controllerClass,
+                            methodName,
+                            metadata,
+                            decoratorState,
+                            ...(initializer.usesInvoke ? { invoke } : {}),
+                        });
+                    }
+                }
+            }
+        };
+    }
+    ensureNoMultiInvokableInitializersPerMethod(moduleName, methodName, controller, initializers) {
+        const invokableInitializers = initializers
+            .map(([, resolver]) => resolver())
+            .filter((initializer) => {
+            const decoratorState = resolveDecoratorState(controller.controllerClass, initializer.token);
+            return (decoratorState?.methods.has(methodName) === true &&
+                initializer.usesInvoke === true);
+        });
+        if (invokableInitializers.length > 1) {
+            throw new ERRORS.MultipleInvokeInitializersPerMethodError(moduleName, controller.controllerClass.name, String(methodName), invokableInitializers.map((initializer) => initializer.constructor.name));
+        }
+    }
+    filterActiveInitializers(initializers, options) {
+        if (options?.excludeInitializers === true)
+            return [];
+        if (!Array.isArray(options?.excludeInitializers))
+            return initializers;
+        const excludedKeys = new Set(options.excludeInitializers);
+        return initializers.filter(([key]) => !excludedKeys.has(key));
+    }
+}
+function getStatusCode(args) {
+    const reply = args[1];
+    if (!reply || typeof reply !== "object")
+        return undefined;
+    const statusCode = reply.statusCode;
+    return typeof statusCode === "number" ? statusCode : undefined;
+}

package/dist/lib/di/processors/interceptor-processor.d.ts

@@ -0,0 +1,21 @@
+import * as Awilix from "awilix";
+import type { DevtoolsProcessorRef } from "../../devtools/devtools.types.js";
+import type { RegisteredModuleScope } from "../contexts/container-context-base.js";
+import type { DiContextOptions } from "../contexts/di-context-base.js";
+import type { InternalModuleLike as M } from "../modules/runtime-module.types.js";
+export declare class InterceptorProcessor {
+    private readonly devtoolsProcessorRef;
+    private readonly keyedFeatureRegistrar;
+    private readonly resolversByModule;
+    constructor(providerOptions: DiContextOptions["providerOptions"], devtoolsProcessorRef: DevtoolsProcessorRef);
+    processInterceptors(m: M, scope: Awilix.AwilixContainer, importedModulesWithScope: RegisteredModuleScope[]): void;
+    createInterceptedProviderResolver({ module, useClass, options, resolver, }: {
+        module: M;
+        useClass: new (...args: any[]) => object;
+        options: Awilix.BuildResolverOptions<any>;
+        resolver?: Awilix.Resolver<any>;
+    }): Awilix.Resolver<any>;
+    private createInterceptedProviderInstance;
+    private callWithInterceptorChain;
+    private get devtoolsTracer();
+}

package/dist/lib/di/processors/interceptor-processor.js

@@ -0,0 +1,117 @@
+import * as Awilix from "awilix";
+import { hasDecoratorMethodMetadata, resolveDecoratorState, } from "../../decorators/decorator-state.js";
+import { KeyedFeatureRegistrar } from "./keyed-feature-registrar.js";
+export class InterceptorProcessor {
+    devtoolsProcessorRef;
+    keyedFeatureRegistrar;
+    resolversByModule = new WeakMap();
+    constructor(providerOptions, devtoolsProcessorRef) {
+        this.devtoolsProcessorRef = devtoolsProcessorRef;
+        this.keyedFeatureRegistrar = new KeyedFeatureRegistrar(providerOptions ?? {});
+    }
+    processInterceptors(m, scope, importedModulesWithScope) {
+        const resolverMap = this.keyedFeatureRegistrar.register({
+            featureKind: "interceptors",
+            module: m,
+            scope,
+            importedModulesWithScope,
+        });
+        this.resolversByModule.set(m, resolverMap);
+    }
+    createInterceptedProviderResolver({ module, useClass, options, resolver, }) {
+        const baseResolver = resolver || Awilix.asClass(useClass, options);
+        const interceptors = [
+            ...(this.resolversByModule.get(module)?.values() ?? []),
+        ];
+        if (interceptors.length === 0) {
+            return baseResolver;
+        }
+        if (!hasDecoratorMethodMetadata(useClass)) {
+            return baseResolver;
+        }
+        return Awilix.createBuildResolver({
+            ...options,
+            resolve: (container) => this.createInterceptedProviderInstance(baseResolver.resolve(container), useClass, interceptors, module.name),
+        });
+    }
+    createInterceptedProviderInstance(instance, metadataTarget, resolveInterceptors, moduleName) {
+        const wrappers = new Map();
+        const self = this;
+        return new Proxy(instance, {
+            get(target, propertyKey, proxyReceiver) {
+                const value = Reflect.get(target, propertyKey, proxyReceiver);
+                if (typeof value !== "function")
+                    return value;
+                const existing = wrappers.get(propertyKey);
+                if (existing)
+                    return existing;
+                const wrapped = (...args) => {
+                    const interceptors = resolveInterceptors.map((resolve) => resolve());
+                    const metadataByToken = new Map();
+                    for (const interceptor of interceptors) {
+                        const state = resolveDecoratorState(metadataTarget, interceptor.token);
+                        if (state === null)
+                            continue;
+                        const method = state.methods.get(propertyKey);
+                        if (method !== undefined) {
+                            metadataByToken.set(interceptor.token.stateSymbol, {
+                                state,
+                                method,
+                            });
+                        }
+                    }
+                    if (metadataByToken.size === 0)
+                        return value.apply(target, args);
+                    return self.callWithInterceptorChain({
+                        target,
+                        methodName: propertyKey,
+                        moduleName,
+                        args,
+                        metadataByToken,
+                        interceptors,
+                        proceed: () => value.apply(target, args),
+                    });
+                };
+                wrappers.set(propertyKey, wrapped);
+                return wrapped;
+            },
+        });
+    }
+    callWithInterceptorChain({ target, methodName, moduleName, args, metadataByToken, interceptors, proceed, }) {
+        const invoke = (index, next) => {
+            if (index >= interceptors.length)
+                return next();
+            const current = interceptors[index];
+            if (!current)
+                return next();
+            const metadata = metadataByToken.get(current.token.stateSymbol);
+            if (metadata === undefined) {
+                return invoke(index + 1, next);
+            }
+            const interceptorName = current.constructor.name;
+            const callInterceptor = () => current.intercept({
+                target,
+                methodName,
+                args,
+                moduleName,
+                metadata: metadata.method,
+                decoratorState: metadata.state,
+                proceed: () => invoke(index + 1, next),
+            });
+            if (!this.devtoolsTracer)
+                return callInterceptor();
+            return this.devtoolsTracer.recordSpan({
+                kind: "interceptor",
+                moduleName,
+                providerKey: interceptorName,
+                methodName: String(methodName),
+                args,
+                callback: callInterceptor,
+            });
+        };
+        return invoke(0, proceed);
+    }
+    get devtoolsTracer() {
+        return this.devtoolsProcessorRef.current?.tracer;
+    }
+}

package/dist/lib/di/processors/keyed-feature-registrar.d.ts

@@ -0,0 +1,19 @@
+import * as Awilix from "awilix";
+import type { RegisteredModuleScope } from "../contexts/container-context-base.js";
+import type { InternalModuleLike as M } from "../modules/runtime-module.types.js";
+type KeyedFeatureKind = "queryPreHandlers" | "commandPreHandlers" | "interceptors" | "initializers";
+type RegisterKeyedFeatureParams = {
+    featureKind: KeyedFeatureKind;
+    module: M;
+    scope: Awilix.AwilixContainer;
+    importedModulesWithScope: RegisteredModuleScope[];
+};
+export declare class KeyedFeatureRegistrar {
+    private readonly providerOptions;
+    constructor(providerOptions: Partial<Awilix.BuildResolverOptions<any>>);
+    private readonly featureConfig;
+    register<T>({ featureKind, module, scope, importedModulesWithScope, }: RegisterKeyedFeatureParams): Map<string, () => T>;
+    private getProviderOptions;
+    private ensureInitializerTokenUniqueness;
+}
+export {};

package/dist/lib/di/processors/keyed-feature-registrar.js

@@ -0,0 +1,112 @@
+import * as Awilix from "awilix";
+import * as ERRORS from "../errors.js";
+import { ProviderResolver } from "../providers/provider-resolver.js";
+import { getOrCreateRequestScope, resolveFromRequestScope, } from "../request-scope-context.js";
+export class KeyedFeatureRegistrar {
+    providerOptions;
+    constructor(providerOptions) {
+        this.providerOptions = providerOptions;
+    }
+    featureConfig = {
+        queryPreHandlers: {
+            exportKey: "queryPreHandlerExports",
+            featureName: "pre-handler",
+        },
+        commandPreHandlers: {
+            exportKey: "commandPreHandlerExports",
+            featureName: "pre-handler",
+        },
+        interceptors: {
+            exportKey: "interceptorExports",
+            featureName: "interceptor",
+        },
+        initializers: {
+            exportKey: "initializerExports",
+            featureName: "initializer",
+        },
+    };
+    register({ featureKind, module, scope, importedModulesWithScope, }) {
+        const ownerByKey = new Map();
+        const resolverMap = new Map();
+        const ownerByInitializerToken = new Map();
+        const config = this.featureConfig[featureKind];
+        const providerResolver = new ProviderResolver(undefined, this.getProviderOptions(featureKind), {}, getOrCreateRequestScope);
+        for (const { module: importedModule, moduleScope: importedModuleScope, } of importedModulesWithScope) {
+            for (const key of importedModule[config.exportKey] ?? []) {
+                const feature = importedModule[featureKind]?.[key];
+                if (!feature) {
+                    throw new ERRORS.InvalidProviderDefinitionError(importedModule.name, key);
+                }
+                if (ownerByKey.has(key)) {
+                    throw new ERRORS.FeatureNameConflictError(module.name, config.featureName, key, ownerByKey.get(key) ?? importedModule.name);
+                }
+                const symbol = Symbol(`${featureKind}_export_${importedModule.name}_${key}`);
+                scope.register({
+                    [symbol]: providerResolver.resolveClassProvider({
+                        provider: feature,
+                        resolutionScope: importedModuleScope.scope,
+                        module: importedModule,
+                        wrapForExport: true,
+                    }),
+                });
+                if (featureKind === "initializers") {
+                    this.ensureInitializerTokenUniqueness({
+                        scope,
+                        symbol,
+                        ownerByInitializerToken,
+                        moduleName: module.name,
+                        featureName: feature.name || key,
+                    });
+                }
+                resolverMap.set(key, featureKind === "initializers"
+                    ? () => scope.resolve(symbol)
+                    : () => resolveFromRequestScope(scope, symbol));
+                ownerByKey.set(key, importedModule.name);
+            }
+        }
+        for (const [key, feature] of Object.entries(module[featureKind] ?? {})) {
+            if (ownerByKey.has(key)) {
+                throw new ERRORS.FeatureNameConflictError(module.name, config.featureName, key, ownerByKey.get(key) ?? module.name);
+            }
+            const symbol = Symbol(`${featureKind}_${module.name}_${key}`);
+            scope.register({
+                [symbol]: providerResolver.resolveClassProvider({
+                    provider: feature,
+                    resolutionScope: scope,
+                    module,
+                }),
+            });
+            if (featureKind === "initializers") {
+                this.ensureInitializerTokenUniqueness({
+                    scope,
+                    symbol,
+                    ownerByInitializerToken,
+                    moduleName: module.name,
+                    featureName: feature.name || key,
+                });
+            }
+            resolverMap.set(key, featureKind === "initializers"
+                ? () => scope.resolve(symbol)
+                : () => resolveFromRequestScope(scope, symbol));
+            ownerByKey.set(key, module.name);
+        }
+        return resolverMap;
+    }
+    getProviderOptions(featureKind) {
+        if (featureKind === "initializers") {
+            return {
+                lifetime: Awilix.Lifetime.SINGLETON,
+            };
+        }
+        return this.providerOptions;
+    }
+    ensureInitializerTokenUniqueness({ scope, symbol, ownerByInitializerToken, moduleName, featureName, }) {
+        const initializer = scope.resolve(symbol);
+        const token = initializer.token.stateSymbol;
+        const existingModuleName = ownerByInitializerToken.get(token);
+        if (existingModuleName) {
+            throw new ERRORS.DuplicateInitializerTokenError(moduleName, featureName, existingModuleName);
+        }
+        ownerByInitializerToken.set(token, moduleName);
+    }
+}

package/dist/lib/di/processors/lifecycle-processor.d.ts

@@ -0,0 +1,37 @@
+import * as Awilix from "awilix";
+import type { InternalModuleLike as M } from "../modules/runtime-module.types.js";
+import type { InitializerTask } from "./initializer-processor.js";
+export interface ModuleInitOptions {
+    excludeInitializers?: true | readonly string[];
+    excludePostInit?: true | readonly string[];
+}
+export interface LifecycleMethods {
+    init(options?: ModuleInitOptions): Promise<void>;
+    dispose(): Promise<void>;
+}
+export declare class LifecycleProcessor {
+    private readonly providerOptions;
+    private readonly eagerProviderRefs;
+    private readonly initializerTasks;
+    private readonly createdScopes;
+    private initPromise?;
+    private disposePromise?;
+    constructor(providerOptions: Partial<Awilix.BuildResolverOptions<any>>);
+    collectEagerProviders(m: M, scope: Awilix.AwilixContainer): void;
+    trackScope(scope: Awilix.AwilixContainer): void;
+    addInitializerTask(task: InitializerTask | null): void;
+    init(options?: ModuleInitOptions): Promise<void>;
+    dispose(): Promise<void>;
+    private executeInit;
+    private executeDispose;
+    private shouldSkipProviderPostInit;
+    private getEagerProviderKeys;
+    private ensureEagerProviderUsesSingletonLifetime;
+    private resolveEagerProvider;
+    private callProviderInitAsync;
+    private callProviderPostInitAsync;
+    private sortEagerProviderRefs;
+    private getProviderInitAfter;
+    private sortEagerProviderIds;
+    private static buildEagerProviderNodeKeyMap;
+}

package/dist/lib/di/processors/lifecycle-processor.js

@@ -0,0 +1,175 @@
+import * as Awilix from "awilix";
+import * as ERRORS from "../errors.js";
+import * as GUARGS from "../type-guards.js";
+export class LifecycleProcessor {
+    providerOptions;
+    eagerProviderRefs = [];
+    initializerTasks = [];
+    createdScopes = [];
+    initPromise;
+    disposePromise;
+    constructor(providerOptions) {
+        this.providerOptions = providerOptions;
+    }
+    collectEagerProviders(m, scope) {
+        for (const key of this.getEagerProviderKeys(m)) {
+            this.eagerProviderRefs.push({
+                module: m,
+                scope,
+                key,
+            });
+        }
+    }
+    trackScope(scope) {
+        this.createdScopes.push(scope);
+    }
+    addInitializerTask(task) {
+        if (!task)
+            return;
+        this.initializerTasks.push(task);
+    }
+    init(options) {
+        this.initPromise ??= this.executeInit(options);
+        return this.initPromise;
+    }
+    dispose() {
+        this.disposePromise ??= this.executeDispose();
+        return this.disposePromise;
+    }
+    async executeInit(options) {
+        const initializedProviders = [];
+        for (const { module, scope, key } of this.sortEagerProviderRefs()) {
+            this.ensureEagerProviderUsesSingletonLifetime(module, scope, key);
+            const instance = await this.resolveEagerProvider({
+                module,
+                scope,
+                key,
+            });
+            initializedProviders.push({ module, scope, key, instance });
+            await this.callProviderInitAsync(instance);
+        }
+        for (const initialize of this.initializerTasks) {
+            await initialize(options);
+        }
+        for (const { key, instance } of initializedProviders) {
+            if (this.shouldSkipProviderPostInit(key, options))
+                continue;
+            await this.callProviderPostInitAsync(instance);
+        }
+    }
+    async executeDispose() {
+        const uniqueScopes = Array.from(new Set(this.createdScopes)).reverse();
+        for (const scope of uniqueScopes) {
+            await scope.dispose();
+        }
+    }
+    shouldSkipProviderPostInit(key, options) {
+        if (options?.excludePostInit === true)
+            return true;
+        if (!Array.isArray(options?.excludePostInit))
+            return false;
+        return new Set(options.excludePostInit).has(key);
+    }
+    getEagerProviderKeys(m) {
+        return Object.entries(m.providers || {})
+            .filter(([, provider]) => GUARGS.isEagerProvider(provider))
+            .map(([key]) => key);
+    }
+    ensureEagerProviderUsesSingletonLifetime(m, scope, key) {
+        if (scope.registrations[key]?.lifetime !== Awilix.Lifetime.SINGLETON) {
+            throw new ERRORS.EagerProviderRequiresSingletonLifetimeError(m.name, key);
+        }
+    }
+    async resolveEagerProvider({ module, scope, key, }) {
+        const provider = module.providers?.[key];
+        if (!provider ||
+            !GUARGS.isFactoryProvider(provider) ||
+            !GUARGS.isAsyncFactoryProvider(provider)) {
+            return scope.resolve(key);
+        }
+        const factoryDeps = (provider.inject || []).map((dependencyKey) => scope.registrations[dependencyKey].resolve(scope));
+        const resolvedValue = await provider.useFactory(...factoryDeps);
+        const { eager, initAfter, inject, useFactory, ...providerResolverOptions } = provider;
+        const resolverOptions = {
+            ...this.providerOptions,
+            ...module.providerOptions,
+            ...providerResolverOptions,
+        };
+        scope.register({
+            [key]: Awilix.asFunction(() => resolvedValue, resolverOptions),
+        });
+        return scope.resolve(key);
+    }
+    async callProviderInitAsync(instance) {
+        if (!GUARGS.hasProviderInit(instance))
+            return;
+        await instance.init();
+    }
+    async callProviderPostInitAsync(instance) {
+        if (!GUARGS.hasProviderPostInit(instance))
+            return;
+        await instance.postInit();
+    }
+    sortEagerProviderRefs() {
+        const nodes = this.eagerProviderRefs.map((ref) => ({
+            ...ref,
+            id: `${ref.module.name}:${ref.key}`,
+            initAfter: this.getProviderInitAfter(ref.module, ref.key),
+        }));
+        const nodeById = new Map(nodes.map((node) => [node.id, node]));
+        const nodeByKey = LifecycleProcessor.buildEagerProviderNodeKeyMap(nodes);
+        const graph = new Map(nodes.map((node) => [node.id, []]));
+        const inDegree = new Map(nodes.map((node) => [node.id, 0]));
+        for (const node of nodes) {
+            for (const dependencyKey of node.initAfter) {
+                const dependencyNode = nodeByKey.get(dependencyKey);
+                if (!dependencyNode) {
+                    throw new ERRORS.EagerProviderInitDependencyNotFoundError(node.module.name, node.key, dependencyKey);
+                }
+                const dependencies = graph.get(dependencyNode.id);
+                if (!dependencies)
+                    continue;
+                dependencies.push(node.id);
+                inDegree.set(node.id, (inDegree.get(node.id) || 0) + 1);
+            }
+        }
+        const sortedIds = this.sortEagerProviderIds(graph, inDegree);
+        if (sortedIds.length !== nodes.length) {
+            throw new ERRORS.CircularProviderInitDependencyError(nodes.map((node) => node.key));
+        }
+        return sortedIds.map((id) => {
+            const { module, scope, key } = nodeById.get(id);
+            return { module, scope, key };
+        });
+    }
+    getProviderInitAfter(module, key) {
+        const provider = module.providers?.[key];
+        if (!GUARGS.hasInitAfter(provider))
+            return [];
+        return [...provider.initAfter];
+    }
+    sortEagerProviderIds(graph, inDegree) {
+        const queue = Array.from(inDegree.entries())
+            .filter(([, degree]) => degree === 0)
+            .map(([id]) => id);
+        const sortedIds = [];
+        while (queue.length > 0) {
+            const current = queue.shift();
+            sortedIds.push(current);
+            for (const dependent of graph.get(current) || []) {
+                const nextDegree = (inDegree.get(dependent) || 0) - 1;
+                inDegree.set(dependent, nextDegree);
+                if (nextDegree === 0)
+                    queue.push(dependent);
+            }
+        }
+        return sortedIds;
+    }
+    static buildEagerProviderNodeKeyMap(nodes) {
+        const nodeByKey = new Map();
+        for (const node of nodes) {
+            nodeByKey.set(node.key, node);
+        }
+        return nodeByKey;
+    }
+}

package/dist/lib/di/processors/overrides-processor.d.ts

@@ -0,0 +1,24 @@
+import type { AnyModuleOverride } from "../modules/module-overrides.js";
+import type { InternalModuleLike } from "../modules/runtime-module.types.js";
+export type OverrideOptions = {
+    moduleOverrides?: readonly AnyModuleOverride[];
+};
+export declare const FeatureKind: {
+    readonly Providers: "providers";
+    readonly QueryPreHandlers: "queryPreHandlers";
+    readonly CommandPreHandlers: "commandPreHandlers";
+    readonly Interceptors: "interceptors";
+    readonly Initializers: "initializers";
+};
+export declare class OverridesProcessor<M extends InternalModuleLike> {
+    private readonly options;
+    private readonly effectiveModuleMap;
+    private readonly appliedModuleOverrides;
+    constructor(options: OverrideOptions);
+    applyModuleOverrides(module: M): M;
+    getModuleWithOverrides(module: M): M;
+    ensureAllModuleOverridesApplied(): void;
+    private ensureModuleOverrideKeysExist;
+    private remapFeatureOverrides;
+    private ensureFeatureOverrideKeysExist;
+}

package/dist/lib/di/processors/overrides-processor.js

@@ -0,0 +1,69 @@
+import * as ERRORS from "../errors.js";
+export const FeatureKind = {
+    Providers: "providers",
+    QueryPreHandlers: "queryPreHandlers",
+    CommandPreHandlers: "commandPreHandlers",
+    Interceptors: "interceptors",
+    Initializers: "initializers",
+};
+const FEATURE_KINDS = Object.values(FeatureKind);
+export class OverridesProcessor {
+    options;
+    effectiveModuleMap = new WeakMap();
+    appliedModuleOverrides = new WeakSet();
+    constructor(options) {
+        this.options = options;
+    }
+    applyModuleOverrides(module) {
+        const moduleOverride = this.options.moduleOverrides?.find((override) => override.module === module);
+        if (!moduleOverride) {
+            this.effectiveModuleMap.set(module, module);
+            return module;
+        }
+        this.ensureModuleOverrideKeysExist(module, moduleOverride);
+        this.appliedModuleOverrides.add(module);
+        const remappedFeatures = FEATURE_KINDS.reduce((acc, featureKind) => {
+            Object.assign(acc, this.remapFeatureOverrides(module, moduleOverride, featureKind));
+            return acc;
+        }, {});
+        const effectiveModule = {
+            ...module,
+            ...remappedFeatures,
+        };
+        this.effectiveModuleMap.set(module, effectiveModule);
+        return effectiveModule;
+    }
+    getModuleWithOverrides(module) {
+        return this.effectiveModuleMap.get(module) ?? module;
+    }
+    ensureAllModuleOverridesApplied() {
+        for (const override of this.options.moduleOverrides ?? []) {
+            if (!this.appliedModuleOverrides.has(override.module)) {
+                throw new ERRORS.ModuleOverrideTargetNotFoundError(override.module.name);
+            }
+        }
+    }
+    ensureModuleOverrideKeysExist(module, moduleOverride) {
+        for (const featureKind of FEATURE_KINDS) {
+            this.ensureFeatureOverrideKeysExist(module, featureKind, moduleOverride.overrides[featureKind]);
+        }
+    }
+    remapFeatureOverrides(module, moduleOverride, featureKind) {
+        return {
+            [featureKind]: {
+                ...module[featureKind],
+                ...moduleOverride.overrides[featureKind],
+            },
+        };
+    }
+    ensureFeatureOverrideKeysExist(module, featureKind, overrides) {
+        if (!overrides)
+            return;
+        const featureKeys = new Set(Object.keys(module[featureKind] || {}));
+        for (const key of Object.keys(overrides)) {
+            if (!featureKeys.has(key)) {
+                throw new ERRORS.ModuleFeatureOverrideNotFoundError(module.name, featureKind, key);
+            }
+        }
+    }
+}