@rsdk/nats.transport 5.4.0-next.2

package/src/index.ts

@@ -0,0 +1,5 @@
+export { Consume } from './metadata.decorator';
+
+export { NatsJetstreamTransport } from './nats-jetstream.transport';
+export { NatsJetstreamTransportOptions } from './types/nats-jetstream-transport-options.type';
+export { Payload } from './payload.decorator';

package/src/metadata.decorator.ts

@@ -0,0 +1,54 @@
+import { applyDecorators } from '@nestjs/common';
+import { EventPattern } from '@nestjs/microservices';
+import { NATS_JETSTREAM_TRANSPORT } from '@nestjs-plugins/nestjs-nats-jetstream-transport';
+import { BoolParser, ConfigMetadataRegistry } from '@rsdk/core';
+import type { EventType } from '@rsdk/events.common';
+import { RsdkMetadata } from '@rsdk/metadata';
+import { NATS_TOPIC_RSDK_METADATA_SCOPE } from '@rsdk/nats.common';
+import omit from 'lodash/omit';
+
+import type { ConsumeOptions } from './types/consume.options';
+
+const ConsumeMetadata =
+  <T>(eventType: EventType<T> | string): MethodDecorator =>
+  (target) => {
+    const rsdkMetadata = new RsdkMetadata(
+      target.constructor,
+      NATS_TOPIC_RSDK_METADATA_SCOPE,
+    );
+
+    const alias =
+      'NATS_STREAM_' +
+      ((eventType as EventType).$group ?? eventType)
+        .replaceAll('.', '-')
+        .toUpperCase() +
+      '_IS_MIRROR';
+
+    ConfigMetadataRegistry.registerProperty(target, alias, {
+      description: '',
+      expectedInEnv: true,
+      key: alias,
+      parser: new BoolParser(),
+    });
+
+    if (typeof eventType === 'string') {
+      rsdkMetadata.add({
+        topicName: eventType,
+      });
+      return;
+    }
+    rsdkMetadata.add({
+      eventType: omit(eventType, 'toJSON', 'encode', 'decode'),
+      group: eventType.$group,
+      partitionKeyField: eventType.$partitionKeyField,
+    });
+  };
+
+export const Consume = <T>(
+  eventType: EventType<T> | string,
+  options?: ConsumeOptions,
+): MethodDecorator =>
+  applyDecorators(
+    EventPattern({ eventType, options }, NATS_JETSTREAM_TRANSPORT),
+    ConsumeMetadata(eventType),
+  );

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

@@ -0,0 +1,13 @@
+import type { IErrorsFormatter } from '@rsdk/core';
+
+export class NatsJetstreamErrorsFormatter implements IErrorsFormatter {
+  protocol = 'nats-jetstream';
+
+  match(): boolean {
+    return false;
+  }
+
+  format(ex: unknown): unknown {
+    return ex;
+  }
+}

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

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

package/src/nats-jetstream.config.ts

@@ -0,0 +1,14 @@
+import { Config, ConfigSection, Property, StringParser } from '@rsdk/core';
+
+export const NatsJetstreamConfigInstance = Symbol(
+  'NatsJetstreamConfigInstance',
+);
+
+@ConfigSection()
+export class NatsJetstreamConfig extends Config {
+  @Property('NATS_JETSTREAM_NAME', new StringParser(), {
+    defaultValue: 'default',
+    description: 'NATS connection name',
+  })
+  name!: string;
+}

package/src/nats-jetstream.transport.ts

