@rsdk/core 5.7.0-next.3 → 6.0.0-next.0

package/src/tracing/tracing.module.ts

@@ -1,4 +1,9 @@
-import type { DynamicModule, OnModuleInit } from '@nestjs/common';
+import type {
+  DynamicModule,
+  FactoryProvider,
+  OnModuleInit,
+  ValueProvider,
+} from '@nestjs/common';
 import { Module } from '@nestjs/common';
 import { APP_INTERCEPTOR } from '@nestjs/core';
 import type { ContextAPI, TraceAPI } from '@opentelemetry/api';
@@ -6,19 +11,19 @@ import { text } from '@rsdk/common';
 import { ILogger, LoggerFactory } from '@rsdk/logging';
 
 import { InjectLogger } from '../logging';
-import type { PlatformOptions } from '../types';
+import type { PlatformOptions, WithGenericHeaders } from '../types';
 
 import {
-  DEFAULT_TRACING_HEADERS,
-  DEFAULT_TRACING_OPTIONS,
+  HEADER_EXTRACTORS,
   HEADER_MAPPINGS,
+  REQUEST_ID_HEADERS,
 } from './constants';
 import { TracingHeaders } from './tracing.actx';
+import { TracingConfig } from './tracing.config';
 import { TracingInterceptor } from './tracing.interceptor';
 import type { TracingHeaderMappings } from './types';
 
 export interface TracingOptions {
-  includeDefault: boolean;
   additionalMappings?: TracingHeaderMappings[];
 }
 
