refactor: refactor configurations

src/booking/src/booking/features/v1/create-booking/create-booking.ts

@@ -5,13 +5,13 @@ import Joi from 'joi';
 import { inject, injectable } from 'tsyringe';
 import mapper from '../../../mappings';
 import notFoundException from 'building-blocks/types/exception/not-found.exception';
-import { IPublisher } from 'building-blocks/rabbitmq/rabbitmq';
 import { BookingCreated } from 'building-blocks/contracts/booking.contract';
 import {BookingDto} from "../../../dtos/booking.dto";
 import {IBookingRepository} from "../../../../data/repositories/booking.repository";
 import {Booking} from "../../../entities/booking.entity";
 import {IFlightClient} from "../../../http-client/services/flight/flight.client";
 import {IPassengerClient} from "../../../http-client/services/passenger/passenger.client";
+import {IPublisher} from "building-blocks/rabbitmq/rabbitmq-publisher";
 
 export class CreateBooking implements IRequest<BookingDto> {
   passengerId: number;

src/booking/src/data/db.context.ts

@@ -1,11 +1,11 @@
 import { container } from 'tsyringe';
-import {Connection, DataSourceOptions} from 'typeorm';
-import {registerRepositories} from "../extensions/repository.extensions";
-import {DbContext, IDbContext} from "building-blocks/typeorm/db-context";
+import { DataSource, DataSourceOptions } from 'typeorm';
+import { registerRepositories } from '../extensions/repository.extensions';
+import { DbContext, IDbContext } from 'building-blocks/typeorm/db-context';
 
 export const initialDbContext = async (
   dataSourceOptions: DataSourceOptions
-): Promise<Connection> => {
+): Promise<DataSource> => {
   container.registerSingleton<IDbContext>('IDbContext', DbContext);
 
   const dbContext = container.resolve(DbContext);

src/booking/src/extensions/otel.extensions.ts

@@ -7,7 +7,7 @@ import {OpenTelemetryTracer} from "building-blocks/open-telemetry/open-telemetry
 export const initialOpenTelemetry = async (app?: Express): Promise<OpenTelemetryTracer> => {
   // tracing
   const openTelemetryTracer = container.resolve(OpenTelemetryTracer);
-  await openTelemetryTracer.createTracer(config.serviceName);
+  await openTelemetryTracer.createTracer((x) => x.serviceName == x.serviceName);
 
   // monitoring
   if (app) {

src/booking/src/extensions/rabbitmq.extensions.ts

@@ -1,18 +1,18 @@
+import { RabbitMQConnection, RabbitmqOptions } from 'building-blocks/rabbitmq/rabbitmq-connection';
 import { container } from 'tsyringe';
-import {
-  Consumer,
-  IConsumer,
-  IPublisher,
-  Publisher,
-  RabbitMQConnection, RabbitmqOptions
-} from 'building-blocks/rabbitmq/rabbitmq';
+import { IPublisher, Publisher } from 'building-blocks/rabbitmq/rabbitmq-publisher';
 
 export const initialRabbitmq = async (options?: RabbitmqOptions): Promise<RabbitMQConnection> => {
   const rabbitMQConnection = container.resolve(RabbitMQConnection);
-  await rabbitMQConnection.createConnection(options);
+
+  await rabbitMQConnection.createConnection((optionsBuilder) => {
+    optionsBuilder.host = options?.host;
+    optionsBuilder.port = options?.port;
+    optionsBuilder.username = options?.username;
+    optionsBuilder.password = options?.password;
+  });
 
   container.register<IPublisher>('IPublisher', Publisher);
-  container.register<IConsumer>('IConsumer', Consumer);
 
   return rabbitMQConnection;
 };

src/building-blocks/open-telemetry/open-telemetry-options-builder.d.ts

@@ -0,0 +1,11 @@
+import { OpenTelemetryOptions } from './open-telemetry';
+export declare class OpenTelemetryOptionsBuilder {
+    private _options;
+    get jaegerEndpoint(): string;
+    set jaegerEndpoint(value: string);
+    get zipkinEndpoint(): string;
+    set zipkinEndpoint(value: string);
+    get serviceName(): string;
+    set serviceName(value: string);
+    build(): OpenTelemetryOptions;
+}

src/building-blocks/open-telemetry/open-telemetry-options-builder.ts

@@ -0,0 +1,33 @@
+import { OpenTelemetryOptions } from './open-telemetry';
+
+export class OpenTelemetryOptionsBuilder {
+  private _options: OpenTelemetryOptions = new OpenTelemetryOptions();
+
+  get jaegerEndpoint(): string {
+    return this._options.jaegerEndpoint;
+  }
+
+  set jaegerEndpoint(value: string) {
+    this._options.jaegerEndpoint = value;
+  }
+
+  get zipkinEndpoint(): string {
+    return this._options.zipkinEndpoint;
+  }
+
+  set zipkinEndpoint(value: string) {
+    this._options.zipkinEndpoint = value;
+  }
+
+  get serviceName(): string {
+    return this._options.serviceName;
+  }
+
+  set serviceName(value: string) {
+    this._options.serviceName = value;
+  }
+
+  build(): OpenTelemetryOptions {
+    return this._options;
+  }
+}

src/building-blocks/open-telemetry/open-telemetry.d.ts

@@ -1,7 +1,13 @@
 import { Tracer } from '@opentelemetry/sdk-trace-node';
+import { OpenTelemetryOptionsBuilder } from './open-telemetry-options-builder';
+export declare class OpenTelemetryOptions {
+    jaegerEndpoint: string;
+    zipkinEndpoint: string;
+    serviceName: string;
+}
 export interface IOpenTelemetryTracer {
-    createTracer(tracerName: string): Promise<Tracer>;
+    createTracer(openTelemetryOptionsBuilder?: (openTelemetryOptionsBuilder?: OpenTelemetryOptionsBuilder) => void): Promise<Tracer>;
 }
 export declare class OpenTelemetryTracer implements IOpenTelemetryTracer {
-    createTracer(tracerName: string): Promise<Tracer>;
+    createTracer(openTelemetryOptionsBuilder: (openTelemetryOptionsBuilder?: OpenTelemetryOptionsBuilder) => void): Promise<Tracer>;
 }

src/building-blocks/open-telemetry/open-telemetry.ts

@@ -5,6 +5,8 @@ import config from '../config/config';
 import { ZipkinExporter } from '@opentelemetry/exporter-zipkin';
 import { Resource } from '@opentelemetry/resources';
 import { SemanticResourceAttributes } from '@opentelemetry/semantic-conventions';
+import { RabbitmqOptionsBuilder } from '../rabbitmq/rabbitmq-options-builder';
+import { OpenTelemetryOptionsBuilder } from './open-telemetry-options-builder';
 
 const { NodeTracerProvider } = require('@opentelemetry/node');
 const { SimpleSpanProcessor } = require('@opentelemetry/tracing');
@@ -13,26 +15,43 @@ const { AmqplibInstrumentation } = require('@opentelemetry/instrumentation-amqpl
 const { ExpressInstrumentation } = require('@opentelemetry/instrumentation-express');
 const { HttpInstrumentation } = require('@opentelemetry/instrumentation-http');
 
+export class OpenTelemetryOptions {
+  jaegerEndpoint: string;
+  zipkinEndpoint: string;
+  serviceName: string;
+}
+
 export interface IOpenTelemetryTracer {
-  createTracer(tracerName: string): Promise<Tracer>;
+  createTracer(
+    openTelemetryOptionsBuilder?: (
+      openTelemetryOptionsBuilder?: OpenTelemetryOptionsBuilder
+    ) => void
+  ): Promise<Tracer>;
 }
 
 @injectable()
 export class OpenTelemetryTracer implements IOpenTelemetryTracer {
-  async createTracer(tracerName: string): Promise<Tracer> {
+  async createTracer(
+    openTelemetryOptionsBuilder: (openTelemetryOptionsBuilder?: OpenTelemetryOptionsBuilder) => void
+  ): Promise<Tracer> {
+    const builder = new OpenTelemetryOptionsBuilder();
+    openTelemetryOptionsBuilder(builder);
+
+    const options = builder.build();
+
     const provider = new NodeTracerProvider({
       resource: new Resource({
-        [SemanticResourceAttributes.SERVICE_NAME]: config.serviceName
+        [SemanticResourceAttributes.SERVICE_NAME]: options?.serviceName ?? config.serviceName
       })
     });
 
     const jaegerExporter = new JaegerExporter({
-      endpoint: config.monitoring.jaegerEndpoint
+      endpoint: options?.jaegerEndpoint ?? config.monitoring.jaegerEndpoint
     });
 
     const zipkinExporter = new ZipkinExporter({
-      url: config.monitoring.zipkinEndpoint,
-      serviceName: config.serviceName
+      url: options?.zipkinEndpoint ?? config.monitoring.zipkinEndpoint,
+      serviceName: options?.serviceName ?? config.serviceName
     });
 
     provider.addSpanProcessor(new SimpleSpanProcessor(jaegerExporter));
@@ -44,11 +63,11 @@ export class OpenTelemetryTracer implements IOpenTelemetryTracer {
       instrumentations: [
         new HttpInstrumentation(),
         new ExpressInstrumentation(),
-        new AmqplibInstrumentation(),
+        new AmqplibInstrumentation()
       ]
     });
 
-    const tracer = provider.getTracer(tracerName);
+    const tracer = provider.getTracer(options?.serviceName ?? config.serviceName);
 
     return tracer;
   }

src/building-blocks/rabbitmq/rabbitmq-connection.d.ts

@@ -0,0 +1,22 @@
+import { Logger } from '../logging/logger';
+import { RabbitmqOptionsBuilder } from './rabbitmq-options-builder';
+import * as amqp from 'amqplib';
+export declare class RabbitmqOptions {
+    host: string;
+    port: number;
+    username: string;
+    password: string;
+}
+export interface IRabbitMQConnection {
+    createConnection(rabbitmqOptionsBuilder?: (rabbitmqOptionsBuilder?: RabbitmqOptionsBuilder) => void): Promise<amqp.Connection>;
+    getChannel(): Promise<amqp.Channel>;
+    closeChanel(): Promise<void>;
+    closeConnection(): Promise<void>;
+}
+export declare class RabbitMQConnection implements IRabbitMQConnection {
+    logger: Logger;
+    createConnection(rabbitmqOptionsBuilder?: (rabbitmqOptionsBuilder?: RabbitmqOptionsBuilder) => void): Promise<amqp.Connection>;
+    getChannel(): Promise<amqp.Channel>;
+    closeChanel(): Promise<void>;
+    closeConnection(): Promise<void>;
+}