@venok/core 1.0.1-canary.5 → 2.0.0

package/dist/scanner.js

@@ -0,0 +1,371 @@
+import { createRequire } from "node:module";
+var __legacyDecorateClassTS = function(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+    r = Reflect.decorate(decorators, target, key, desc);
+  else
+    for (var i = decorators.length - 1;i >= 0; i--)
+      if (d = decorators[i])
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __legacyDecorateParamTS = (index, decorator) => (target, key) => decorator(target, key, index);
+var __legacyMetadataTS = (k, v) => {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
+    return Reflect.metadata(k, v);
+};
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// packages/core/src/scanner.ts
+import {
+  APP_FILTER,
+  APP_GUARD,
+  APP_INTERCEPTOR,
+  APP_PIPE,
+  CATCH_WATERMARK,
+  ENHANCER_KEY_TO_SUBTYPE_MAP,
+  ENHANCER_TOKEN_TO_SUBTYPE_MAP,
+  EXCEPTION_FILTERS_METADATA,
+  GUARDS_METADATA,
+  INJECTABLE_WATERMARK,
+  INTERCEPTORS_METADATA,
+  MODULE_METADATA,
+  PIPES_METADATA,
+  ROUTE_ARGS_METADATA
+} from "./constants.js";
+import { ApplicationConfig } from "./application/config.js";
+import { CircularDependencyException } from "./errors/exceptions/circular-dependency.exception.js";
+import { InvalidClassModuleException } from "./errors/exceptions/invalid-class-module.exception.js";
+import { InvalidModuleException } from "./errors/exceptions/invalid-module.exception.js";
+import { UndefinedModuleException } from "./errors/exceptions/undefined-module.exception.js";
+import { InternalCoreModuleFactory } from "./injector/internal-core-module/internal-core-module-factory.js";
+import { getClassScope } from "./injector/helpers/class-scope.helper.js";
+import { TopologyTree } from "./injector/topology-tree/topology-tree.js";
+import { flatten } from "./helpers/flatten.helper.js";
+import { isFunction, isNull, isUndefined } from "./helpers/shared.helper.js";
+import { UuidFactory } from "./helpers/uuid.helper.js";
+import { Scope } from "./enums/scope.enum.js";
+
+class DependenciesScanner {
+  container;
+  metadataScanner;
+  graphInspector;
+  applicationConfig;
+  applicationProvidersApplyMap = [];
+  constructor(container, metadataScanner, graphInspector, applicationConfig = new ApplicationConfig) {
+    this.container = container;
+    this.metadataScanner = metadataScanner;
+    this.graphInspector = graphInspector;
+    this.applicationConfig = applicationConfig;
+  }
+  async scan(module, options) {
+    await this.registerCoreModule(options?.overrides);
+    await this.scanForModules({
+      moduleDefinition: module,
+      overrides: options?.overrides
+    });
+    await this.scanModulesForDependencies();
+    this.addScopedEnhancersMetadata();
+    this.calculateModulesDistance();
+    this.container.bindGlobalScope();
+  }
+  async scanForModules({
+    moduleDefinition,
+    lazy,
+    scope = [],
+    ctxRegistry = [],
+    overrides = []
+  }) {
+    const { moduleRef: moduleInstance, inserted: moduleInserted } = await this.insertOrOverrideModule(moduleDefinition, overrides, scope) ?? {};
+    moduleDefinition = this.getOverrideModuleByModule(moduleDefinition, overrides)?.newModule ?? moduleDefinition;
+    moduleDefinition = moduleDefinition instanceof Promise ? await moduleDefinition : moduleDefinition;
+    ctxRegistry.push(moduleDefinition);
+    if (this.isForwardReference(moduleDefinition)) {
+      moduleDefinition = moduleDefinition.forwardRef();
+    }
+    const modules = !this.isDynamicModule(moduleDefinition) ? this.reflectMetadata(MODULE_METADATA.IMPORTS, moduleDefinition) : [
+      ...this.reflectMetadata(MODULE_METADATA.IMPORTS, moduleDefinition.module),
+      ...moduleDefinition.imports || []
+    ];
+    let registeredModuleRefs = [];
+    for (const [index, innerModule] of modules.entries()) {
+      if (innerModule === undefined)
+        throw new UndefinedModuleException(moduleDefinition, index, scope);
+      if (!innerModule)
+        throw new InvalidModuleException(moduleDefinition, index, scope);
+      if (ctxRegistry.includes(innerModule))
+        continue;
+      const moduleRefs = await this.scanForModules({
+        moduleDefinition: innerModule,
+        scope: scope.concat(moduleDefinition),
+        ctxRegistry,
+        overrides,
+        lazy
+      });
+      registeredModuleRefs = registeredModuleRefs.concat(moduleRefs);
+    }
+    if (!moduleInstance)
+      return registeredModuleRefs;
+    if (lazy && moduleInserted)
+      this.container.bindGlobalsToImports(moduleInstance);
+    return [moduleInstance].concat(registeredModuleRefs);
+  }
+  async insertModule(moduleDefinition, scope) {
+    const moduleToAdd = this.isForwardReference(moduleDefinition) ? moduleDefinition.forwardRef() : moduleDefinition;
+    if (this.isInjectable(moduleToAdd) || this.isExceptionFilter(moduleToAdd)) {
+      throw new InvalidClassModuleException(moduleDefinition, scope);
+    }
+    return this.container.addModule(moduleToAdd, scope);
+  }
+  async scanModulesForDependencies(modules = this.container.getModules()) {
+    for (const [token, { metatype }] of modules) {
+      await this.reflectImports(metatype, token, metatype.name);
+      this.reflectProviders(metatype, token);
+      this.reflectExports(metatype, token);
+    }
+  }
+  async reflectImports(module, token, context) {
+    const modules = [
+      ...this.reflectMetadata(MODULE_METADATA.IMPORTS, module),
+      ...this.container.getDynamicMetadataByToken(token, MODULE_METADATA.IMPORTS)
+    ];
+    for (const related of modules) {
+      await this.insertImport(related, token, context);
+    }
+  }
+  reflectProviders(module, token) {
+    const providers = [
+      ...this.reflectMetadata(MODULE_METADATA.PROVIDERS, module),
+      ...this.container.getDynamicMetadataByToken(token, MODULE_METADATA.PROVIDERS)
+    ];
+    providers.forEach((provider) => {
+      this.insertProvider(provider, token);
+      this.reflectDynamicMetadata(provider, token);
+    });
+  }
+  reflectDynamicMetadata(cls, token) {
+    if (!cls || !cls.prototype)
+      return;
+    this.reflectInjectables(cls, token, GUARDS_METADATA);
+    this.reflectInjectables(cls, token, INTERCEPTORS_METADATA);
+    this.reflectInjectables(cls, token, EXCEPTION_FILTERS_METADATA);
+    this.reflectInjectables(cls, token, PIPES_METADATA);
+    this.reflectParamInjectables(cls, token, ROUTE_ARGS_METADATA);
+  }
+  reflectExports(module, token) {
+    const exports = [
+      ...this.reflectMetadata(MODULE_METADATA.EXPORTS, module),
+      ...this.container.getDynamicMetadataByToken(token, MODULE_METADATA.EXPORTS)
+    ];
+    exports.forEach((exportedProvider) => this.insertExportedProviderOrModule(exportedProvider, token));
+  }
+  reflectInjectables(component, token, metadataKey) {
+    const Injectables = this.reflectMetadata(metadataKey, component);
+    const methodInjectables = this.metadataScanner.getAllMethodNames(component.prototype).reduce((acc, method) => {
+      const methodInjectable = this.reflectKeyMetadata(component, metadataKey, method);
+      if (methodInjectable)
+        acc.push(methodInjectable);
+      return acc;
+    }, []);
+    Injectables.forEach((injectable) => this.insertInjectable(injectable, token, component, ENHANCER_KEY_TO_SUBTYPE_MAP[metadataKey]));
+    methodInjectables.forEach((methodInjectable) => {
+      methodInjectable.metadata.forEach((injectable) => this.insertInjectable(injectable, token, component, ENHANCER_KEY_TO_SUBTYPE_MAP[metadataKey], methodInjectable.methodKey));
+    });
+  }
+  reflectParamInjectables(component, token, metadataKey) {
+    const paramsMethods = this.metadataScanner.getAllMethodNames(component.prototype);
+    paramsMethods.forEach((methodKey) => {
+      const metadata = Reflect.getMetadata(metadataKey, component, methodKey);
+      if (!metadata)
+        return;
+      const params = Object.values(metadata);
+      params.map((item) => item.pipes).flat(1).forEach((injectable) => this.insertInjectable(injectable, token, component, "pipe", methodKey));
+    });
+  }
+  reflectKeyMetadata(component, key, methodKey) {
+    let prototype = component.prototype;
+    do {
+      const descriptor = Reflect.getOwnPropertyDescriptor(prototype, methodKey);
+      if (!descriptor)
+        continue;
+      const metadata = Reflect.getMetadata(key, descriptor.value);
+      if (!metadata)
+        return;
+      return { methodKey, metadata };
+    } while ((prototype = Reflect.getPrototypeOf(prototype)) && prototype !== Object.prototype && prototype);
+    return;
+  }
+  calculateModulesDistance() {
+    const modulesGenerator = this.container.getModules().values();
+    modulesGenerator.next();
+    const rootModule = modulesGenerator.next().value;
+    if (!rootModule)
+      return;
+    const tree = new TopologyTree(rootModule);
+    tree.walk((moduleRef, depth) => {
+      if (moduleRef.isGlobal)
+        return;
+      moduleRef.distance = depth;
+    });
+  }
+  async insertImport(related, token, context) {
+    if (isUndefined(related))
+      throw new CircularDependencyException(context);
+    if (this.isForwardReference(related))
+      return this.container.addImport(related.forwardRef(), token);
+    await this.container.addImport(related, token);
+  }
+  isCustomProvider(provider) {
+    return provider && !isNull(provider.provide);
+  }
+  insertProvider(provider, token) {
+    const isCustomProvider = this.isCustomProvider(provider);
+    if (!isCustomProvider)
+      return this.container.addProvider(provider, token);
+    const applyProvidersMap = this.getApplyProvidersMap();
+    const providersKeys = Object.keys(applyProvidersMap);
+    const type = provider.provide;
+    if (!providersKeys.includes(type))
+      return this.container.addProvider(provider, token);
+    const uuid = UuidFactory.get(type.toString());
+    const providerToken = `${type} (UUID: ${uuid})`;
+    let scope = provider.scope;
+    if (isNull(scope) && provider.useClass) {
+      scope = getClassScope(provider.useClass);
+    }
+    this.applicationProvidersApplyMap.push({
+      type,
+      moduleKey: token,
+      providerKey: providerToken,
+      scope
+    });
+    const newProvider = {
+      ...provider,
+      provide: providerToken,
+      scope
+    };
+    const enhancerSubtype = ENHANCER_TOKEN_TO_SUBTYPE_MAP[type];
+    const factoryOrClassProvider = newProvider;
+    if (this.isRequestOrTransient(factoryOrClassProvider.scope)) {
+      return this.container.addInjectable(newProvider, token, enhancerSubtype);
+    }
+    this.container.addProvider(newProvider, token, enhancerSubtype);
+  }
+  insertInjectable(injectable, token, host, subtype, methodKey) {
+    if (isFunction(injectable)) {
+      const instanceWrapper = this.container.addInjectable(injectable, token, subtype, host);
+      this.graphInspector.insertEnhancerMetadataCache({
+        moduleToken: token,
+        classRef: host,
+        enhancerInstanceWrapper: instanceWrapper,
+        targetNodeId: instanceWrapper.id,
+        subtype,
+        methodKey
+      });
+      return instanceWrapper;
+    } else {
+      this.graphInspector.insertEnhancerMetadataCache({
+        moduleToken: token,
+        classRef: host,
+        enhancerRef: injectable,
+        methodKey,
+        subtype
+      });
+    }
+  }
+  insertExportedProviderOrModule(toExport, token) {
+    const fulfilledProvider = this.isForwardReference(toExport) ? toExport.forwardRef() : toExport;
+    this.container.addExportedProviderOrModule(fulfilledProvider, token);
+  }
+  insertOrOverrideModule(moduleDefinition, overrides, scope) {
+    const overrideModule = this.getOverrideModuleByModule(moduleDefinition, overrides);
+    if (overrideModule !== undefined)
+      return this.overrideModule(moduleDefinition, overrideModule.newModule, scope);
+    return this.insertModule(moduleDefinition, scope);
+  }
+  getOverrideModuleByModule(module, overrides) {
+    if (this.isForwardReference(module)) {
+      return overrides.find((moduleToOverride) => {
+        return moduleToOverride.moduleToReplace === module.forwardRef() || moduleToOverride.moduleToReplace.forwardRef?.() === module.forwardRef();
+      });
+    }
+    return overrides.find((moduleToOverride) => moduleToOverride.moduleToReplace === module);
+  }
+  async overrideModule(moduleToOverride, newModule, scope) {
+    return this.container.replaceModule(this.isForwardReference(moduleToOverride) ? moduleToOverride.forwardRef() : moduleToOverride, this.isForwardReference(newModule) ? newModule.forwardRef() : newModule, scope);
+  }
+  reflectMetadata(metadataKey, metatype) {
+    return Reflect.getMetadata(metadataKey, metatype) || [];
+  }
+  async registerCoreModule(overrides) {
+    const moduleDefinition = InternalCoreModuleFactory.create(this.container, this, this.container.getModuleCompiler(), this.graphInspector, overrides);
+    const [instance] = await this.scanForModules({
+      moduleDefinition,
+      overrides
+    });
+    this.container.registerCoreModuleRef(instance);
+  }
+  addScopedEnhancersMetadata() {
+    this.applicationProvidersApplyMap.filter((wrapper) => this.isRequestOrTransient(wrapper.scope)).forEach(({ moduleKey, providerKey }) => {
+      const modulesContainer = this.container.getModules();
+      const { injectables } = modulesContainer.get(moduleKey);
+      const instanceWrapper = injectables.get(providerKey);
+      const iterableIterator = modulesContainer.values();
+      flatten([...iterableIterator].map((moduleRef) => moduleRef.entryProviders)).forEach((EntryProvider) => EntryProvider.addEnhancerMetadata(instanceWrapper));
+    });
+  }
+  applyApplicationProviders() {
+    const applyProvidersMap = this.getApplyProvidersMap();
+    const applyRequestProvidersMap = this.getApplyRequestProvidersMap();
+    const getInstanceWrapper = (moduleKey, providerKey, collectionKey) => {
+      const modules = this.container.getModules();
+      const collection = modules.get(moduleKey)[collectionKey];
+      return collection.get(providerKey);
+    };
+    this.applicationProvidersApplyMap.forEach(({ moduleKey, providerKey, type, scope }) => {
+      let instanceWrapper;
+      if (this.isRequestOrTransient(scope)) {
+        instanceWrapper = getInstanceWrapper(moduleKey, providerKey, "injectables");
+        this.graphInspector.insertAttachedEnhancer(instanceWrapper);
+        return applyRequestProvidersMap[type](instanceWrapper);
+      }
+      instanceWrapper = getInstanceWrapper(moduleKey, providerKey, "providers");
+      this.graphInspector.insertAttachedEnhancer(instanceWrapper);
+      applyProvidersMap[type](instanceWrapper.instance);
+    });
+  }
+  getApplyProvidersMap() {
+    return {
+      [APP_INTERCEPTOR]: (interceptor) => this.applicationConfig.addGlobalInterceptor(interceptor),
+      [APP_PIPE]: (pipe) => this.applicationConfig.addGlobalPipe(pipe),
+      [APP_GUARD]: (guard) => this.applicationConfig.addGlobalGuard(guard),
+      [APP_FILTER]: (filter) => this.applicationConfig.addGlobalFilter(filter)
+    };
+  }
+  getApplyRequestProvidersMap() {
+    return {
+      [APP_INTERCEPTOR]: (interceptor) => this.applicationConfig.addGlobalRequestInterceptor(interceptor),
+      [APP_PIPE]: (pipe) => this.applicationConfig.addGlobalRequestPipe(pipe),
+      [APP_GUARD]: (guard) => this.applicationConfig.addGlobalRequestGuard(guard),
+      [APP_FILTER]: (filter) => this.applicationConfig.addGlobalRequestFilter(filter)
+    };
+  }
+  isDynamicModule(module) {
+    return module && !!module.module;
+  }
+  isInjectable(metatype) {
+    return !!Reflect.getMetadata(INJECTABLE_WATERMARK, metatype);
+  }
+  isExceptionFilter(metatype) {
+    return !!Reflect.getMetadata(CATCH_WATERMARK, metatype);
+  }
+  isForwardReference(module) {
+    return module && !!module.forwardRef;
+  }
+  isRequestOrTransient(scope) {
+    return scope === Scope.REQUEST || scope === Scope.TRANSIENT;
+  }
+}
+export {
+  DependenciesScanner
+};