@rsdk/core 1.0.12 → 2.0.0

package/src/config/additional-source/additional-source.initializer.ts

@@ -1,16 +1,16 @@
 import { SELF_DECLARED_DEPS_METADATA } from '@nestjs/common/constants';
 import type { Constructor } from '@rsdk/common';
+import { LoggerFactory } from '@rsdk/logging';
 
 import { APP_NAME } from '../../app-metadata/app-metadata.const';
 import { NoInitException } from '../../exceptions';
+import type { ConfigContext } from '../context/config.context';
 import { ConfigPropertyMetadataNotFound } from '../exceptions';
 import { isPropertyToken } from '../metadata';
 import type { ConfigSource } from '../sources';
 import { ConfigSourceDIException, isReloadable } from '../sources';
 import type { RawValues } from '../types';
 
-import type { AdditionalSourceOptions } from './additional-source.module';
-
 /**
  * Содержит логику инициализации дополнительных источников конфигурации
  */
@@ -21,7 +21,12 @@ export class AdditionalSourceInitializer {
    */
   private initializePromise: Promise<void> | undefined;
 
-  constructor(private options: AdditionalSourceOptions) {}
+  private logger = LoggerFactory.create(AdditionalSourceInitializer);
+
+  constructor(
+    private context: ConfigContext,
+    private options: Constructor<ConfigSource>[],
+  ) {}
 
   /**
    * Инициализирует дополнительные источники конфигурации
@@ -37,7 +42,7 @@ export class AdditionalSourceInitializer {
     if (this.initializePromise) {
       return this.initializePromise;
     }
-    this.initializePromise = this.initializeAdditionalSources(this.options);
+    this.initializePromise = this.initializeAdditionalSources();
     return this.initializePromise;
   }
 
@@ -47,20 +52,23 @@ export class AdditionalSourceInitializer {
    * NOTE: standalone properties from env can be used to
    * configure additional sources
    */
-  private async initializeAdditionalSources(
-    options: AdditionalSourceOptions,
-  ): Promise<void> {
+  private async initializeAdditionalSources(): Promise<void> {
+    const options = { sources: this.options };
     if (!options.sources || options.sources.length === 0) {
-      options.logger.info('No additional sources configured');
+      this.logger.info('No additional sources configured');
       return;
     }
-    const { sources, events, logger, vars } = options;
+    const { sources } = options;
+
+    const { events, vars } = this.context;
+
+    const logger = this.logger;
 
     logger.info('Initializing additional configuration sources');
 
     for (const ctor of sources) {
       // We should restore the order to initialize for our ctor init later
-      const args = this.getConfigSourceArguments(options, ctor);
+      const args = this.getConfigSourceArguments(ctor);
 
       const source = new ctor(...args);
 
@@ -114,10 +122,7 @@ export class AdditionalSourceInitializer {
    * @param ctor
    * @private
    */
-  private getConfigSourceArguments(
-    options: AdditionalSourceOptions,
-    ctor: Constructor<ConfigSource>,
-  ): unknown[] {
+  private getConfigSourceArguments(ctor: Constructor<ConfigSource>): unknown[] {
     // Injectable config properties!
     const metadata = Reflect.getMetadata(SELF_DECLARED_DEPS_METADATA, ctor) as {
       index: number;
@@ -131,28 +136,32 @@ export class AdditionalSourceInitializer {
 
     const sortedMetadata = [...metadata].sort((a, b) => a.index - b.index);
 
-    const { prefix, propertyMetadata, vars } = options;
-    const injectables = new Map<unknown, unknown>().set(APP_NAME, prefix);
+    const injectables = new Map<unknown, unknown>().set(
+      APP_NAME,
+      this.context.prefix,
+    );
 
-    const args = sortedMetadata.map((x) => {
-      if (injectables.has(x.param)) {
-        return injectables.get(x.param);
+    const args = sortedMetadata.map((metadata) => {
+      if (injectables.has(metadata.param)) {
+        return injectables.get(metadata.param);
       }
 
-      if (!isPropertyToken(x.param)) {
-        throw new ConfigSourceDIException(ctor, x.param);
+      if (!isPropertyToken(metadata.param)) {
+        throw new ConfigSourceDIException(ctor, metadata.param);
       }
 
-      const propMeta = propertyMetadata.get(x.param);
+      const propMeta = this.context.standalonePropertyMetadata.get(
+        metadata.param,
+      );
       if (!propMeta) {
-        throw new ConfigPropertyMetadataNotFound(x.param);
+        throw new ConfigPropertyMetadataNotFound(metadata.param);
       }
 
-      const property = vars.extract(propMeta);
+      const property = this.context.vars.extract(propMeta);
       if (!property) {
         throw new NoInitException(
           'Config property',
-          x.param as string,
+          metadata.param as string,
           'You probably should add @DeclareProperty decorator to source class.',
         );
       }

package/src/config/additional-source/additional-source.module.ts

@@ -3,6 +3,7 @@ import type { Constructor } from '@rsdk/common';
 import type { ILogger } from '@rsdk/logging';
 
 import { ConfigReloadIndicator } from '../config-reload.indicator';
+import { ConfigContext } from '../context/config.context';
 import type { PropertyToken } from '../metadata';
 import type { ReloadEvents } from '../reload';
 import type { ConfigSource } from '../sources';
@@ -16,7 +17,7 @@ import { AdditionalSourceInitializer } from './additional-source.initializer';
  * Инициализирует все `source` в хуке `onModuleInit`
  */
 export class AdditionalSourceModule {
-  static forRoot(options: AdditionalSourceOptions): DynamicModule {
+  static forRoot(options: Constructor<ConfigSource>[]): DynamicModule {
     return {
       imports: [
         {
@@ -24,8 +25,10 @@ export class AdditionalSourceModule {
           module: AdditionalSourceModule,
           providers: [
             {
+              inject: [ConfigContext],
               provide: AdditionalSourceInitializer,
-              useValue: new AdditionalSourceInitializer(options),
+              useFactory: (configContext: ConfigContext) =>
+                new AdditionalSourceInitializer(configContext, options),
             },
           ],
           exports: [AdditionalSourceInitializer],

package/src/config/config-reload.indicator.ts

@@ -1,7 +1,8 @@
 import { Injectable } from '@nestjs/common';
 
-import type { CheckDetails, HealthIndicator } from '../health';
+import type { CheckDetails } from '../health/helpers';
 import { CheckResult } from '../health/helpers';
+import type { HealthIndicator } from '../health/types';
 
 import type { Config } from './config.abstract';
 import { ReloadEvents } from './reload';
@@ -9,10 +10,9 @@ import type { ConfigSource } from './sources';
 
 @Injectable()
 export class ConfigReloadIndicator implements HealthIndicator {
-  private events = ReloadEvents.getInstance();
   private errors = new Map<ConfigSource | Config, Error>();
 
-  constructor() {
+  constructor(private events: ReloadEvents) {
     this.events
       .on('reload_failure', (source, err) => this.errors.set(source, err))
       .on('update_failure', (config, err) => this.errors.set(config, err))

package/src/config/config.abstract.ts

@@ -3,7 +3,7 @@ import { intersection, isEqual } from 'lodash';
 import 'reflect-metadata';
 
 import { CONFIG_METADATA_KEY } from './metadata';
-import { ReloadEvents } from './reload';
+import type { ReloadEvents } from './reload';
 import type { PropertyMetadata, SectionMetadata } from './types';
 import type { Vars } from './vars.class';
 
@@ -18,10 +18,9 @@ export class Config {
    * Keys are prefixed and sources are added.
    */
   private readonly propertiesMetadata: Record<string, PropertyMetadata>;
-  private readonly events: ReloadEvents = ReloadEvents.getInstance();
 
   // TODO: why not to pass this.vars and event emitter?
-  constructor() {
+  constructor(private readonly events: ReloadEvents) {
     const metadata = Reflect.getMetadata(
       CONFIG_METADATA_KEY,
       this.constructor,

package/src/config/config.module.ts

@@ -1,25 +1,15 @@
 import type { DynamicModule, FactoryProvider, Provider } from '@nestjs/common';
-import { Module } from '@nestjs/common';
 import type { Constructor } from '@rsdk/common';
-import { dotenv } from '@rsdk/common';
-import { LoggerFactory } from '@rsdk/logging';
 
-import { SequenceException } from '../exceptions';
 import type { PlatformOptions } from '../types';
 
 import { AdditionalSourceInitializer } from './additional-source/additional-source.initializer';
 import { AdditionalSourceModule } from './additional-source/additional-source.module';
+import { ConfigContext } from './context/config.context';
 import type { Config } from './config.abstract';
-import {
-  ConfigNotBootstrappedException,
-  ConfigPropertyMetadataNotFound,
-} from './exceptions';
-import type { PropertyToken } from './metadata';
-import { ConfigMetadataRegistry, getPropertyToken } from './metadata';
-import { ReloadEvents } from './reload';
+import { getPropertyToken } from './metadata';
 import type { ConfigSource } from './sources';
-import type { ConfigValue, PropertyMetadata } from './types';
-import { Vars } from './vars.class';
+import type { ConfigValue } from './types';
 
 export interface ConfigModuleOptions {
   /**
@@ -35,108 +25,7 @@ export interface ConfigModuleOptions {
   sources?: Constructor<ConfigSource>[];
 }
 
-/**
- * Configuration is loaded in predictable order. You should take
- * into account chat all repeating keys will be overwritten on each step:
- *
- * 1. .env file if there is any
- * 2. process environment
- * 3. динамические source'ы (если сделать последовательно - то в порядке указания)
- */
-
-@Module({})
 export class PlatformConfigModule {
-  private static isBootstrapped = false;
-  private static events = ReloadEvents.getInstance();
-  private static vars: Vars;
-  private static prefix: string;
-  /**
-   * Проинициализированные секции конфигов
-   * @private
-   */
-  private static initializedConfigs = new Map<Constructor<Config>, Config>();
-  /**
-   * undefined является валидным значением по умолчанию (`defaultValue`)
-   * @private
-   */
-  private static properties = new Map<PropertyToken, ConfigValue | undefined>();
-
-  /**
-   * We don't use class as context here because it is undefined if
-   * tsc target is ES2022
-   */
-  private static logger = LoggerFactory.create('PlatformConfigModule');
-
-  /**
-   * Метадата о необходимых приложению значениях конфигурации
-   * Зачем храним?
-   * Потому что пайплайн такой:
-   * 1. Собираем данные о том какие поля нам нужны
-   * 2. Приложение запрашивает поле из конфигурации
-   * 3. Ищем метаданные
-   * 4. По метаданным вытягиваем значение
-   * 5. Отдаём значение
-   *
-   * Это важно так как позволяет прозрачным образом контролировать этот процесс и инициализировать поля в тот момент когда они потребуются
-   * А не в тот момент когда их объявили
-   * Основной кейс, где это применяется - тесты
-   * @private
-   */
-  private static propertyMetadata = new Map<string, PropertyMetadata>();
-
-  /**
-   * This method should be invoked BEFORE bootstrapping nest application.
-   *
-   * It takes 2 main actions:
-   * - load environment variables
-   *
-   * - instantiates all configuration initializedConfig (classes marked with
-   *   @ConfigSection() decorator) and adds them into internal storage
-   *
-   * If any of these actions fails - application should exit.
-   *
-   * NOTE: This method should be invoked before any other interaction
-   * with ConfigurationModule
-   *
-   * ATTENTION: not load values from additional source
-   */
-  static bootstrap(options?: ConfigModuleOptions): void {
-    if (this.isBootstrapped) {
-      throw new SequenceException("Can't bootstrap ConfigurationModule twice");
-    }
-
-    this.prefix = options?.appName ?? '';
-
-    if (this.prefix) {
-      this.logger.info('Setting configuration keys prefix', {
-        prefix: this.prefix,
-      });
-    }
-
-    this.vars = new Vars(this.prefix);
-
-    this.readEnvironment();
-
-    /**
-     * Reading and validating standalone properties from env.
-     *
-     * NOTE: Splitting extraction if standalone properties into 2 phases
-     * is necessary, some configuration sources can need something
-     * from env to be instatiated.
-     */
-    const { properties } = ConfigMetadataRegistry.getMetadata();
-
-    this.extractStandaloneProperties(properties, 'expectedInEnv');
-
-    /**
-     * NOTE: That properties from .env already loaded.
-     * Now loading ones from other sources
-     */
-    this.extractStandaloneProperties(properties, 'others');
-
-    this.isBootstrapped = true;
-  }
-
   /**
    * Use this method to imports specific configuration property
    * into given module
@@ -171,20 +60,29 @@ export class PlatformConfigModule {
      * forFeature() is executed Config instances don't yet exist
      */
     const provider: FactoryProvider = {
-      inject: [{ optional: true, token: AdditionalSourceInitializer }],
+      inject: [
+        ConfigContext,
+        { optional: true, token: AdditionalSourceInitializer },
+      ],
       provide: ctor,
       useFactory: async (
+        configContext: ConfigContext,
         additionalSourceModuleInitializer?: AdditionalSourceInitializer,
       ) => {
         /**
          * Да, каждый раз вызываем метод `initialize` более подробно почему так - смотри в `JSDoc` метода
          */
         await additionalSourceModuleInitializer?.initialize();
-        return this.resolve(ctor);
+        return configContext.resolve(ctor);
       },
     };
 
     return {
+      /**
+       * Если использовать существующий PlatformConfigModule,
+       * то появляются коллизии при резолве зависимостей, а сам Nest падает
+       * TODO [@nestjs/core@>9.4]: проверить работоспособность, может быть исправлено
+       */
       module: PlatformConfigModule,
       providers: [provider],
 
@@ -197,134 +95,34 @@ export class PlatformConfigModule {
     const imports: (Promise<DynamicModule> | DynamicModule)[] = [];
 
     if (options.config?.sources) {
-      imports.push(
-        // TODO: Эти опции в идеале добавить в сам контейнер и использовать их везде
-        AdditionalSourceModule.forRoot({
-          sources: options.config?.sources,
-          logger: this.logger,
-          properties: this.properties,
-          vars: this.vars,
-          events: this.events,
-          prefix: this.prefix,
-          propertyMetadata: this.propertyMetadata,
-        }),
-      );
+      imports.push(AdditionalSourceModule.forRoot(options.config?.sources));
     }
 
     return {
+      global: true,
       imports,
       module: PlatformConfigModule,
       providers,
+      exports: providers,
     };
   }
 
-  /**
-   * Extracting specific instance of configuration section by
-   * its class reference. Throws error if called before .bootstrap()
-   *
-   * ATTENTION: Конфиг будет разрешен с доступными на данный момент переменными,
-   * то есть если дополнительные источники конфигурации ещё не были проинициализированы,
-   * они не будут учтены в разрешении конфигурации.
-   *
-   * @param ctor Pass constructor of configuration section class
-   * @returns T
-   */
-  static resolve<T extends Config>(ctor: Constructor<T>): T {
-    /**
-     * Автор уверен, что здесь не стоит делать bootstrap так как это разные зоны ответственности
-     */
-    if (!this.isBootstrapped) {
-      throw new ConfigNotBootstrappedException();
-    }
-
-    const instance = this.initializedConfigs.get(ctor);
-    if (!instance) {
-      const instantiateSection = this.instantiateSection(ctor);
-
-      this.initializedConfigs.set(ctor, instantiateSection);
-      return instantiateSection;
-    }
-
-    // We know exactly it is T
-    return instance as T;
-  }
-
   private static getPropertyProvider(
     token: `STANDALONE_CONFIG_PROPERTY_${string}`,
   ): FactoryProvider<ConfigValue | undefined> {
     return {
-      inject: [{ optional: true, token: AdditionalSourceInitializer }],
+      inject: [
+        ConfigContext,
+        { optional: true, token: AdditionalSourceInitializer },
+      ],
       provide: token,
       useFactory: async (
+        configContext: ConfigContext,
         additionalSourceModuleInitializer?: AdditionalSourceInitializer,
       ): Promise<ConfigValue | undefined> => {
         await additionalSourceModuleInitializer?.initialize();
-        if (this.properties.has(token)) {
-          // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-          return this.properties.get(token)!;
-        }
-        const propMeta = this.propertyMetadata.get(token);
-        if (!propMeta) {
-          throw new ConfigPropertyMetadataNotFound(token);
-        }
-        const value = this.vars.extract(propMeta);
-
-        this.properties.set(token, value);
-        return value;
+        return configContext.resolveProperty(token);
       },
     };
   }
-
-  private static readEnvironment(): void {
-    this.logger.info('Loading variables from .env file if exists');
-    dotenv.config();
-
-    this.logger.info('Initializing raw parameters storage');
-
-    /**
-     * Copying parameters from process.env, skipping entries
-     * for which value is undefined (not sure it's possible,
-     * but @types/node says it is).
-     */
-
-    for (const [key, value] of Object.entries(process.env)) {
-      if (value !== undefined) {
-        this.vars.set(key, value);
-      }
-    }
-  }
-
-  private static extractStandaloneProperties(
-    properties: Map<string, PropertyMetadata>,
-    subset: 'expectedInEnv' | 'others',
-  ): void {
-    for (const [alias, metadata] of properties.entries()) {
-      if (subset === 'expectedInEnv' && !metadata.expectedInEnv) {
-        continue;
-      }
-
-      this.propertyMetadata.set(getPropertyToken(alias), metadata);
-    }
-  }
-
-  /**
-   * Инициализирует инстанс секции конфига
-   * ATTENTION: не проверяет есть ли ещё проинициализированные, будьте внимательны во избежание неожиданного поведение
-   * @param ctor
-   * @private
-   */
-  private static instantiateSection<T extends Config>(ctor: Constructor<T>): T {
-    const instance = new ctor();
-
-    this.logger.debug('Initializing configuration section instance', {
-      ctor: ctor.name,
-    });
-
-    this.events.on('merge', () => {
-      instance.tryUpdate(this.vars);
-    });
-
-    instance.read(this.vars);
-    return instance;
-  }
 }