refactor: Code to use factory pattern

[LeonardoVieira1630]

Description

Standardize class initialization across all microservices by implementing the Factory Pattern to handle asynchronous initialization properly and avoid initialization-related issues.

Background

Currently, microservices lack a consistent initialization pattern for classes, leading to various problematic approaches. Some components use flags to verify if they've been initialized, others call init functions within other methods, and some attempt initialization within constructors. Since TypeScript constructors are mandatory synchronous, we cannot wait for asynchronous methods to complete, which can result in functions being called before classes are fully initialized.

Problem Statement

The inconsistent initialization patterns create race conditions and reliability issues where methods may be invoked on incompletely initialized objects. After researching industry-standard approaches, while the current implementations are technically correct, adopting the Factory Pattern would bring significant benefits for maintainability, reliability, and code consistency.

Factory Pattern Overview

The Factory Pattern provides a way to create objects without specifying their concrete classes directly. In our context, it allows us to handle complex asynchronous initialization by encapsulating the creation logic in static factory methods that can properly await initialization steps before returning fully-initialized instances.

Implementation Example

// Before: Problematic initialization
class DatabaseService {
  private connection: Connection;
  private isInitialized = false;

  constructor(config: Config) {
    // Cannot await here - constructor must be sync
    this.initConnection(config);
  }

  private async initConnection(config: Config) {
    this.connection = await createConnection(config);
    this.isInitialized = true;
  }

  async query(sql: string) {
    if (!this.isInitialized) {
      throw new Error('Service not initialized');
    }
    return this.connection.query(sql);
  }
}

// After: Factory Pattern
class DatabaseService {
  private constructor(private connection: Connection) {}

  static async create(config: Config): Promise<DatabaseService> {
    const connection = await createConnection(config);
    await connection.authenticate();
    return new DatabaseService(connection);
  }

  async query(sql: string) {
    return this.connection.query(sql);
  }
}

// Usage:
// const dbService = await DatabaseService.create(config);