@suissa/universal-queues/src/index.ts

Factory universal para mensageria (RabbitMQ, Kafka, SQS) para sistemas distribuídos.

import { IMessaging } from './interfaces/IMessaging';
import { RabbitMQClient } from './rabbitmq';
import { RedisHistory, IHistory } from './clients/history.redis';


type RabbitOptions = {
  uri?: string;
  name?: string;         // chave do cache (ex.: "default", "low-priority")
  prefetch?: number;     // channel.prefetch
  connect?: boolean;     // default: true
};

const instances = new Map<string, IMessaging>();

export class MessagingFactory {
  static async create(
    driver: 'rabbitmq',
    uriOrOptions?: string | RabbitOptions
  ): Promise<IMessaging> {
    if (driver !== 'rabbitmq') {
      throw new Error(`Driver não suportado: ${driver}`);
    }

    // Normaliza opções
    const opts: RabbitOptions = typeof uriOrOptions === 'string'
      ? { uri: uriOrOptions }
      : (uriOrOptions || {});

    const name = opts.name || 'default';
    const cacheKey = `rabbitmq::${name}`;

    // Reaproveita instância já conectada
    const cached = instances.get(cacheKey);
    if (cached) return cached;

    const client = new RabbitMQClient({
      prefetch: opts.prefetch ?? 20, // valor padrão razoável
    });

    const shouldConnect = opts.connect !== false;
    if (shouldConnect) {
      const uri =
        opts.uri ||
        process.env.RABBITMQ_URI ||
        'amqp://localhost:5672';

      await client.connect(uri);
    }

    instances.set(cacheKey, client);
    return client;
  }
}

// export class MessagingFactory {
//   static create(type: 'rabbitmq' = 'rabbitmq'): IMessaging {
//     if (type === 'rabbitmq') return new RabbitMQClient();
//     // Futuro: if (type === 'kafka') return new KafkaClient();
//     throw new Error(`Mensageria não suportada: ${type}`);
//   }
// }


export class HistoryFactory {
  static create(type: 'redis' = 'redis'): IHistory {
    if (type === 'redis') return new RedisHistory();
    throw new Error(`Cache não suportada: ${type}`);
  }
}