@rsdk/nats.transport 5.7.0 → 5.8.0-next.1

package/src/{server.ts → jetstream/server.ts}

@@ -14,7 +14,7 @@ import { InternalException, NotFoundException } from '@rsdk/core';
 import type { EventType } from '@rsdk/events.common';
 import { isEventType, X_TYPE_HEADER } from '@rsdk/events.common';
 import { LoggerFactory } from '@rsdk/logging';
-import { getStreamName } from '@rsdk/nats.common';
+import { getStreamName, isMessageType } from '@rsdk/nats.common';
 import { isEqual } from 'lodash';
 import type {
   Consumer,
@@ -22,16 +22,18 @@ import type {
   JetStreamClient,
   JetStreamManager,
   NatsConnection,
-  SubscriptionOptions,
 } from 'nats';
 import { connect } from 'nats';
 import { connectable, isObservable, Subject } from 'rxjs';
 
-import type { ConsumerInfo } from './types/consumer-info.type';
-import type { ConsumersMap } from './types/consumers-map.type';
-import type { EventTypeWithOptions } from './types/event-type-with-options.type';
-import type { Mapping } from './types/mapping.type';
-import { EventsDeserializer } from './events.deserializer';
+import { EventsDeserializer } from '../events.deserializer';
+
+import type {
+  ConsumerInfo,
+  ConsumersMap,
+  EventTypeWithOptions,
+  Mapping,
+} from './types';
 
 /**
  * Класс, реализующий сервер NATS JetStream.
@@ -41,8 +43,10 @@ export class NatsJetStreamServer
   implements CustomTransportStrategy
 {
   readonly transportId = NATS_JETSTREAM_TRANSPORT;
-  override logger = LoggerFactory.create('NatsJetStreamServer');
-  override readonly deserializer = new EventsDeserializer();
+  override logger = LoggerFactory.create(NatsJetStreamServer.name);
+  override readonly deserializer =
+    new EventsDeserializer<EventTypeWithOptions>();
+
   private nc?: NatsConnection;
   private jsm?: JetStreamManager;
   private readonly streams = new Set<string>();
@@ -69,8 +73,11 @@ export class NatsJetStreamServer
 
   static isNatsContext(
     maybeNatsContext: unknown,
-  ): maybeNatsContext is NatsJetStreamContext {
-    return maybeNatsContext instanceof NatsJetStreamContext;
+  ): maybeNatsContext is NatsJetStreamContext | NatsContext {
+    return (
+      maybeNatsContext instanceof NatsJetStreamContext ||
+      maybeNatsContext instanceof NatsContext
+    );
   }
 
   /**
@@ -85,7 +92,6 @@ export class NatsJetStreamServer
     this.jsm = await this.nc.jetstreamManager(this.options.jetStreamOptions);
 
     await this.bindEventHandlers();
-    this.bindMessageHandlers();
     callback();
   }
 
@@ -110,29 +116,57 @@ export class NatsJetStreamServer
     isEventHandler = false,
     extras: Record<string, any> = {},
   ): void {
-    const eventType = this.getEventType(pattern);
-    let formattedPattern: string;
+    if (isEventHandler) {
+      return this.addEventHandler(pattern, callback, extras);
+    }
+
+    throw new InternalException(
+      'Request/reply handlers are not supported for this transport',
+    );
+  }
+
+  private addEventHandler(
+    pattern: any,
+    callback: MessageHandler,
+    extras: Record<string, any> = {},
+  ): void {
+    const eventType = this.getMessageType(pattern);
+    const formattedPattern = this.getFormattedPattern(eventType);
+
+    const stream = isEventType(eventType)
+      ? this.getStreamName(pattern)
+      : eventType;
 
-    if (isEventType(eventType)) {
-      this.streams.add(this.getStreamName(pattern));
-      formattedPattern = eventType.$type;
-      this.deserializer.events.set(formattedPattern, pattern);
+    this.streams.add(stream);
+    this.deserializer.events.set(formattedPattern, pattern);
+
+    super.addHandler(formattedPattern, callback, true, extras);
+  }
+
+  private getFormattedPattern(eventType: any): string {
+    if (isMessageType(eventType)) {
+      return eventType.$type;
     } else if (typeof eventType === 'string') {
-      formattedPattern = eventType;
-      this.streams.add(eventType);
+      /**
+       * NOTE: сейчас если указывается строка, то мы исключаем decode формата protobuf.
+       * Наверное стоит разделить subject и декодеры на разные поля.
+       */
+      return eventType;
     }
 