@@ -30,31 +35,75 @@ export class TracingModule implements OnModuleInit {
   constructor(@InjectLogger(TracingModule) private readonly logger: ILogger) {}
 
   static forRoot({
-    tracing = DEFAULT_TRACING_OPTIONS,
-    plugins = [],
+    tracing,
+    plugins,
+    transports,
   }: PlatformOptions): DynamicModule {
-    const mappings: TracingHeaderMappings[] = [];
+    return {
+      global: true,
+      module: TracingModule,
+      providers: [
+        { provide: APP_INTERCEPTOR, useClass: TracingInterceptor },
+        this.createHeaderExtractorsProvider(transports, plugins),
+        this.createHeaderMappingsProvider(tracing, plugins),
+      ],
+    };
+  }
 
-    if (tracing?.includeDefault) {
-      mappings.push(...DEFAULT_TRACING_HEADERS);
-    }
+  /**
+   * Creates a provider for header mappings configuration.
+   * Combines default headers, plugin-provided headers and additional custom mappings
+   * into a single collection.
+   */
+  private static createHeaderMappingsProvider(
+    options: TracingOptions = {},
+    plugins: PlatformOptions['plugins'],
+  ): FactoryProvider {
+    const mappings: TracingHeaderMappings[] = [];
 
-    for (const plugin of plugins) {
+    for (const plugin of plugins ?? []) {
       mappings.push(...(plugin.additionalTracingHeaders?.() ?? []));
     }
 
-    mappings.push(...(tracing.additionalMappings ?? []));
+    mappings.push(...(options.additionalMappings ?? []));
 
     return {
-      global: true,
-      module: TracingModule,
-      providers: [
-        { provide: APP_INTERCEPTOR, useClass: TracingInterceptor },
-        { provide: HEADER_MAPPINGS, useValue: mappings },
-      ],
+      provide: HEADER_MAPPINGS,
+      inject: [TracingConfig],
+      useFactory: (config: TracingConfig): TracingHeaderMappings[] => {
+        if (config.traceRequestId) {
+          mappings.push(REQUEST_ID_HEADERS);
+        }
+
+        return mappings;
+      },
     };
   }
 
+  /**
+   * Creates a provider for header extractors from different transport protocols.
+   * Collects extractors from both transport implementations and plugins to handle
+   * protocol-specific header extraction.
+   */
+  private static createHeaderExtractorsProvider(
+    transports: PlatformOptions['transports'],
+    plugins: PlatformOptions['plugins'],
+  ): ValueProvider {
+    const extractors = new Map<string, WithGenericHeaders>();
+
+    for (const transport of transports ?? []) {
+      extractors.set(transport.getProtocol(), transport);
+    }
+
+    for (const plugin of plugins ?? []) {
+      for (const x of plugin.tracingHeadersExtractors?.() ?? []) {
+        extractors.set(x.protocol, x.extractor);
+      }
+    }
+
+    return { provide: HEADER_EXTRACTORS, useValue: extractors };
+  }
+
   // Можно добавить включение и выключение при изменении конфига.
   async onModuleInit(): Promise<void> {
     if (!this.context || !this.trace) {

package/src/transport/protocol.detector.ts

@@ -1,5 +1,6 @@
 import type { ArgumentsHost } from '@nestjs/common';
 
+import { InternalException } from '../exceptions';
 import type { ITransport } from '../types';
 
 /**
@@ -12,8 +13,17 @@ export class ProtocolDetector {
   /**
    * Detects transport's protocol by ArgumentHost (context)
    */
-  getProtocol(context: ArgumentsHost): string | undefined {
-    return this.getTransport(context)?.getProtocol();
+  getProtocol(context: ArgumentsHost): string {
+    /**
+     * FIXME: Грязный хак, который можно исправить только
+     * "прицепив" к транспорту. А ещё учесть, что на http-транспорте
+     * может быть и обычный http!
+     */
+    if ((context.getType() as any) === 'graphql') {
+      return 'graphql';
+    }
+
+    return this.getTransport(context).getProtocol();
   }
 
   /**
@@ -24,7 +34,17 @@ export class ProtocolDetector {
     return this.getProtocol(context) === protocol;
   }
 
-  private getTransport(context: ArgumentsHost): ITransport | undefined {
-    return this.transports.findLast((x) => x.matchByContext(context));
+  private getTransport(context: ArgumentsHost): ITransport {
+    const transport = this.transports.findLast((x) =>
+      x.matchByContext(context),
+    );
+
+    if (!transport) {
+      throw new InternalException('Cant detect transport protocol', {
+        details: { context },
+      });
+    }
+
+    return transport;
   }
 }

package/src/transport/transport.module.ts

@@ -1,9 +1,6 @@
 import type { DynamicModule } from '@nestjs/common';
 import type { NestModuleDefinition } from '@rsdk/common.nestjs';
-import { flatten } from 'lodash';
 
-import type { IErrorsFormatter, IErrorsSender } from '../exceptions.handling';
-import { GlobalExceptionsModule } from '../exceptions.handling';
 import { HealthModule } from '../health/health.module';
 import { MetricsModule } from '../metrics';
 import type { PlatformExtendedOptions } from '../types';
@@ -18,7 +15,6 @@ export class PlatformTransportModule {
         PlatformTransportModule.initProtocolDetector(options),
         PlatformTransportModule.initHealthchecks(options),
         PlatformTransportModule.initMetrics(options),
-        PlatformTransportModule.initExceptionsHandling(options),
         ...PlatformTransportModule.getTransportModules(options),
       ],
       module: PlatformTransportModule,
@@ -72,25 +68,4 @@ export class PlatformTransportModule {
         .map((x) => x.getHealthController()),
     });
   }
-
-  private static initExceptionsHandling(
-    options: PlatformExtendedOptions,
-  ): DynamicModule {
-    const transports = options.transports ?? [];
-
-    return GlobalExceptionsModule.forRoot({
-      formatters: [
-        ...transports.map((x) => x.getErrorsFormatter()),
-        ...(options.plugins?.map((x) => x.errorFormatter?.()) || []),
-      ].filter((x): x is IErrorsFormatter => Boolean(x)),
-      senders: [
-        ...transports.map((x) => x.getErrorsSender?.()),
-        ...(options.plugins?.map((x) => x.errorSender?.()) || []),
-      ].filter((x): x is IErrorsSender => Boolean(x)),
-      transformers: [
-        ...flatten(transports.map((x) => x.getErrorTransformers())),
-        ...flatten(options.plugins?.map((x) => x.errorTransformers?.() || [])),
-      ],
-    });
-  }
 }

package/src/types/plugins.ts

@@ -2,14 +2,15 @@ import type { DynamicModule, MiddlewareConsumer } from '@nestjs/common';
 import type { Constructor } from '@rsdk/common';
 import type { ResourceExtractor } from '@rsdk/metadata';
 
-import type {
-  IErrorsFormatter,
-  IErrorsSender,
-  IErrorsTransformer,
-} from '../exceptions.handling';
 import type { TracingHeaderMappings } from '../tracing';
 
-import type { WithGenericHeaders } from './transports';
+import type {
+  WithErrorFormatting,
+  WithErrorSending,
+  WithErrorTransforming,
+  WithGenericHeaders,
+  WithLogFormatting,
+} from './transports';
 
 export type SpecifiedTransports = Readonly<string[]>;
 export type AppropriateTransports = SpecifiedTransports | 'any';
@@ -26,7 +27,10 @@ export const hasSpecifiedTransports = (
  */
 export interface PlatformAppPlugin<
   T extends AppropriateTransports = AppropriateTransports,
-> {
+> extends Partial<WithErrorFormatting>,
+    Partial<WithErrorSending>,
+    Partial<WithErrorTransforming>,
+    Partial<WithLogFormatting> {
   /**
    * Additional resource extractors
    * Maybe used with custom plugin entity
@@ -58,21 +62,6 @@ export interface PlatformAppPlugin<
    */
   modules?(): (Constructor | DynamicModule)[];
 
-  /**
-   * Additional error transformers
-   */
-  errorTransformers?(): IErrorsTransformer[];
-
-  /**
-   * Additional error formatter
-   */
-  errorFormatter?(): IErrorsFormatter;
-
-  /**
-   * Additional errors sender
-   */
-  errorSender?(): IErrorsSender;
-
   /**
    * Apply additional middleware (using MiddlewareConsumer).
    * Will work only if application has HttpAdapter

package/src/types/transports.ts

@@ -14,6 +14,7 @@ import type {
   IErrorsSender,
   IErrorsTransformer,
 } from '../exceptions.handling';
+import type { LogFormatter } from '../logging';
 
 import type { NestModuleDefinitions } from './options';
 
@@ -36,10 +37,40 @@ export interface WithGenericHeaders {
 export const hasGenericHeaders = (x: unknown): x is WithGenericHeaders =>
   typeof (x as any)?.getHeaders === 'function';
 
+export interface WithErrorFormatting {
+  errorFormatter(): IErrorsFormatter;
+}
+
+export interface WithErrorSending {
+  /**
+   * @returns sending error algorithm
+   */
+  errorSender(): IErrorsSender;
+}
+
+export interface WithErrorTransforming {
+  /**
+   * @returns error transformers or empty array
+   */
+  errorTransformers(): IErrorsTransformer[];
+}
+
+export interface WithLogFormatting {
+  /**
+   * @returns logging formatter
+   */
+  logFormatter(): LogFormatter;
+}
+
 /**
  * Base functionality of HTTP or microservice transport
  */
-export interface ITransport extends WithGenericHeaders {
+export interface ITransport
+  extends WithGenericHeaders,
+    WithErrorFormatting,
+    WithErrorTransforming,
+    WithLogFormatting,
+    Partial<WithErrorSending> {
   /**
    * @returns protocol in text format
    */
@@ -57,21 +88,6 @@ export interface ITransport extends WithGenericHeaders {
    */
   matchByContext(ctx: ArgumentsHost): boolean;
 
-  /**
-   * @returns error formatting algorithm
-   */
-  getErrorsFormatter(): IErrorsFormatter;
-
-  /**
-   * @returns error transformers or empty array
-   */
-  getErrorTransformers(): IErrorsTransformer[];
-
-  /**
-   * @returns sending error algorithm
-   */
-  getErrorsSender?(): IErrorsSender;
-
   /**
    * Modules for register metrics, healthchecks, configs and supporting tools, such as clients
    */

package/src/unhandled-rejection.handler.ts

@@ -1,31 +1,23 @@
 import { text } from '@rsdk/common';
 import { LoggerFactory } from '@rsdk/logging';
 
-const logger = LoggerFactory.create('PlatformContext');
-
-if (!process.env.RSDK_CLI_MODE) {
-  logger.info('Registering unhandled rejections handler...');
-}
+const logger = LoggerFactory.create('UnhandledRejectionHandler');
 
 // This code enriches output if unhandled exceptions happen
-process.on('unhandledRejection', (reason: any, promise) => {
-  logger.error(
-    text`
-        Unhandled promise rejection happened! Process is shutting down
-        with exit code 1. See: https://github.com/nodejs/node/issues/20392
-        and https://nodejs.org/api/process.html#event-unhandledrejection
-      `,
-    { promise, reason },
-  );
+process.on('unhandledRejection', (reason: any, promise: Promise<any>) => {
+  const message = text`
+    Unhandled promise rejection happened! Process is shutting down
+    with exit code 1. See: https://github.com/nodejs/node/issues/20392
+    and https://nodejs.org/api/process.html#event-unhandledrejection
+  `;
+
+  logger.error(message, { promise, reason });
 
   /**
    * Additionally writes to standard console, because both <promise> and <reason>
    * can be not serializable
    */
-  console.error('Found unhandled rejection', {
-    promise,
-    reason,
-  });
+  console.error(message, { promise, reason });
 
   process.exit(1);
 });

package/test/logging.interceptor.spec.ts

@@ -0,0 +1,292 @@
+import type { ExecutionContext } from '@nestjs/common';
+import type { ILogger } from '@rsdk/logging';
+import { DEFAULT_LEVEL } from '@rsdk/logging';
+import { ApiZone } from '@rsdk/zones';
+import { of, throwError } from 'rxjs';
+
+import type { Config } from '../src/config';
+import { InternalException } from '../src/exceptions';
+import type { LogFormatter } from '../src/logging/formatters';
+import type { LoggingConfig } from '../src/logging/logging.config';
+import { LoggingInterceptor } from '../src/logging/logging.interceptor';
+import type { ProtocolDetector } from '../src/transport/protocol.detector';
+
+/**
+ * TODO: Надо куда-то вынести, но @rsdk/testing зависит
+ * от @rsdk/core, так что возникает цикл. Разобраться!
+ */
+export const createMockLogger = (): jest.Mocked<ILogger> => {
+  return {
+    debug: jest.fn(),
+    info: jest.fn(),
+    warn: jest.fn(),
+    error: jest.fn(),
+    fatal: jest.fn(),
+    trace: jest.fn(),
+    log: jest.fn(),
+  };
+};
+
+/**
+ * TODO: Надо куда-то вынести, но @rsdk/testing зависит
+ * от @rsdk/core, так что возникает цикл. Разобраться!
+ */
+export const createMockExecutionContext = (): jest.Mocked<ExecutionContext> => {
+  return {
+    getClass: jest.fn().mockReturnValue(class TestController {}),
+    getHandler: jest.fn(),
+    getArgs: jest.fn(),
+    getArgByIndex: jest.fn(),
+    switchToRpc: jest.fn(),
+    switchToHttp: jest.fn(),
+    switchToWs: jest.fn(),
+    getType: jest.fn(),
+  };
+};
+
+describe('LoggingInterceptor', () => {
+  let mockLogger: jest.Mocked<ILogger>;
+  let mockDetector: jest.Mocked<ProtocolDetector>;
+  let mockFormatter: jest.Mocked<LogFormatter>;
+
+  const makeInterceptor = (
+    configOverrides: Partial<Omit<LoggingConfig, keyof Config>> = {},
+  ): LoggingInterceptor => {
+    const config: Omit<LoggingConfig, keyof Config> = {
+      /**
+       * Defaults
+       */
+      logRequestBody: false,
+      logResponseBody: false,
+      excludeZones: [],
+      level: DEFAULT_LEVEL,
+      redact: [],
+      sync: false,
+      otelEnabled: false,
+
+      /**
+       * Overrides
+       */
+      ...configOverrides,
+    };
+
+    return new LoggingInterceptor(
+      mockLogger,
+      new Map([[mockFormatter.protocol, mockFormatter]]),
+      mockDetector,
+      config as LoggingConfig,
+    );
+  };
+
+  /**
+   * TODO: Чтобы вот такого не делать, нужно будет убрать базовый класс
+   * config в принципе. Это можно сделать, привязывая функциональность
+   * обновления и прочего к ссылкам на созданные инстансы
+   */
+  beforeEach(async () => {
+    mockLogger = createMockLogger();
+
+    mockDetector = {
+      getProtocol: jest.fn(),
+    } as unknown as jest.Mocked<ProtocolDetector>;
+
+    mockFormatter = {
+      protocol: 'test',
+      getPath: jest.fn().mockReturnValue('/test/path'),
+      formatRequest: jest.fn().mockReturnValue({}),
+      formatResponse: jest.fn().mockReturnValue({}),
+      shouldLog: jest.fn().mockReturnValue(true),
+    };
+  });
+
+  describe('no error', () => {
+    it('should log request and response for non-excluded zone', (done) => {
+      // Arrange
+      mockDetector.getProtocol.mockReturnValue('test');
+      const mockContext = createMockExecutionContext();
+      const interceptor = makeInterceptor();
+
+      // Act & Assert
+      interceptor
+        .intercept(mockContext, { handle: () => of('response data') })
+        .subscribe({
+          complete: () => {
+            /* eslint-disable prettier/prettier */
+            expect(mockLogger.debug).toHaveBeenCalledTimes(2);
+            expect(mockLogger.debug).toHaveBeenNthCalledWith(1, '>>> Received [TEST] /test/path', expect.any(Object));
+            expect(mockLogger.debug).toHaveBeenNthCalledWith(2, '<<< Handled [TEST] /test/path', expect.objectContaining({
+              executionTime: expect.any(Number),
+            }));
+            /* eslint-enable prettier/prettier */
+
+            done();
+          },
+        });
+    });
+
+    it('should not log request and response for excluded zone', (done) => {
+      // Arrange
+      mockDetector.getProtocol.mockReturnValue('test');
+      const mockContext = createMockExecutionContext();
+
+      // Mock zone metadata
+      @ApiZone('excluded-zone')
+      class WithExcludedZone {}
+
+      mockContext.getClass.mockReturnValue(WithExcludedZone);
+      jest.spyOn(Reflect, 'getMetadata').mockReturnValue('excluded-zone');
+
+      const interceptor = makeInterceptor({
+        excludeZones: ['excluded-zone'],
+      });
+
+      // Act & Assert
+      interceptor
+        .intercept(mockContext, { handle: () => of('response data') })
+        .subscribe({
+          complete: () => {
+            expect(mockLogger.debug).toHaveBeenCalledTimes(0);
+            done();
+          },
+        });
+    });
+
+    it('should include request body when logRequestBody is true', (done) => {
+      // Arrange
+      mockDetector.getProtocol.mockReturnValue('test');
+      const mockContext = createMockExecutionContext();
+      const interceptor = makeInterceptor({ logRequestBody: true });
+
+      // Act & Assert
+      interceptor
+        .intercept(mockContext, { handle: () => of('response data') })
+        .subscribe({
+          complete: () => {
+            expect(mockFormatter.formatRequest).toHaveBeenCalledWith(
+              mockContext,
+              true,
+            );
+            done();
+          },
+        });
+    });
+
+    it('should include response body when logResponseBody is true', (done) => {
+      // Arrange
+      mockDetector.getProtocol.mockReturnValue('test');
+      const mockContext = createMockExecutionContext();
+      const interceptor = makeInterceptor({ logResponseBody: true });
+
+      // Act & Assert
+      interceptor
+        .intercept(mockContext, { handle: () => of('response data') })
+        .subscribe({
+          complete: () => {
+            expect(mockFormatter.formatResponse).toHaveBeenCalledWith(
+              mockContext,
+              'response data',
+            );
+            done();
+          },
+        });
+    });
+
+    it('should use default formatter for unknown protocol', (done) => {
+      // Arrange
+      mockDetector.getProtocol.mockReturnValue('unknown');
+      const mockContext = createMockExecutionContext();
+      const interceptor = makeInterceptor();
+
+      // Act & Assert
+      interceptor
+        .intercept(mockContext, { handle: () => of('response data') })
+        .subscribe({
+          complete: () => {
+            expect(mockLogger.warn).toHaveBeenCalledWith(
+              'no formatter for protocol <unknown>...',
+            );
+            done();
+          },
+        });
+    });
+
+    it('should not log if formatter.shouldLog returns false', (done) => {
+      // Arrange
+      mockDetector.getProtocol.mockReturnValue('test');
+      const mockContext = createMockExecutionContext();
+
+      mockFormatter.shouldLog = jest.fn().mockReturnValue(false);
+      const interceptor = makeInterceptor();
+
+      // Act & Assert
+      interceptor
+        .intercept(mockContext, { handle: () => of('response data') })
+        .subscribe({
+          complete: () => {
+            expect(mockLogger.debug).not.toHaveBeenCalled();
+            done();
+          },
+        });
+    });
+  });
+
+  describe('with error', () => {
+    it('should log errors even for excluded zones', (done) => {
+      // Arrange
+      mockDetector.getProtocol.mockReturnValue('test');
+      const mockContext = createMockExecutionContext();
+
+      // Mock zone metadata
+      jest.spyOn(Reflect, 'getMetadata').mockReturnValue('excluded-zone');
+
+      const interceptor = makeInterceptor({
+        excludeZones: ['excluded-zone'],
+      });
+
+      const error = new InternalException('Test error');
+
+      // Act & Assert
+      interceptor
+        .intercept(mockContext, { handle: () => throwError(() => error) })
+        .subscribe({
+          error: () => {
+            expect(mockLogger.error).toHaveBeenCalledWith(
+              'Failed [TEST] /test/path',
+              expect.objectContaining({
+                request: {},
+                cause: error,
+                path: '/test/path',
+                zone: 'excluded-zone',
+              }),
+            );
+            done();
+          },
+        });
+    });
+
+    it('should log error with request details', (done) => {
+      // Arrange
+      mockDetector.getProtocol.mockReturnValue('test');
+      const mockContext = createMockExecutionContext();
+      const error = new InternalException('Test error');
+      const interceptor = makeInterceptor();
+
+      // Act & Assert
+      interceptor
+        .intercept(mockContext, { handle: () => throwError(() => error) })
+        .subscribe({
+          error: () => {
+            expect(mockLogger.error).toHaveBeenCalledWith(
+              'Failed [TEST] /test/path',
+              expect.objectContaining({
+                request: '[ALREADY LOGGED]',
+                cause: error,
+                path: '/test/path',
+              }),
+            );
+            done();
+          },
+        });
+    });
+  });
+});

package/dist/config/parsers/array/array.parser.d.ts

@@ -1,11 +0,0 @@
-import type { PropertyParser } from '../../types';
-export declare class ArrayParser<T> implements PropertyParser<T[]> {
-    private readonly singleValueParser;
-    private readonly options;
-    constructor(singleValueParser: PropertyParser<T>, options?: {
-        separator: string;
-    });
-    type(): string;
-    description(): string;
-    parse(value: unknown): T[];
-}