awilixify 2.2.1 → 3.0.0

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

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

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

@@ -0,0 +1,13 @@
+import * as Awilix from "awilix";
+import type { InternalModuleLike as M } from "../modules/runtime-module.types.js";
+import type { ControllerRuntimeEntry } from "./initializer-processor.js";
+import type { InterceptorProcessor } from "./interceptor-processor.js";
+export declare class ControllerProcessor {
+    private readonly interceptorProcessor;
+    private readonly providerOptions;
+    private readonly skipRegisterRoutes;
+    private readonly registeredControllers;
+    constructor(interceptorProcessor: InterceptorProcessor, providerOptions: Partial<Awilix.BuildResolverOptions<any>>, skipRegisterRoutes: boolean);
+    processControllers(m: M, diScope: Awilix.AwilixContainer): ControllerRuntimeEntry[];
+    private resolveBySymbol;
+}

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

@@ -0,0 +1,76 @@
+import * as Awilix from "awilix";
+import * as ERRORS from "../errors.js";
+import { resolveFromRequestScope } from "../request-scope-context.js";
+import { hasUseClass } from "../type-guards.js";
+export class ControllerProcessor {
+    interceptorProcessor;
+    providerOptions;
+    skipRegisterRoutes;
+    registeredControllers = new WeakMap();
+    constructor(interceptorProcessor, providerOptions, skipRegisterRoutes) {
+        this.interceptorProcessor = interceptorProcessor;
+        this.providerOptions = providerOptions;
+        this.skipRegisterRoutes = skipRegisterRoutes;
+    }
+    processControllers(m, diScope) {
+        if (!m.controllers?.length)
+            return [];
+        if (m.registerControllers === false)
+            return [];
+        const runtimeEntries = [];
+        if (new Set(m.controllers).size !== m.controllers.length) {
+            throw new ERRORS.DuplicateControllersInModuleError(m.name);
+        }
+        for (const c of m.controllers) {
+            const { useClass, ...awilixOptions } = hasUseClass(c)
+                ? c
+                : { useClass: c };
+            const existingModule = this.registeredControllers.get(useClass);
+            if (!existingModule) {
+                this.registeredControllers.set(useClass, m);
+                const controllerSymbol = Symbol(`controller_${useClass.name}`);
+                const options = {
+                    ...this.providerOptions,
+                    ...m.providerOptions,
+                    ...awilixOptions,
+                };
+                const isWithNewScope = options.lifetime !== Awilix.Lifetime.SINGLETON;
+                const baseResolver = Awilix.asClass(useClass, {
+                    ...options,
+                    ...(isWithNewScope && {
+                        injector: () => ({
+                            resolveSelf: () => this.resolveBySymbol(controllerSymbol, diScope, isWithNewScope),
+                        }),
+                    }),
+                });
+                diScope.register({
+                    [controllerSymbol]: this.interceptorProcessor.createInterceptedProviderResolver({
+                        module: m,
+                        useClass,
+                        options,
+                        resolver: baseResolver,
+                    }),
+                });
+                if (!this.skipRegisterRoutes &&
+                    typeof useClass.prototype.registerRoutes === "function") {
+                    baseResolver.resolve(diScope).registerRoutes();
+                }
+                runtimeEntries.push({
+                    controllerClass: useClass,
+                    resolve: () => this.resolveBySymbol(controllerSymbol, diScope, isWithNewScope),
+                });
+                continue;
+            }
+            if (existingModule === m) {
+                continue;
+            }
+            throw new ERRORS.ControllerAlreadyRegisteredError(useClass.name, existingModule.name);
+        }
+        return runtimeEntries;
+    }
+    resolveBySymbol(symbol, scope, withNewScope) {
+        if (withNewScope)
+            return resolveFromRequestScope(scope, symbol);
+        return scope.resolve(symbol);
+    }
+}

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

@@ -0,0 +1,15 @@
+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";
+export declare const HandlerType: {
+    readonly Query: "query";
+    readonly Command: "command";
+};
+export type HandlerType = (typeof HandlerType)[keyof typeof HandlerType];
+export declare class HandlerProcessor {
+    private readonly providerOptions;
+    private readonly keyedFeatureRegistrar;
+    private static readonly handlerConfig;
+    constructor(providerOptions: Partial<Awilix.BuildResolverOptions<any>>);
+    processHandlers(m: M, scope: Awilix.AwilixContainer, importedModulesWithScope: RegisteredModuleScope[], handlerType: HandlerType): void;
+}

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