-    super.addHandler(formattedPattern!, callback, isEventHandler, extras);
+    throw new InternalException(
+      'Invalid pattern type: expected event type or string',
+    );
   }
 
   /**
-   * Получает тип события из шаблона.
-   * @param pattern - Шаблон для получения типа события.
-   * @returns Тип события.
+   * Получает тип сообщения из шаблона.
+   * @param pattern - Шаблон для получения типа сообщения.
+   * @returns Тип сообщения.
    */
-  private getEventType(pattern: any): any {
-    return typeof pattern === 'object' && 'eventType' in pattern
-      ? pattern.eventType
+  private getMessageType(pattern: any): any {
+    return typeof pattern === 'object' && 'type' in pattern
+      ? pattern.type
       : pattern;
   }
 
@@ -197,7 +231,7 @@ export class NatsJetStreamServer
         mapping: new Map() as Mapping,
       };
 
-      aggregatedConsumer.mapping.set(this.getTypePart(deserializer.eventType), {
+      aggregatedConsumer.mapping.set(this.getTypePart(deserializer.type), {
         deserializer,
         handler,
       });
@@ -278,7 +312,7 @@ export class NatsJetStreamServer
       receivedSubjects,
     );
 
-    this.handleMessages(consumer, mapping, consumerName);
+    this.handleEventMessages(consumer, mapping, consumerName);
   }
 
   /**
@@ -287,7 +321,7 @@ export class NatsJetStreamServer
    * @param mapping - Соответствия между типами сообщений и обработчиками.
    * @param consumerName - Имя консьюмера.
    */
-  private async handleMessages(
+  private async handleEventMessages(
     consumer: Consumer,
     mapping: Mapping,
     consumerName: string,
@@ -368,85 +402,13 @@ export class NatsJetStreamServer
     });
   }
 
