# @hirehq/queue-service

A private npm package for HireHQ queue subscriber and publisher functionality using RabbitMQ.

## Features

- **Queue Subscriber**: Consume messages from RabbitMQ queues
- **Queue Publisher**: Publish messages to RabbitMQ exchanges
- **Unified Queue Service**: Combined subscriber and publisher functionality
- **TypeScript Support**: Full TypeScript definitions included
- **Configurable**: Environment-based configuration with fallbacks
- **Error Handling**: Robust error handling and logging

## Installation

```bash
npm install @hirehq/queue-service
```

## Usage

### Basic Usage

```typescript
import { createQueueService, MessageHandler } from '@hirehq/queue-service';
import { ConsumeMessage } from 'amqplib';

// Define your message handler
class MyMessageHandler implements MessageHandler {
  async handleMessage(msg: ConsumeMessage): Promise<void> {
    const messageContent = msg.content.toString();
    console.log('Received message:', messageContent);

    // Process your message here
    const data = JSON.parse(messageContent);
    // ... your processing logic
  }
}

// Create queue service
const messageHandler = new MyMessageHandler();
const queueService = createQueueService(fastifyInstance, messageHandler);

// Start subscription
await queueService.startSubscription();

// Publish a message
const success = await queueService.publishMessage({
  type: 'notification',
  data: { userId: '123', message: 'Hello!' }
});

// Publish with custom routing key
const success = await queueService.publishMessage(
  { type: 'email', data: { to: 'user@example.com' } },
  'email.notification'
);
```

### Advanced Usage

```typescript
import { QueueService, QueueConfig } from '@hirehq/queue-service';

// Custom configuration
const config: QueueConfig = {
  queueName: 'my-custom-queue',
  exchangeName: 'my-custom-exchange',
  routingKey: 'my-custom-routing-key',
  host: 'rabbitmq.example.com',
  port: 5672,
  username: 'myuser',
  password: 'mypassword',
  vhost: '/myvhost'
};

// Create with custom config
const queueService = new QueueService(fastifyInstance, messageHandler);

// Publish batch messages
const messages = [
  { type: 'email', data: { to: 'user1@example.com' } },
  { type: 'sms', data: { to: '+1234567890' } },
  { type: 'notification', data: { userId: '123' } }
];

const result = await queueService.publishBatch(messages, 'batch.notification');
console.log(`Published: ${result.success} successful, ${result.failed} failed`);

// Check subscription status
if (queueService.isSubscriptionActive()) {
  console.log('Queue subscription is active');
}

// Close connection
await queueService.closeConnection();
```

### Environment Variables

The package uses the following environment variables with defaults:

- `RABBITMQ_QUEUE_NAME` (default: 'notification_queue')
- `RABBITMQ_EXCHANGE_NAME` (default: 'notification_exchange')
- `RABBITMQ_ROUTING_KEY` (default: 'notification')
- `RABBITMQ_HOST` (default: 'localhost')
- `RABBITMQ_PORT` (default: 5672)
- `RABBITMQ_USERNAME` (default: 'guest')
- `RABBITMQ_PASSWORD` (default: 'guest')
- `RABBITMQ_VHOST` (default: '/')

## API Reference

### QueueService

Main class that combines subscriber and publisher functionality.

#### Methods

- `startSubscription()`: Start consuming messages from the queue
- `publishMessage(message, routingKey?)`: Publish a single message
- `publishMessageWithOptions(options)`: Publish with advanced options
- `publishBatch(messages, routingKey?)`: Publish multiple messages
- `closeConnection()`: Close the queue connection
- `isSubscriptionActive()`: Check if subscription is active

### QueueSubscriber

Handles message consumption from RabbitMQ queues.

#### Methods

- `startSubscription()`: Start the subscription
- `stopSubscription()`: Stop the subscription
- `isSubscriptionActive()`: Check subscription status

### QueuePublisher

Handles message publishing to RabbitMQ exchanges.

#### Methods

- `publishMessage(message, routingKey?)`: Publish a single message
- `publishMessageWithOptions(options)`: Publish with options
- `publishBatch(messages, routingKey?)`: Publish multiple messages

## Types

### QueueConfig

```typescript
interface QueueConfig {
  queueName?: string;
  exchangeName?: string;
  routingKey?: string;
  host?: string;
  port?: number;
  username?: string;
  password?: string;
  vhost?: string;
}
```

### MessageHandler

```typescript
interface MessageHandler {
  handleMessage(msg: ConsumeMessage): Promise<void>;
}
```

### PublishMessageOptions

```typescript
interface PublishMessageOptions {
  message: any;
  routingKey?: string;
  exchangeName?: string;
  persistent?: boolean;
}
```

## Development

### Building

```bash
npm run build
```

### Testing

```bash
npm test
```

### Linting

```bash
npm run lint
npm run lint:check
```

### Formatting

```bash
npm run format
npm run format:check
```

## License

UNLICENSED - Private package for HireHQ use only.