@@ -0,0 +1,94 @@
+import type { ArgumentsHost, ExecutionContext } from '@nestjs/common';
+import type { CustomStrategy } from '@nestjs/microservices';
+import type { NatsJetStreamServerOptions } from '@nestjs-plugins/nestjs-nats-jetstream-transport';
+import {
+  type ConfigContext,
+  type GenericHeaders,
+  type IErrorsFormatter,
+  type IErrorsTransformer,
+  type IMicroserviceTransport,
+  Manifest,
+  type NestModuleDefinitions,
+} from '@rsdk/core';
+import { LoggerFactory } from '@rsdk/logging';
+import { DefaultNatsConfig } from '@rsdk/nats.common';
+
+import type { NatsJetstreamTransportOptions } from './types/nats-jetstream-transport-options.type';
+import { NatsHeaders } from './nats.headers';
+import { NatsJetstreamConfig } from './nats-jetstream.config';
+import { NatsJetstreamErrorsFormatter } from './nats-jetstream-errors.formatter';
+import { NatsJetstreamTransportModule } from './nats-jetstream-transport.module';
+import { NatsJetStreamServer } from './server';
+
+export class NatsJetstreamTransport implements IMicroserviceTransport {
+  private readonly logger = LoggerFactory.create(NatsJetstreamTransport);
+  private servers: string[] = [];
+  private name = 'nats-jetstream-unknown';
+
+  constructor(private readonly options?: NatsJetstreamTransportOptions) {}
+
+  extractHeaders(ctx: ExecutionContext): GenericHeaders {
+    return new NatsHeaders(ctx);
+  }
+
+  getProtocol(): string {
+    return 'nats-jetstream';
+  }
+
+  matchByContext(ctx: ArgumentsHost): boolean {
+    const natsCtx = ctx.getArgByIndex(1);
+
+    return NatsJetStreamServer.isNatsContext(natsCtx);
+  }
+
+  getErrorsFormatter(): IErrorsFormatter {
+    return new NatsJetstreamErrorsFormatter();
+  }
+
+  getErrorTransformers(): IErrorsTransformer[] {
+    return [];
+  }
+
+  modules(): NestModuleDefinitions {
+    return [NatsJetstreamTransportModule];
+  }
+
+  createMicroserviceOptions(): CustomStrategy {
+    const options: NatsJetStreamServerOptions = {
+      ...this.options,
+      connectionOptions: {
+        ...this.options?.connectionOptions,
+        name: this.name,
+        servers: this.servers,
+      },
+      consumerOptions: {
+        ...this.options?.consumerOptions,
+      },
+      streamConfig: [],
+    };
+
+    this.logger.trace('createMicroserviceOptions', { options });
+
+    const { name } = Manifest.getData();
+    const server = new NatsJetStreamServer(options, {
+      appName: name,
+      autoUpdateConsumers: true,
+    });
+
+    return {
+      strategy: server,
+    };
+  }
+
+  init(configContext: ConfigContext): void {
+    const natsConfig = configContext.resolve(DefaultNatsConfig);
+    const natsJetstreamConfig = configContext.resolve(NatsJetstreamConfig);
+
+    this.name = natsJetstreamConfig.name;
+    this.servers = natsConfig.servers;
+  }
+
+  onStart(): void {
+    this.logger.info(`Nats servers: ${this.servers.join(',')}`);
+  }
+}

package/src/nats.headers.ts

@@ -0,0 +1,33 @@
+import type { ExecutionContext } from '@nestjs/common';
+import type { GenericHeaders } from '@rsdk/core';
+import { InputException } from '@rsdk/core';
+
+import { NatsJetStreamServer } from './server';
+
+/**
+ * @description хелпер для нормализованного извлечения заголовков из nats
+ */
+export class NatsHeaders implements GenericHeaders {
+  private readonly normalizedHeaders: Record<string, string>;
+
+  constructor(ctx: ExecutionContext) {
+    const natsCtx = ctx.getArgByIndex(1);
+
+    if (!NatsJetStreamServer.isNatsContext(natsCtx)) {
+      throw new InputException('Unexpected call with non Nats ArgumentHost');
+    }
+
+    this.normalizedHeaders = Object.fromEntries(
+      Object.entries(natsCtx.message.headers || {}).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/payload.decorator.ts

@@ -0,0 +1,17 @@
+import type { ExecutionContext } from '@nestjs/common';
+import { createParamDecorator } from '@nestjs/common';
+
+type Contract<T> = {
+  decode: (bytes: Uint8Array) => T;
+  encode: (data: T) => {
+    finish: () => Uint8Array;
+  };
+};
+
+export const Payload = createParamDecorator(
+  <T>(contract: Contract<T>, ctx: ExecutionContext): T => {
+    const natsContext = ctx.getArgByIndex(1);
+
+    return contract.decode(natsContext.message.data);
+  },
+);