Documentação da Biblioteca Corex

Visão Geral

A biblioteca Corex é um cliente Node.js para comunicação com servidores Corex através de conexões TCP, oferecendo funcionalidades de mensageria, canais, serviços e eventos em tempo real.

Instalação e Importação

import { Corex, flowaitec } from '@flowaitec/corex-js';

// Ou criar uma nova instância
const client = Corex();

Classe Principal: Corex

Conectando ao Servidor

// URL de conexão: fxp://username:password@host:port
await client.connect('fxp://user:pass@localhost:4222');

// Eventos de conexão
client.on('connected', () => {
  console.log('Conectado ao servidor');
});

client.on('error', (err) => {
  console.error('Erro de conexão:', err);
});

client.on('close', () => {
  console.log('Conexão fechada');
});

Métodos Principais

connect(url: string): Promise<void>

Estabelece conexão com o servidor Corex.

channel(name: string): CorexChannel

Cria e retorna um canal com o nome especificado.

team(name: string): CorexTeam

Cria e retorna um time/grupo.

close(): void

Fecha a conexão com o servidor.

Propriedades

• id: string - ID do cliente atribuído pelo servidor
• connected: boolean - Status da conexão

Classe CorexChannel

Gerenciamento de Canais

const channel = client.channel('meu-canal');

// Criar canal
await channel.create('Descrição do canal');

// Editar canal
await channel.edit('Nova descrição');

// Remover canal
await channel.remove();

// Obter informações
const info = await channel.info();

Publicação e Assinatura

Publicar Mensagens

await channel.publish('meu-topico', Buffer.from('Mensagem de exemplo'));

Assinar Tópicos

await channel.subscribe('meu-topico', (topic, message) => {
  console.log(`Mensagem recebida no tópico ${topic}:`, message.toString());
});

Serviços e Requisições

Criar Serviço

await channel.service('meu-servico', (message, reply) => {
  // Processar requisição
  const response = Buffer.from('Resposta do serviço');
  reply(null, response); // Sem erro
  // ou: reply(new Error('Erro no serviço'));
});

Fazer Requisição

try {
  const response = await channel.request(
    'meu-servico', 
    Buffer.from('Dados da requisição'),
    5000 // timeout em ms
  );
  console.log('Resposta:', response.toString());
} catch (error) {
  console.error('Erro na requisição:', error);
}

Métodos de Consulta

// Listar serviços disponíveis
const services = await channel.getServices();

// Listar eventos
const events = await channel.getEvents();

// Listar canais
const channels = await channel.list();

Sub-canais Especializados

// WebSocket
channel.ws().emit('evento', Buffer.from('dados'));

// MQTT
channel.mqtt().publish('topico', Buffer.from('mensagem'));

// Redis
channel.redis().set('chave', Buffer.from('valor'));

// Dispositivos
channel.device();

// Aplicativos
channel.app();

// Scripts
channel.script();

Classe CorexTeam

Gerenciamento de Times

const team = client.team('meu-time');

// Criar time
await team.create();

// Editar time
await team.edit();

// Listar times
await team.list();

// Remover time
await team.remove();

Gerenciamento de Membros

const member = team.member();

// Adicionar membro
await member.create();

// Editar membro
await member.edit();

// Listar membros
await member.list();

// Remover membro
await member.remove();

Gerenciamento de Canais do Time

const teamChannel = team.channel();

// Conectar canal ao time
await teamChannel.connect('nome-canal');

// Desconectar canal
await teamChannel.disconnect('nome-canal');

// Listar canais conectados
await teamChannel.list();

Tratamento de Mensagens do Servidor

Tipos de Comandos Suportados

• INFO: Informações do servidor e identificação do cliente
• MSG: Mensagens publicadas em tópicos
• CH_REQ: Requisições para serviços de canal
• RES/AUTH/CH_RES: Respostas para requisições
• OK: Confirmação de operação
• ERROR: Erros do servidor
• PING/PONG: Manutenção da conexão

Exemplo Completo de Uso

import { Corex } from '@flowaitec/corex-js';

async function exemplo() {
  const client = Corex();
  
  try {
    // Conectar
    await client.connect('fxp://usuario:senha@localhost:4222');
    
    // Criar canal
    const canal = client.channel('canal-exemplo');
    await canal.create('Canal de exemplo');
    
    // Assinar tópico
    await canal.subscribe('notificacoes', (topico, mensagem) => {
      console.log(`Notificação: ${mensagem.toString()}`);
    });
    
    // Criar serviço
    await canal.service('calculadora', (dados, responder) => {
      const numero = parseInt(dados.toString());
      const resultado = numero * 2;
      responder(null, Buffer.from(resultado.toString()));
    });
    
    // Publicar mensagem
    await canal.publish('notificacoes', Buffer.from('Olá mundo!'));
    
    // Fazer requisição
    const resposta = await canal.request('calculadora', Buffer.from('5'), 3000);
    console.log(`Resultado: ${resposta.toString()}`); // "10"
    
  } catch (error) {
    console.error('Erro:', error);
  } finally {
    client.close();
  }
}

exemplo();

Tratamento de Erros

A biblioteca utiliza Promises e callbacks com tratamento de erro consistente:

try {
  await channel.publish('topico', dados);
} catch (error) {
  console.error('Falha ao publicar:', error.message);
}

// Em callbacks de serviço
channel.service('servico', (mensagem, reply) => {
  try {
    // Processamento
    reply(null, resultado);
  } catch (error) {
    reply(error); // Envia erro para o cliente
  }
});

Timeouts

Todas as operações de requisição suportam timeout:

// Timeout de 5 segundos
const resposta = await channel.request('servico', dados, 5000);

Buffer como Formato de Dados

Todos os dados são transmitidos como Buffers, permitindo flexibilidade no formato:

// Texto
Buffer.from('Texto simples', 'utf8');

// JSON
Buffer.from(JSON.stringify({ chave: 'valor' }));

// Dados binários
Buffer.from(arrayBuffer);

Esta documentação cobre os principais aspectos da biblioteca Corex para implementação de clientes robustos de mensageria em tempo real.