-  /**
-   * Связывает обработчики сообщений.
-   */
-  private bindMessageHandlers(): void {
-    const messageHandlers = [...this.messageHandlers.entries()].filter(
-      ([, handler]) => !handler.isEventHandler,
-    );
-
-    for (const [subject, messageHandler] of messageHandlers) {
-      const subscriptionOptions: SubscriptionOptions = {
-        callback: async (err, msg) => {
-          if (err) {
-            this.logger.error(err.message, err);
-            return;
-          }
-          const payload = this.deserializer.deserialize(msg);
-          const context = new NatsContext([msg]);
-          const response$ = this.transformToObservable(
-            messageHandler(payload.data, context),
-          );
-
-          this.send(response$, (response) =>
-            msg.respond(response as Uint8Array),
-          );
-        },
-      };
-
-      this.nc?.subscribe(subject, subscriptionOptions);
-      this.logger.debug(`Subscribed to ${subject} messages`);
-    }
-  }
-
-  /**
-   * Настраивает поток для сервера.
-   */
-  private async setupStream(): Promise<void> {
-    const { streamConfig } = this.options;
-    const streams = await this.jsm?.streams.list().next();
-
-    const reqStreamConfigs = Array.isArray(streamConfig)
-      ? streamConfig
-      : [streamConfig];
-
-    for (const requiredStreamConfig of reqStreamConfigs) {
-      if (!requiredStreamConfig) {
-        continue;
-      }
-      const stream = streams?.find(
-        (stream) => stream.config.name === requiredStreamConfig?.name,
-      );
-
-      if (stream) {
-        const streamSubjects = new Set([
-          ...stream.config.subjects,
-          ...(requiredStreamConfig?.subjects ?? []),
-        ]);
-
-        const streamInfo = await this.jsm?.streams.update(stream.config.name, {
-          ...stream.config,
-          ...requiredStreamConfig,
-          subjects: [...streamSubjects.keys()],
-        });
-
-        this.logger.info(`Stream ${streamInfo?.config.name} updated`);
-      } else {
-        const streamInfo = await this.jsm?.streams.add(requiredStreamConfig);
-
-        this.logger.info(`Stream ${streamInfo?.config.name} created`);
-      }
-    }
-  }
-
   /**
    * Получает имя потока для десериализатора.
    * @param contract - Десериализатор событий.
    * @returns Имя потока.
    */
   private getStreamName(contract: EventTypeWithOptions): string {
-    return contract.options?.streamName ?? getStreamName(contract.eventType);
+    return contract.options?.streamName ?? getStreamName(contract.type);
   }
 
   /**

package/src/{types → jetstream/types}/event-type-with-options.type.ts

@@ -3,6 +3,6 @@ import type { EventType } from '@rsdk/events.common';
 import type { ConsumeOptions } from './consume.options';
 
 export type EventTypeWithOptions = {
-  eventType: EventType;
+  type: EventType;
   options?: ConsumeOptions;
 };

package/src/jetstream/types/index.ts

@@ -0,0 +1,6 @@
+export * from './consume.options';
+export * from './consumer-info.type';
+export * from './event-type-with-options.type';
+export * from './mapping.type';
+export * from './nats-jetstream-transport-options.type';
+export * from './consumers-map.type';

package/src/{types → jetstream/types}/mapping.type.ts

@@ -4,5 +4,8 @@ import type { EventTypeWithOptions } from './event-type-with-options.type';
 
 export type Mapping = Map<
   string,
-  { deserializer: EventTypeWithOptions; handler: MessageHandler }
+  {
+    deserializer: EventTypeWithOptions;
+    handler: MessageHandler;
+  }
 >;

package/src/request/constants.ts

@@ -0,0 +1 @@
+export const NATS_REQUEST_PROTOCOL = 'nats-request';

package/src/request/consume-request.decorator.ts

@@ -0,0 +1,18 @@
+import { applyDecorators } from '@nestjs/common';
+import { MessagePattern, Transport } from '@nestjs/microservices';
+import type { MessageType } from '@rsdk/nats.common';
+
+import type { ConsumeRequestOptions } from './types';
+
+export const ConsumeRequest = <T>(
+  request: MessageType<T>,
+  response: MessageType<T>,
+  options?: Omit<ConsumeRequestOptions, 'response'>,
+): MethodDecorator => {
+  return applyDecorators(
+    MessagePattern(
+      { type: request, options: { ...options, response } },
+      Transport.NATS,
+    ),
+  );
+};

package/src/request/index.ts

@@ -0,0 +1,4 @@
+export * from './consume-request.decorator';
+export * from './nats-request.transport';
+export * from './types';
+export * from './constants';

package/src/request/nats-request-errors.formatter.ts

@@ -0,0 +1,49 @@
+import {
+  ExceptionKind,
+  type IErrorsFormatter,
+  PipelineException,
+} from '@rsdk/core';
+
+import { NATS_REQUEST_PROTOCOL } from './constants';
+
+export class NatsRequestErrorsFormatter implements IErrorsFormatter {
+  static readonly defaultKind = ExceptionKind.UNKNOWN;
+  protocol = NATS_REQUEST_PROTOCOL;
+
+  match(): boolean {
+    return false;
+  }
+
+  format(ex: unknown, verboseErrors?: boolean): unknown {
+    if (ex instanceof PipelineException) {
+      const message = verboseErrors
+        ? [
+            ex.message,
+            ...PipelineException.innerMessages(ex).map((msg) =>
+              msg.replace(ex.message, '').trim().replace(/:$/, ''),
+            ),
+          ].join(': ')
+        : ExceptionKind[ex.kind].toString();
+
+      return {
+        code: ex.code,
+        message,
+        details: ex.details || {},
+        kind: ex.kind,
+        exceptionCode: ex.code.toString(),
+      };
+    }
+
+    const defaultExMessage = 'UNKNOWN ERROR';
+
+    return {
+      code: 'UNKNOWN',
+      message: verboseErrors
+        ? ((ex as any)?.message ?? defaultExMessage)
+        : defaultExMessage,
+      details: (ex as any)?.details ?? {},
+      kind: (ex as any)?.kind ?? NatsRequestErrorsFormatter.defaultKind,
+      exceptionCode: (ex as any)?.code?.toString(),
+    };
+  }
+}

package/src/request/nats-request-errors.sender.ts

@@ -0,0 +1,39 @@
+import type { ArgumentsHost } from '@nestjs/common';
+import { Status } from '@rsdk/builtin-contract/dist/grpc.error.v1';
+import type { IErrorsSender } from '@rsdk/core';
+import { MsgHdrsImpl } from 'nats';
+import type { EMPTY, Observable } from 'rxjs';
+import { throwError } from 'rxjs';
+
+import { NATS_REQUEST_PROTOCOL } from './constants';
+import type { FormattedNatsError } from './types';
+
+export class NatsRequestErrorsSender implements IErrorsSender {
+  protocol = NATS_REQUEST_PROTOCOL;
+
+  send(
+    _host: ArgumentsHost,
+    ex: FormattedNatsError,
+  ): Observable<any> | typeof EMPTY {
+    const metadata = new MsgHdrsImpl();
+
+    const status = Status.fromPartial({
+      code: ex.kind,
+      details: ex.details,
+      message: ex.message,
+      exceptionCode: ex.exceptionCode,
+    });
+
+    metadata.set(
+      'nats-status-details-hex',
+      (Status.encode(status).finish() as Buffer).toString('hex'),
+    );
+    const error = {
+      code: ex.code,
+      details: ex.message,
+      metadata,
+    };
+
+    return throwError(() => error);
+  }
+}

package/src/request/nats-request-logger.interceptor.ts

@@ -0,0 +1,89 @@
+import type {
+  CallHandler,
+  ExecutionContext,
+  NestInterceptor,
+} from '@nestjs/common/interfaces';
+import { InjectLogger, ProtocolDetector } from '@rsdk/core';
+import { ILogger } from '@rsdk/logging';
+import type { Observable } from 'rxjs';
+import { catchError, tap, throwError } from 'rxjs';
+
+import { NATS_REQUEST_PROTOCOL } from './constants';
+import { NatsRequestConfig } from './nats-request.config';
+
+export class NatsRequestLoggerInterceptor implements NestInterceptor {
+  constructor(
+    @InjectLogger(NatsRequestLoggerInterceptor) private logger: ILogger,
+    private config: NatsRequestConfig,
+    private detector: ProtocolDetector,
+  ) {}
+
+  intercept(
+    context: ExecutionContext,
+    next: CallHandler<any>,
+  ): Observable<any> | Promise<Observable<any>> {
+    if (!this.config.requestLogging) {
+      return next.handle();
+    }
+
+    const protocol = this.detector.getProtocol(context);
+
+    if (protocol !== NATS_REQUEST_PROTOCOL) {
+      return next.handle();
+    }
+
+    const rpc = context.switchToRpc();
+
+    const startDate = Date.now();
+    const rpcContext = rpc.getContext();
+    const serializedCtx = rpcContext?.toJSON?.() ?? rpcContext;
+    const requestForLog = {
+      data: rpc.getData(),
+      ctx: serializedCtx,
+    };
+
+    const path = this.getRpcPath(context);
+
+    this.logger.trace(`received nats request ${path}`, {
+      request: requestForLog,
+      timestamp: startDate,
+    });
+
+    return next.handle().pipe(
+      catchError((error) => {
+        const endDate = Date.now();
+
+        this.logger.trace(`handled nats request ${path} with error`, {
+          request: requestForLog,
+          startDate,
+          endDate,
+          duration: endDate - startDate,
+          error,
+        });
+        return throwError(() => error);
+      }),
+      tap((response) => {
+        const endDate = Date.now();
+
+        this.logger.trace(`handled nats request ${path}`, {
+          request: requestForLog,
+          startDate,
+          endDate,
+          duration: endDate - startDate,
+          response,
+        });
+      }),
+    );
+  }
+
+  private getRpcPath(context: ExecutionContext): string | undefined {
+    try {
+      return context.getArgs()[1]?.args[0];
+    } catch (error) {
+      if (error instanceof Error) {
+        this.logger.warn(error.message, { error });
+      }
+      return undefined;
+    }
+  }
+}

package/src/request/nats-request-transport.module.ts

@@ -0,0 +1,4 @@
+import { Module } from '@nestjs/common';
+
+@Module({})
+export class NatsRequestTransportModule {}

package/src/request/nats-request.config.ts

@@ -0,0 +1,36 @@
+import {
+  BoolParser,
+  Config,
+  ConfigSection,
+  EnumParser,
+  Property,
+  StringParser,
+} from '@rsdk/core';
+import { DEFAULT_PAYLOAD_FORMAT, PayloadFormat } from '@rsdk/events.common';
+
+export const NatsRequestConfigInstance = Symbol('NatsRequestConfigInstance');
+
+@ConfigSection()
+export class NatsRequestConfig extends Config {
+  @Property('NATS_REQUEST_NAME', new StringParser(), {
+    defaultValue: 'default',
+    description: 'NATS connection name',
+  })
+  readonly name!: string;
+
+  @Property(
+    'NATS_DEFAULT_RESPONSE_PAYLOAD_TYPE',
+    new EnumParser(PayloadFormat),
+    {
+      defaultValue: DEFAULT_PAYLOAD_FORMAT,
+      description: `Default payload type of response. Possible values: ${Object.values(PayloadFormat).join(', ')}.`,
+    },
+  )
+  readonly defaultResponsePayloadType!: PayloadFormat;
+
+  @Property('NATS_REQUEST_LOGGING', new BoolParser(), {
+    defaultValue: false,
+    description: 'Enable trace logging all requests',
+  })
+  readonly requestLogging!: boolean;
+}

package/src/request/nats-request.headers.ts

@@ -0,0 +1,33 @@
+import type { ExecutionContext } from '@nestjs/common';
+import type { GenericHeaders } from '@rsdk/core';
+import { InputException } from '@rsdk/core';
+
+import { NatsRequestServer } from './server';
+
+/**
+ * @description хелпер для нормализованного извлечения заголовков из nats
+ */
+export class NatsRequestHeaders implements GenericHeaders {
+  private readonly normalizedHeaders: Record<string, string>;
+
+  constructor(ctx: ExecutionContext) {
+    const natsCtx = ctx.getArgByIndex(1);
+
+    if (!NatsRequestServer.isNatsContext(natsCtx)) {
+      throw new InputException('Unexpected call with non Nats ArgumentHost');
+    }
+
+    this.normalizedHeaders = Object.fromEntries(
+      Object.entries(natsCtx.getHeaders() || {}).map(([k, v]) => [
+        Array.isArray(k)
+          ? k[0].toString().toLowerCase()
+          : k.toString().toLowerCase(),
+        v,
+      ]),
+    );
+  }
+
+  get(key: string): string | undefined {
+    return this.normalizedHeaders[key.toLowerCase()];
+  }
+}

