@rsdk/core 1.0.12 → 2.0.0

package/src/context.aggregator.ts

@@ -0,0 +1,62 @@
+import { RsdkMetadataProvider } from '@rsdk/metadata';
+
+import { ConfigContextModule } from './config/context/module';
+import { RsdkMetadataGlobalModule } from './rsdk-metadata/rsdk-metadata.global-module';
+import type { ContextAggregated } from './types/context-aggregated';
+import { ConfigContext } from './config';
+import type { PlatformContext } from './platform.context';
+import { PlatformModule } from './platform.module';
+
+export class ContextAggregator {
+  private _aggregated: ContextAggregated;
+
+  constructor(private platformContext: PlatformContext) {}
+
+  /**
+   * Прежде всего этот метод предназачен для единой точки конфигурации трех главных компонентов от которых зависит работа приложения
+   * RsdkMetadataProvider - хранит и предоставляет информацию о метаданных дерева модулей для приложения
+   * ConfigContext - его существование конкретно здесь обусловлено единственной проблемой, хранит информацию о том как приложение должно/может быть сконфигурировано
+   * root - Собственно рут модуль для создания DI
+   *
+   * И RsdkMetadataProvider, и ConfigContext должны быть внутри DI, они там собственно и будут. Но так как Nestjs считает иначе, а именно не даёт создать контекст приложения отдельно от транспорта... Кушаем кактус...
+   */
+  async getAggregated(): Promise<ContextAggregated> {
+    if (this._aggregated) {
+      return this._aggregated;
+    }
+    const platformRoot = PlatformModule.forRoot(
+      this.platformContext.extendedOptions,
+    );
+    const rsdkMetadataGlobalModule = await RsdkMetadataGlobalModule.raw(
+      platformRoot,
+    );
+    const rsdkMetadataProvider = await RsdkMetadataProvider.create(
+      rsdkMetadataGlobalModule,
+      platformRoot,
+    );
+
+    const configContext = new ConfigContext(rsdkMetadataProvider, {
+      ...this.platformContext.options.config,
+      appName: this.platformContext.extendedOptions.name,
+    });
+
+    const root = {
+      imports: [
+        platformRoot,
+        rsdkMetadataGlobalModule,
+        ConfigContextModule.forRoot(configContext),
+      ],
+      module: ContextAggregator,
+    };
+
+    this._aggregated = { root, rsdkMetadataProvider, configContext };
+    return this._aggregated;
+  }
+
+  /**
+   * Просто алиас чтобы везде не писать такую конструкцию
+   */
+  async getConfigContext(): Promise<ConfigContext> {
+    return (await this.getAggregated()).configContext;
+  }
+}

package/src/exceptions/base/platform-exception.absract.ts