@@ -0,0 +1,69 @@
+import * as Awilix from "awilix";
+import { Mediator } from "../../mediator/mediator.js";
+import * as ERRORS from "../errors.js";
+import { ProviderResolver } from "../providers/provider-resolver.js";
+import { getOrCreateRequestScope } from "../request-scope-context.js";
+import { hasUseClass } from "../type-guards.js";
+import { KeyedFeatureRegistrar } from "./keyed-feature-registrar.js";
+export const HandlerType = {
+    Query: "query",
+    Command: "command",
+};
+export class HandlerProcessor {
+    providerOptions;
+    keyedFeatureRegistrar;
+    static handlerConfig = {
+        query: {
+            handlersKey: "queryHandlers",
+            preHandlersKey: "queryPreHandlers",
+            mediatorKey: "queryMediator",
+        },
+        command: {
+            handlersKey: "commandHandlers",
+            preHandlersKey: "commandPreHandlers",
+            mediatorKey: "commandMediator",
+        },
+    };
+    constructor(providerOptions) {
+        this.providerOptions = providerOptions;
+        this.keyedFeatureRegistrar = new KeyedFeatureRegistrar(providerOptions);
+    }
+    processHandlers(m, scope, importedModulesWithScope, handlerType) {
+        const { handlersKey, mediatorKey, preHandlersKey } = HandlerProcessor.handlerConfig[handlerType];
+        const middlewareResolvers = this.keyedFeatureRegistrar.register({
+            featureKind: preHandlersKey,
+            module: m,
+            scope,
+            importedModulesWithScope,
+        });
+        const handlers = m[handlersKey];
+        if (!handlers?.length)
+            return;
+        const mediator = new Mediator(middlewareResolvers, m.name);
+        for (const h of handlers) {
+            const { useClass: HandlerClass, ...handlerOptions } = hasUseClass(h)
+                ? h
+                : { useClass: h };
+            const handlerKey = HandlerClass.key;
+            if (typeof handlerKey !== "string" || !handlerKey.length) {
+                throw new ERRORS.HandlerMissingStaticKeyError(HandlerClass.name);
+            }
+            const options = ProviderResolver.mergeResolverOptions(m, this.providerOptions, handlerOptions);
+            const handlerSymbol = Symbol(`${handlerKey}_${HandlerClass.name}`);
+            scope.register({
+                [handlerSymbol]: Awilix.asClass(HandlerClass, options),
+            });
+            mediator.register(handlerKey, (payload, context) => {
+                const requestScope = options.lifetime === Awilix.Lifetime.SINGLETON
+                    ? scope
+                    : getOrCreateRequestScope(scope);
+                return requestScope
+                    .resolve(handlerSymbol)
+                    .executor(payload, context);
+            });
+        }
+        scope.register({
+            [mediatorKey]: Awilix.asValue(mediator),
+        });
+    }
+}

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

@@ -0,0 +1,19 @@
+import type * as Awilix from "awilix";
+import type { RegisteredModuleScope } from "../contexts/container-context-base.js";
+import type { InternalModuleLike as M } from "../modules/runtime-module.types.js";
+import type { ConstructorController } from "../providers/provider.types.js";
+import type { ModuleInitOptions } from "./lifecycle-processor.js";
+export type ControllerRuntimeEntry = {
+    controllerClass: ConstructorController;
+    resolve: () => any;
+};
+export type InitializerTask = (options?: ModuleInitOptions) => Promise<void>;
+export declare class InitializerProcessor {
+    private readonly keyedFeatureRegistrar;
+    private readonly resolversByModule;
+    collectInitializers(m: M, scope: Awilix.AwilixContainer, importedModulesWithScope: RegisteredModuleScope[], controllers: ControllerRuntimeEntry[]): InitializerTask | null;
+    private ensureNoMultiInvokableInitializersPerMethod;
+    private filterActiveInitializers;
+    private processInitializerResolvers;
+    private getControllerMethodNames;
+}

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

@@ -0,0 +1,91 @@
+import { resolveDecoratorState } from "../../decorators/decorator-state.js";
+import * as ERRORS from "../errors.js";
+import { runInRequestScopeContext } from "../request-scope-context.js";
+import { KeyedFeatureRegistrar } from "./keyed-feature-registrar.js";
+export class InitializerProcessor {
+    keyedFeatureRegistrar = new KeyedFeatureRegistrar({});
+    resolversByModule = new WeakMap();
+    collectInitializers(m, scope, importedModulesWithScope, controllers) {
+        this.processInitializerResolvers(m, scope, importedModulesWithScope);
+        const initializers = [
+            ...(this.resolversByModule.get(m) ??
+                new Map()).entries(),
+        ];
+        if (initializers.length === 0 || controllers.length === 0)
+            return null;
+        return async (options) => {
+            const activeInitializers = this.filterActiveInitializers(initializers, options);
+            if (activeInitializers.length === 0)
+                return;
+            for (const controller of controllers) {
+                for (const methodName of this.getControllerMethodNames(controller.controllerClass)) {
+                    const invoke = (...args) => 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));
+    }
+    processInitializerResolvers(m, scope, importedModulesWithScope) {
+        this.resolversByModule.set(m, this.keyedFeatureRegistrar.register({
+            featureKind: "initializers",
+            module: m,
+            scope,
+            importedModulesWithScope,
+        }));
+    }
+    getControllerMethodNames(controllerClass) {
+        const collected = new Set();
+        let proto = controllerClass.prototype;
+        while (proto && proto !== Object.prototype) {
+            Object.getOwnPropertyNames(proto)
+                .filter((name) => name !== "constructor" && typeof proto[name] === "function")
+                .forEach((name) => {
+                collected.add(name);
+            });
+            Object.getOwnPropertySymbols(proto)
+                .filter((symbol) => typeof proto[symbol] === "function")
+                .forEach((symbol) => {
+                collected.add(symbol);
+            });
+            proto = Object.getPrototypeOf(proto);
+        }
+        return [...collected];
+    }
+}

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

@@ -0,0 +1,18 @@
+import * as Awilix from "awilix";
+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 keyedFeatureRegistrar;
+    private readonly resolversByModule;
+    constructor(providerOptions: DiContextOptions["providerOptions"]);
+    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;
+}

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

@@ -0,0 +1,101 @@
+import * as Awilix from "awilix";
+import { hasDecoratorMethodMetadata, resolveDecoratorState, } from "../../decorators/decorator-state.js";
+import { KeyedFeatureRegistrar } from "./keyed-feature-registrar.js";
+export class InterceptorProcessor {
+    keyedFeatureRegistrar;
+    resolversByModule = new WeakMap();
+    constructor(providerOptions) {
+        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);
+            }
+            return current.intercept({
+                target,
+                methodName,
+                args,
+                moduleName,
+                metadata: metadata.method,
+                decoratorState: metadata.state,
+                proceed: () => invoke(index + 1, next),
+            });
+        };
+        return invoke(0, proceed);
+    }
+}

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,38 @@
+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;
+    private static createEagerProviderId;
+}