package/src/request/nats-request.transport.ts

@@ -0,0 +1,107 @@
+import type { ArgumentsHost, ExecutionContext } from '@nestjs/common';
+import { APP_INTERCEPTOR } from '@nestjs/core';
+import type { CustomStrategy } from '@nestjs/microservices';
+import {
+  type ConfigContext,
+  type GenericHeaders,
+  type IErrorsFormatter,
+  type IErrorsSender,
+  type IErrorsTransformer,
+  type IMicroserviceTransport,
+  Manifest,
+  type NestModuleDefinitions,
+} from '@rsdk/core';
+import { PayloadFormat } from '@rsdk/events.common';
+import { LoggerFactory } from '@rsdk/logging';
+import { DefaultNatsConfig } from '@rsdk/nats.common';
+import type { ConnectionOptions } from 'nats';
+
+import { NATS_REQUEST_PROTOCOL } from './constants';
+import { NatsRequestConfig } from './nats-request.config';
+import { NatsRequestHeaders } from './nats-request.headers';
+import { NatsRequestErrorsFormatter } from './nats-request-errors.formatter';
+import { NatsRequestErrorsSender } from './nats-request-errors.sender';
+import { NatsRequestLoggerInterceptor } from './nats-request-logger.interceptor';
+import { NatsRequestTransportModule } from './nats-request-transport.module';
+import { NatsRequestServer } from './server';
+
+export class NatsRequestTransport implements IMicroserviceTransport {
+  private readonly logger = LoggerFactory.create(NatsRequestTransport);
+  private config: DefaultNatsConfig | null = null;
+  private name = 'nats-request-unknown';
+  private responsePayloadType: PayloadFormat = PayloadFormat.JSON;
+
+  constructor(private readonly options?: ConnectionOptions) {}
+
+  extractHeaders(ctx: ExecutionContext): GenericHeaders {
+    return new NatsRequestHeaders(ctx);
+  }
+
+  getProtocol(): string {
+    return NATS_REQUEST_PROTOCOL;
+  }
+
+  matchByContext(ctx: ArgumentsHost): boolean {
+    const natsCtx = ctx.getArgByIndex(1);
+
+    return NatsRequestServer.isNatsContext(natsCtx);
+  }
+
+  getErrorsFormatter(): IErrorsFormatter {
+    return new NatsRequestErrorsFormatter();
+  }
+
+  getErrorsSender(): IErrorsSender {
+    return new NatsRequestErrorsSender();
+  }
+
+  getErrorTransformers(): IErrorsTransformer[] {
+    return [];
+  }
+
+  modules(): NestModuleDefinitions {
+    return [
+      {
+        module: NatsRequestTransportModule,
+        providers: [
+          { provide: APP_INTERCEPTOR, useClass: NatsRequestLoggerInterceptor },
+        ],
+      },
+    ];
+  }
+
+  createMicroserviceOptions(): CustomStrategy {
+    const options: ConnectionOptions = {
+      ...this.options,
+      name: this.name,
+      servers: this.config?.servers ?? 'unknown',
+      maxReconnectAttempts: this.config?.maxReconnectAttempts ?? -1,
+      reconnectTimeWait: this.config?.reconnectTimeWait ?? 2000,
+    };
+
+    this.logger.trace('createMicroserviceOptions', { options });
+
+    const { name } = Manifest.getData();
+    const server = new NatsRequestServer(options, {
+      appName: name,
+      responsePayloadType: this.responsePayloadType,
+    });
+
+    return { strategy: server };
+  }
+
+  init(configContext: ConfigContext): void {
+    const natsConfig = configContext.resolve(DefaultNatsConfig);
+    const natsRequestConfig = configContext.resolve(NatsRequestConfig);
+
+    this.config = natsConfig;
+    this.name = natsRequestConfig.name;
+    this.responsePayloadType = natsRequestConfig.defaultResponsePayloadType;
+  }
+
+  onStart(): void {
+    this.logger.info(
+      `Nats request servers: ${this.config?.servers?.join(',') ?? 'unknown'}`,
+    );
+  }
+}