@@ -8,7 +8,7 @@ export interface ExceptionsProps<T = any> {
   /**
    * Wrapped original error
    */
-  cause?: Error | undefined;
+  cause?: unknown | undefined;
 
   /**
    * Additional structured details
@@ -37,7 +37,7 @@ export abstract class PlatformException<T = any> extends Error {
    * PlatformException has ability to wrap original errors. Such an option exists
    * in many other languages and frameworks: .NET, Java, Go etc.
    */
-  readonly cause: Error | undefined;
+  readonly cause: unknown | undefined;
 
   /**
    * Any custom attributes developer is willing to
@@ -63,7 +63,12 @@ export abstract class PlatformException<T = any> extends Error {
   }
 
   static innerMessages(ex: Error): string[] {
-    if (!ex || !(ex instanceof PlatformException) || !ex.cause) {
+    if (
+      !ex ||
+      !(ex instanceof PlatformException) ||
+      !ex.cause ||
+      !(ex.cause instanceof Error)
+    ) {
       return [];
     }
 

package/src/health/autodoc/heath.autodoc-resolver.ts

@@ -1,33 +1,30 @@
-import type { DocumentNode, DocumentResolver } from '@rsdk/autodoc-protocol';
-import { Composite, Table } from '@rsdk/autodoc-protocol';
-import type { RsdkMetadata } from '@rsdk/metadata';
+import type { DocumentNode, DocumentResolver } from '@rsdk/autodoc.protocol';
+import { Composite, Table } from '@rsdk/autodoc.protocol';
+import type { RsdkMetadataProvider } from '@rsdk/metadata';
 
-import type { IndicatorOptions } from '../metadata';
+import { HEALTH_INDICATOR_RSDK_METADATA_SCOPE } from '../metadata/constants';
+import type { HealthIndicatorRsdkMetadata } from '../metadata/types';
 
-export class IndicatorAutodoc implements DocumentResolver {
-  constructor(
-    readonly rsdkMetadata: RsdkMetadata<{
-      key: string;
-      options: IndicatorOptions;
-      constructorName: string;
-    }>,
-  ) {}
-
-  getNode(): DocumentNode | null {
-    const resources = this.rsdkMetadata.get();
+export class IndicatorAutodocResolver implements DocumentResolver {
+  getNode(rsdkMetadataProvider: RsdkMetadataProvider): DocumentNode | null {
+    const resources = rsdkMetadataProvider.get<HealthIndicatorRsdkMetadata>(
+      HEALTH_INDICATOR_RSDK_METADATA_SCOPE,
+    );
     if (!resources) {
       return null;
     }
     return new Composite(
       new Table(
         resources.map(({ value }) => ({
-          key: value.key,
-          scope: value.options.scope ?? '-',
+          key: value.options.key,
+          scope: value.options.scope,
           description: value.options.description ?? '-',
-          name: value.constructorName,
+          name: value.target.name,
         })),
       ),
       'Health indicators',
     );
   }
 }
+
+export const indicatorAutodocResolver = new IndicatorAutodocResolver();

package/src/health/health.const.ts

@@ -1,2 +1,4 @@
 export const MODULE_OPTIONS = 'HEALTH_MODULE_OPTIONS';
 export const HEALTH_SERVICE = 'HEALTH_SERVICE_TOKEN';
+
+export const DEFAULT_HEALTH_CHECK_SCOPE = 'common';

package/src/health/health.service.ts

@@ -4,14 +4,18 @@ import { ModuleRef } from '@nestjs/core';
 import type { Constructor } from '@rsdk/common';
 import { LogTime } from '@rsdk/decorators';
 import { ILogger } from '@rsdk/logging';
+import { RsdkMetadataProvider } from '@rsdk/metadata';
 
 import { InjectLogger } from '../logging';
 
+import { HEALTH_INDICATOR_RSDK_METADATA_SCOPE } from './metadata/constants';
+import type { HealthIndicatorRsdkMetadata } from './metadata/types';
 import { HealthCheckException } from './exceptions';
-import { IndicatorsRegistry } from './metadata';
+import { DEFAULT_HEALTH_CHECK_SCOPE } from './health.const';
 import type {
   CheckSummary,
   HealthIndicator,
+  IndicatorMetadata,
   ResolvedIndicators,
 } from './types';
 
@@ -23,6 +27,7 @@ export class HealthChecksService implements OnModuleInit {
   constructor(
     @InjectLogger(HealthChecksService) private readonly logger: ILogger,
     private readonly moduleRef: ModuleRef,
+    private readonly rsdkMetadataProvider: RsdkMetadataProvider,
   ) {}
 
   @LogTime()
@@ -64,10 +69,21 @@ export class HealthChecksService implements OnModuleInit {
     return summary;
   }
 
+  iterateByIndicators(): [Constructor<HealthIndicator>, IndicatorMetadata][] {
+    const resources =
+      this.rsdkMetadataProvider.get<HealthIndicatorRsdkMetadata>(
+        HEALTH_INDICATOR_RSDK_METADATA_SCOPE,
+      );
+
+    return resources.map((value) => [value.value.target, value.value.options]);
+  }
+
   async onModuleInit(): Promise<void> {
     this.logger.debug('Initializing indicators...');
 
-    for (const [ctor, { key, scope }] of IndicatorsRegistry.entries()) {
+    const indicators = this.iterateByIndicators();
+
+    for (const [ctor, { key, scope }] of indicators) {
       if (!this.indicators[scope]) {
         this.indicators[scope] = [];
       }
@@ -94,7 +110,7 @@ export class HealthChecksService implements OnModuleInit {
        * This means - "perform all checks you have"
        */
       case '*':
-        return [...this.indicators.common];
+        return [...this.indicators[DEFAULT_HEALTH_CHECK_SCOPE]];
 
       /**
        * Matching exact filter. If no specific checks
@@ -107,7 +123,10 @@ export class HealthChecksService implements OnModuleInit {
           this.logger.warn(`Unsupported healthcheck filter: ${filter}`);
         }
 
-        return [...this.indicators.common, ...(specific || [])];
+        return [
+          ...this.indicators[DEFAULT_HEALTH_CHECK_SCOPE],
+          ...(specific || []),
+        ];
       }
     }
   }

package/src/health/metadata/constants.ts

@@ -0,0 +1 @@
+export const HEALTH_INDICATOR_RSDK_METADATA_SCOPE = 'health-indicator';

package/src/health/metadata/indicator.decorator.ts

@@ -1,10 +1,8 @@
 /* eslint-disable @typescript-eslint/ban-types */
 
-import { AutodocMetadata } from '@rsdk/autodoc-protocol';
 import type { Constructor } from '@rsdk/common';
-import { RsdkMetadata } from '@rsdk/metadata';
 
-import { IndicatorAutodoc } from '../autodoc/heath.autodoc-resolver';
+import { DEFAULT_HEALTH_CHECK_SCOPE } from '../health.const';
 import type { HealthIndicator } from '../types';
 
 import { IndicatorsRegistry } from './indicators.registry';
@@ -38,22 +36,8 @@ export const Indicator = (
   return function (target: Function): void {
     IndicatorsRegistry.register(target as Constructor<HealthIndicator>, {
       key,
-      scope: 'common',
+      scope: options.scope ?? DEFAULT_HEALTH_CHECK_SCOPE,
       ...options,
     });
-    const rsdkMetadata = new RsdkMetadata<{
-      key: string;
-      options: IndicatorOptions;
-      constructorName: string;
-    }>(target, 'health-indicator');
-
-    rsdkMetadata.add({
-      key,
-      options,
-      constructorName: target.name,
-    });
-    const autodocMetadata = new AutodocMetadata(rsdkMetadata);
-
-    autodocMetadata.defineResolver(new IndicatorAutodoc(rsdkMetadata));
   };
 };

package/src/health/metadata/indicators.registry.ts

@@ -1,34 +1,27 @@
+import { AutodocMetadata } from '@rsdk/autodoc.protocol';
 import type { Constructor } from '@rsdk/common';
-import { LoggerFactory } from '@rsdk/logging';
+import { RsdkMetadata } from '@rsdk/metadata';
 
-import { DoubleInitException } from '../../exceptions';
+import { indicatorAutodocResolver } from '../autodoc/heath.autodoc-resolver';
 import type { HealthIndicator, IndicatorMetadata } from '../types';
 
-export class IndicatorsRegistry {
-  private static logger = LoggerFactory.create('IndicatorsRegistry');
-  private static indicators = new Map<
-    Constructor<HealthIndicator>,
-    IndicatorMetadata
-  >();
-
-  static isRegistered(ctor: Constructor<HealthIndicator>): boolean {
-    return this.indicators.has(ctor);
-  }
+import { HEALTH_INDICATOR_RSDK_METADATA_SCOPE } from './constants';
+import type { HealthIndicatorRsdkMetadata } from './types';
 
+export class IndicatorsRegistry {
   static register(
     target: Constructor<HealthIndicator>,
     options: IndicatorMetadata,
   ): void {
-    if (this.indicators.has(target)) {
-      throw new DoubleInitException('Health indicator', target.name);
-    }
-
-    this.indicators.set(target, options);
-  }
-
-  static entries(): Iterable<
-    [Constructor<HealthIndicator>, IndicatorMetadata]
-  > {
-    return this.indicators.entries();
+    RsdkMetadata.add<HealthIndicatorRsdkMetadata>(
+      target,
+      { target, options, constructorName: target.name },
+      HEALTH_INDICATOR_RSDK_METADATA_SCOPE,
+    );
+    AutodocMetadata.defineResolver(
+      target,
+      HEALTH_INDICATOR_RSDK_METADATA_SCOPE,
+      indicatorAutodocResolver,
+    );
   }
 }

package/src/health/metadata/types.ts

@@ -0,0 +1,9 @@
+import type { Constructor } from '@rsdk/common';
+
+import type { HealthIndicator, IndicatorMetadata } from '../types';
+
+export type HealthIndicatorRsdkMetadata = {
+  target: Constructor<HealthIndicator>;
+  options: IndicatorMetadata;
+  constructorName: string;
+};

package/src/index.ts

@@ -1,23 +1,36 @@
+import './unhandled-rejection.handler';
+
+export {
+  FileSystemCheckOptions,
+  FileSystemIndicator,
+  PingCheckOptions,
+  PingIndicator,
+} from './health/indicators.abstract';
+
+export { HealthChecksService } from './health/health.service';
+
+export { CheckSummary } from './health/types';
+
+export { getLoggerToken } from './logging/helpers';
+
+export { Indicator } from './health/metadata/indicator.decorator';
+
+export { HealthIndicator } from './health/types';
+
+export { CheckResult } from './health/helpers';
+
 export { ConfigTag } from './config/config.const';
 
 export { PlatformContext } from './platform.context';
 
 export * from './config';
+
 export * from './exceptions';
+
 export * from './exceptions.handling';
-export {
-  // TODO: Продолжить документирование отсюда
-  HealthIndicator,
-  FileSystemIndicator,
-  FileSystemCheckOptions,
-  PingIndicator,
-  PingCheckOptions,
-  HealthChecksService,
-  CheckSummary,
-  Indicator,
-  CheckResult,
-} from './health';
+
 export { InjectLogger } from './logging';
+
 export {
   AnyMetric,
   Counter,
@@ -28,7 +41,11 @@ export {
   MetricsModule,
   register,
 } from './metrics';
+
 export { PlatformApp } from './app/platform.app';
+
 export * from './types';
+
 export * from './app-metadata/decorators';
+
 export * from './app-metadata/app-metadata.const';

package/src/logging/decorators/inject-logger.decorator.ts

@@ -7,9 +7,10 @@ import { LoggingModule } from '../logging.module';
 export const InjectLogger = (
   context: string | Constructor,
 ): ParameterDecorator => {
-  const token = getLoggerToken(context);
+  return (target, propertyKey, parameterIndex) => {
+    const token = getLoggerToken(context);
 
-  LoggingModule.register(context, token);
-
-  return Inject(token);
+    Inject(token)(target, propertyKey, parameterIndex);
+    LoggingModule.register(target, context, token);
+  };
 };

package/src/logging/global-logger-provider.generator.ts

@@ -0,0 +1,28 @@
+import type { NestModuleDefinition } from '@rsdk/common';
+import { LoggerFactory } from '@rsdk/logging';
+import type { RsdkMetadataProvider } from '@rsdk/metadata';
+
+import { LOGGING_RSDK_METADATA_SCOPE } from './metadata/constants';
+import type { LoggingRsdkMetadata } from './types';
+
+class GlobalLoggerProvidersGenerator {
+  generate(rsdkMetadataProvider: RsdkMetadataProvider): NestModuleDefinition {
+    const resources = rsdkMetadataProvider.get<LoggingRsdkMetadata>(
+      LOGGING_RSDK_METADATA_SCOPE,
+    );
+
+    const providers = resources.map(({ value }) => ({
+      provide: value.token,
+      useValue: LoggerFactory.create(value.context),
+    }));
+
+    return {
+      global: true,
+      providers: providers,
+      module: GlobalLoggerProvidersGenerator,
+      exports: providers,
+    };
+  }
+}
+
+export const globalLoggerProvidersModule = new GlobalLoggerProvidersGenerator();

package/src/logging/index.ts

@@ -2,3 +2,5 @@ export * from '@rsdk/logging';
 export * from './logging.module';
 export * from './adapters';
 export * from './decorators';
+export { LOGGING_RSDK_METADATA_SCOPE } from './metadata/constants';
+export { LoggingRsdkMetadata } from './types';

package/src/logging/logging.config.ts

@@ -23,7 +23,8 @@ export class LoggingConfig extends Config {
 
   @Property('LOG_REDACT', new ArrayParser(new StringParser()), {
     defaultValue: [],
-    description: 'Log level',
+    description:
+      'Redaction sensitive data details: https://github.com/pinojs/pino/blob/master/docs/redaction.md',
   })
   readonly redact!: string[];
 }

package/src/logging/logging.module.ts

@@ -1,17 +1,21 @@
 /* eslint-disable sort-keys */
 
-import type { DynamicModule, Provider } from '@nestjs/common';
+import type { DynamicModule } from '@nestjs/common';
 import { Module } from '@nestjs/common';
 import type { Constructor } from '@rsdk/common';
 import { LoggerFactory } from '@rsdk/logging';
+import { RsdkMetadata } from '@rsdk/metadata';
 
 import { PlatformConfigModule } from '../config';
+import type { PlatformRawGlobalMetadata } from '../rsdk-metadata/constants';
+import { PLATFORM_RAW_GLOBAL_METADATA_SCOPE } from '../rsdk-metadata/constants';
 
+import { LOGGING_RSDK_METADATA_SCOPE } from './metadata/constants';
 import { LoggingConfig } from './logging.config';
+import type { LoggingRsdkMetadata } from './types';
 
 @Module({})
 export class LoggingModule {
-  private static providers = new Map<string, Provider>();
   private static logger = LoggerFactory.create('LoggingModule');
 
   constructor(config: LoggingConfig) {
@@ -27,22 +31,44 @@ export class LoggingModule {
     cfg();
   }
 
-  static register(context: string | Constructor, token: string): void {
-    this.providers.set(token, {
-      provide: token,
-      useValue: LoggerFactory.create(context),
-    });
-  }
-
-  static forRoot(): DynamicModule {
-    const providers = [...this.providers.values()];
-
+  /**
+   * Возвращает модуль которые нужны для логгирования в любом случае, например его конфиг
+   */
+  static pureRoot(): DynamicModule {
     return {
-      module: LoggingModule,
-      imports: [PlatformConfigModule.forFeature(LoggingConfig)],
-      exports: providers,
-      providers: providers,
       global: true,
+      imports: [PlatformConfigModule.forFeature(LoggingConfig)],
+      module: LoggingModule,
+      exports: [PlatformConfigModule],
     };
   }
+
+  static register(
+    target: object,
+    context: string | Constructor,
+    token: string,
+  ): void {
+    RsdkMetadata.add<PlatformRawGlobalMetadata>(
+      target,
+      {
+        global: true,
+        imports: [PlatformConfigModule.forFeature(LoggingConfig)],
+        module: LoggingModule,
+        providers: [
+          {
+            provide: token,
+            useValue: LoggerFactory.create(context),
+          },
+        ],
+        exports: [token],
+      },
+      PLATFORM_RAW_GLOBAL_METADATA_SCOPE,
+    );
+
+    RsdkMetadata.add<LoggingRsdkMetadata>(
+      target,
+      { context, token, target },
+      LOGGING_RSDK_METADATA_SCOPE,
+    );
+  }
 }

package/src/logging/metadata/constants.ts

@@ -0,0 +1 @@
+export const LOGGING_RSDK_METADATA_SCOPE = 'LOGGING_RSDK_METADATA_SCOPE';

package/src/logging/types.ts

@@ -1,3 +1,7 @@
-import type { Provider } from '@nestjs/common';
+import type { Constructor } from '@rsdk/common';
 
-export type InstancesRegistry = Map<string, Provider>;
+export type LoggingRsdkMetadata = {
+  target: object;
+  context: string | Constructor;
+  token: string;
+};

package/src/metrics/index.ts

@@ -2,5 +2,5 @@ export { Counter, Gauge, Histogram, Summary, register } from 'prom-client';
 export * from './metrics.module';
 export * from './types';
 export * from './metadata';
-export { MetricAutodocResolver } from './metadata';
 export { MetricRsdkMetadata } from './metadata';
+export { MetricStorage } from './metric.storage';

package/src/metrics/metadata/autodoc/metrics.autodoc-resolver.ts

@@ -1,14 +1,16 @@
-import type { DocumentNode, DocumentResolver } from '@rsdk/autodoc-protocol';
-import { Composite, Table } from '@rsdk/autodoc-protocol';
-import type { RsdkMetadata } from '@rsdk/metadata';
+import type { DocumentNode, DocumentResolver } from '@rsdk/autodoc.protocol';
+import { Composite, Table } from '@rsdk/autodoc.protocol';
+import type { RsdkMetadataProvider } from '@rsdk/metadata';
 
+import { METRIC_RSDK_METADATA_SCOPE } from '../constants';
 import type { MetricRsdkMetadata } from '../types';
 
-export class MetricAutodocResolver implements DocumentResolver {
-  constructor(readonly rsdkMetadata: RsdkMetadata<MetricRsdkMetadata>) {}
+class MetricAutodocResolver implements DocumentResolver {
+  getNode(rsdkMetadataProvider: RsdkMetadataProvider): DocumentNode | null {
+    const resources = rsdkMetadataProvider.get<MetricRsdkMetadata>(
+      METRIC_RSDK_METADATA_SCOPE,
+    );
 
-  getNode(): DocumentNode | null {
-    const resources = this.rsdkMetadata.get();
     if (!resources) {
       return null;
     }
@@ -18,8 +20,8 @@ export class MetricAutodocResolver implements DocumentResolver {
         resources.map(({ value }) => {
           return {
             name: value.metadata.name,
-            description: value.metadata.description,
-            type: value.type,
+            description: value.metadata.description ?? '-',
+            type: value.metadata.type,
             controllerName: value.metricController.name,
           };
         }),
@@ -28,3 +30,5 @@ export class MetricAutodocResolver implements DocumentResolver {
     );
   }
 }
+
+export const metricsDocumentResolver = new MetricAutodocResolver();

package/src/metrics/metadata/constants.ts

@@ -0,0 +1 @@
+export const METRIC_RSDK_METADATA_SCOPE = 'METRIC_RSDK_METADATA_SCOPE';

package/src/metrics/metadata/index.ts

@@ -1,5 +1,4 @@
 export * from './metrics.registry';
 export * from './decorators';
-export { MetricAutodocResolver } from './autodoc/metrics.autodoc-resolver';
 
 export { MetricRsdkMetadata } from './types';

package/src/metrics/metadata/metrics.registry.ts

@@ -1,35 +1,31 @@
+import { AutodocMetadata } from '@rsdk/autodoc.protocol';
 import type { Constructor } from '@rsdk/common';
+import { RsdkMetadata } from '@rsdk/metadata';
 
-import { DoubleInitException, NoInitException } from '../../exceptions';
 import type { AnyMetric, MetricMetadata } from '../types';
 
+import { metricsDocumentResolver } from './autodoc/metrics.autodoc-resolver';
+import { METRIC_RSDK_METADATA_SCOPE } from './constants';
+import type { MetricRsdkMetadata } from './types';
+
 // separate class because we don't want to expose this
 export class MetricsRegistry {
-  private static metadata = new Map<Constructor<AnyMetric>, MetricMetadata>();
-
   static register(
     target: Constructor<AnyMetric>,
     metric: MetricMetadata,
   ): void {
-    if (this.metadata.has(target)) {
-      throw new DoubleInitException('Metric', target.name);
-    }
-
-    this.metadata.set(target, metric);
+    RsdkMetadata.add<MetricRsdkMetadata>(
+      target,
+      {
+        metricController: target,
+        metadata: metric,
+      },
+      METRIC_RSDK_METADATA_SCOPE,
+    );
+    AutodocMetadata.defineResolver(
+      target,
+      METRIC_RSDK_METADATA_SCOPE,
+      metricsDocumentResolver,
+    );
   }
-
-  static getOne(ctor: Constructor<AnyMetric>): Readonly<MetricMetadata> {
-    const metadata = this.metadata.get(ctor);
-    if (!metadata) {
-      throw new NoInitException('Metric', ctor.name);
-    }
-
-    return metadata;
-  }
-
-  static getAll(): Readonly<Map<Constructor<AnyMetric>, MetricMetadata>> {
-    return this.metadata;
-  }
-
-  // TODO Metadata for autodoc
 }