@autofleet/kafka 0.0.1

package/README.md

@@ -0,0 +1,579 @@
+# @autofleet/kafka
+
+Internal wrapper for Apache Kafka producer using [@platformatic/kafka](https://www.npmjs.com/package/@platformatic/kafka), providing a production-ready interface for publishing messages to Kafka topics.
+
+## Table of Contents
+
+- [Installation](#installation)
+- [Features](#features)
+- [Quick Start](#quick-start)
+- [Usage](#usage)
+  - [Publishing Messages](#publishing-messages)
+  - [Batch Publishing](#batch-publishing)
+  - [Managing Connection](#managing-connection)
+- [Configuration](#configuration)
+- [Advanced Features](#advanced-features)
+  - [Message Keys for Partitioning](#message-keys-for-partitioning)
+  - [Custom Headers](#custom-headers)
+  - [Partition Control](#partition-control)
+- [API Reference](#api-reference)
+- [Best Practices](#best-practices)
+- [Testing](#testing)
+
+## Installation
+
+```bash
+pnpm add @autofleet/kafka
+```
+
+## Features
+
+- **Simple Producer API** - Easy-to-use interface for publishing messages
+- **Automatic Connection Management** - Handles connection lifecycle automatically
+- **Batch Publishing** - Efficient batch message sending
+- **Message Partitioning** - Control message distribution across partitions
+- **Custom Headers** - Attach metadata to messages
+- **Graceful Shutdown** - Automatic cleanup on process termination
+- **Type Safety** - Full TypeScript support
+- **Production Ready** - Built with reliability and performance in mind
+
+## Quick Start
+
+```typescript
+import AfKafka from '@autofleet/kafka';
+
+// Initialize the producer
+const kafka = new AfKafka({
+  brokers: ['localhost:9092'],
+  clientId: 'my-service',
+});
+
+// Publish a message
+await kafka.publish('user-events', {
+  userId: '123',
+  action: 'user.created',
+  timestamp: Date.now(),
+});
+
+// Publish multiple messages in a batch
+await kafka.publishBatch({
+  topic: 'user-events',
+  messages: [
+    { value: { userId: '123', action: 'login' } },
+    { value: { userId: '456', action: 'logout' } },
+  ],
+});
+
+// Disconnect when done
+await kafka.disconnect();
+```
+
+## Usage
+
+### Publishing Messages
+
+#### Basic Publishing
+
+```typescript
+const kafka = new AfKafka({
+  brokers: ['localhost:9092', 'localhost:9093'],
+  clientId: 'user-service',
+});
+
+// Publish a simple message
+await kafka.publish('user-events', {
+  userId: '123',
+  event: 'profile_updated',
+  data: {
+    name: 'John Doe',
+    email: 'john@example.com',
+  },
+});
+```
+
+#### Publishing with Message Key
+
+Message keys determine which partition a message goes to, ensuring messages with the same key are always sent to the same partition (maintaining order).
+
+```typescript
+await kafka.publish(
+  'user-events',
+  { userId: '123', action: 'update' },
+  {
+    key: 'user-123', // All messages with this key go to the same partition
+  }
+);
+```
+
+#### Publishing with Custom Headers
+
+```typescript
+await kafka.publish(
+  'user-events',
+  { userId: '123', action: 'login' },
+  {
+    headers: {
+      'correlation-id': requestId,
+      'source': 'api-gateway',
+      'version': '1.0.0',
+    },
+  }
+);
+```
+
+#### Publishing to Specific Partition
+
+```typescript
+await kafka.publish(
+  'user-events',
+  { userId: '123', action: 'update' },
+  {
+    partition: 2, // Send directly to partition 2
+  }
+);
+```
+
+### Batch Publishing
+
+Batch publishing is more efficient for sending multiple messages:
+
+```typescript
+await kafka.publishBatch({
+  topic: 'user-events',
+  messages: [
+    {
+      value: { userId: '123', action: 'login' },
+      key: 'user-123',
+    },
+    {
+      value: { userId: '456', action: 'logout' },
+      key: 'user-456',
+    },
+    {
+      value: { userId: '789', action: 'update' },
+      key: 'user-789',
+      headers: { priority: 'high' },
+    },
+  ],
+});
+```
+
+### Managing Connection
+
+```typescript
+// The producer connects automatically on first publish
+await kafka.publish('my-topic', { data: 'value' });
+
+// Disconnect when you're done
+await kafka.disconnect();
+
+// Graceful shutdown is automatic on SIGTERM/SIGINT
+// unless dontGracefulShutdown is set to true
+```
+
+## Configuration
+
+### KafkaOptions
+
+```typescript
+interface KafkaOptions {
+  // Array of Kafka broker addresses (required)
+  brokers: string[];
+
+  // Client ID for this producer (optional)
+  clientId?: string;
+
+  // Custom logger instance (optional)
+  logger?: LoggerInstanceManager;
+
+  // Skip automatic graceful shutdown (default: false)
+  dontGracefulShutdown?: boolean;
+}
+```
+
+The package uses [@platformatic/kafka](https://www.npmjs.com/package/@platformatic/kafka) with `jsonSerializer` for automatic JSON serialization of message values.
+
+## Advanced Features
+
+### Message Keys for Partitioning
+
+Use message keys to control partitioning and maintain order:
+
+```typescript
+// All messages for the same user go to the same partition
+await kafka.publish('user-events', event, {
+  key: `user-${userId}`,
+});
+
+// All messages for the same order go to the same partition
+await kafka.publish('order-events', event, {
+  key: `order-${orderId}`,
+});
+```
+
+**Why use keys?**
+- Ensures messages with the same key are ordered
+- Enables partition-level parallelism
+- Supports stateful stream processing
+
+### Custom Headers
+
+Headers are useful for metadata and message routing:
+
+```typescript
+await kafka.publish('events', data, {
+  headers: {
+    // Correlation ID for distributed tracing
+    'correlation-id': correlationId,
+
+    // Source service
+    'source': 'user-service',
+
+    // Message schema version
+    'schema-version': '2.0',
+
+    // Content encoding
+    'encoding': 'json',
+
+    // Custom application headers
+    'tenant-id': 'tenant-123',
+  },
+});
+```
+
+### Partition Control
+
+Direct partition control for advanced use cases:
+
+```typescript
+// Send to specific partition
+await kafka.publish('events', data, {
+  partition: 0, // Always send to partition 0
+});
+
+// Balance across partitions using keys
+const partitionKey = `${customerId % 10}`;
+await kafka.publish('events', data, {
+  key: partitionKey,
+});
+```
+
+## API Reference
+
+### `new AfKafka(options)`
+
+Creates a new Kafka producer instance.
+
+**Parameters:**
+- `options` - Configuration options (see [Configuration](#configuration))
+
+**Example:**
+```typescript
+const kafka = new AfKafka({
+  brokers: ['localhost:9092'],
+  clientId: 'my-service',
+});
+```
+
+### `publish<T>(topic, value, options?): Promise<RecordMetadata[]>`
+
+Publishes a single message to a topic.
+
+**Parameters:**
+- `topic` - Topic name
+- `value` - Message value (will be JSON stringified)
+- `options` (optional) - Publish options
+
+**Returns:** Array of record metadata (partition, offset, etc.)
+
+**Example:**
+```typescript
+const metadata = await kafka.publish('events', { id: 1, data: 'test' }, {
+  key: 'key-1',
+  headers: { type: 'create' },
+});
+
+console.log(`Published to partition ${metadata[0].partition} at offset ${metadata[0].offset}`);
+```
+
+### `publishBatch(options): Promise<RecordMetadata[]>`
+
+Publishes multiple messages in a batch to a topic.
+
+**Parameters:**
+- `options.topic` - Topic name
+- `options.messages` - Array of messages with values, keys, headers, etc.
+
+**Returns:** Array of record metadata for each message
+
+**Example:**
+```typescript
+const metadata = await kafka.publishBatch({
+  topic: 'events',
+  messages: [
+    { value: { id: 1 }, key: 'key-1' },
+    { value: { id: 2 }, key: 'key-2' },
+  ],
+});
+```
+
+### `disconnect(): Promise<void>`
+
+Disconnects the producer and cleans up resources.
+
+**Example:**
+```typescript
+await kafka.disconnect();
+```
+
+## Best Practices
+
+### 1. Use Centralized Topic Definitions
+
+Define your topics in `src/topics.ts`:
+
+```typescript
+export const TOPICS = {
+  USER_EVENTS: 'user-events',
+  ORDER_EVENTS: 'order-events',
+  PAYMENT_EVENTS: 'payment-events',
+} as const;
+
+export type TopicName = typeof TOPICS[keyof typeof TOPICS];
+```
+
+Usage:
+
+```typescript
+import { TOPICS } from './topics';
+
+await kafka.publish(TOPICS.USER_EVENTS, data);
+```
+
+### 2. Use Message Keys for Ordering
+
+```typescript
+// Ensure all events for a user are processed in order
+await kafka.publish('user-events', event, {
+  key: `user-${userId}`,
+});
+
+// Ensure all events for a session are processed in order
+await kafka.publish('session-events', event, {
+  key: `session-${sessionId}`,
+});
+```
+
+### 3. Add Metadata with Headers
+
+```typescript
+await kafka.publish('events', data, {
+  headers: {
+    'correlation-id': requestId,
+    'source-service': serviceName,
+    'event-type': eventType,
+    'schema-version': '1.0',
+  },
+});
+```
+
+### 4. Use Batch Publishing for High Throughput
+
+```typescript
+// Instead of multiple publish calls
+for (const event of events) {
+  await kafka.publish('events', event); // ❌ Slow
+}
+
+// Use batch publishing
+await kafka.publishBatch({
+  topic: 'events',
+  messages: events.map(e => ({ value: e })), // ✅ Fast
+});
+```
+
+### 5. Handle Errors Gracefully
+
+```typescript
+try {
+  await kafka.publish('events', data);
+} catch (error) {
+  logger.error('Failed to publish to Kafka', { error, data });
+  // Consider:
+  // - Retry logic
+  // - Fallback to queue
+  // - Alert monitoring
+}
+```
+
+### 6. Use Multiple Brokers for High Availability
+
+```typescript
+const kafka = new AfKafka({
+  brokers: ['kafka1:9092', 'kafka2:9092', 'kafka3:9092'],
+  clientId: 'my-service',
+});
+```
+
+### 7. Monitor Production Metrics
+
+```typescript
+const metadata = await kafka.publish('events', data);
+
+// Log metrics
+logger.info('Message published', {
+  topic: 'events',
+  partition: metadata[0].partition,
+  offset: metadata[0].offset,
+  latency: Date.now() - startTime,
+});
+```
+
+## Testing
+
+Run the test suite:
+
+```bash
+pnpm test
+```
+
+Run tests with coverage:
+
+```bash
+pnpm run coverage
+```
+
+### Example Test
+
+```typescript
+import { describe, it, expect, beforeEach } from 'vitest';
+import AfKafka from '@autofleet/kafka';
+
+describe('MyKafkaService', () => {
+  let kafka: AfKafka;
+
+  beforeEach(() => {
+    kafka = new AfKafka({
+      brokers: ['localhost:9092'],
+      clientId: 'test-client',
+    });
+  });
+
+  it('should publish event successfully', async () => {
+    const result = await kafka.publish('test-topic', {
+      userId: '123',
+      action: 'test',
+    });
+
+    expect(result).toBeDefined();
+    expect(result[0]).toHaveProperty('partition');
+    expect(result[0]).toHaveProperty('offset');
+  });
+});
+```
+
+## Environment Variables
+
+Common environment variable patterns:
+
+```bash
+# Kafka brokers
+KAFKA_BROKERS=kafka1:9092,kafka2:9092,kafka3:9092
+
+# Client configuration
+KAFKA_CLIENT_ID=my-service
+KAFKA_SASL_USERNAME=user
+KAFKA_SASL_PASSWORD=pass
+```
+
+Usage:
+
+```typescript
+const kafka = new AfKafka({
+  brokers: process.env.KAFKA_BROKERS?.split(',') || ['localhost:9092'],
+  clientId: process.env.KAFKA_CLIENT_ID || 'default-client',
+});
+```
+
+## Common Patterns
+
+### Event Sourcing
+
+```typescript
+await kafka.publish('user-events', {
+  eventType: 'UserCreated',
+  aggregateId: userId,
+  timestamp: Date.now(),
+  data: userData,
+}, {
+  key: userId,
+  headers: {
+    'event-type': 'UserCreated',
+    'aggregate-type': 'User',
+  },
+});
+```
+
+### Change Data Capture (CDC)
+
+```typescript
+await kafka.publish('database-changes', {
+  operation: 'INSERT',
+  table: 'users',
+  before: null,
+  after: newUserRecord,
+}, {
+  key: newUserRecord.id,
+  headers: {
+    'schema': 'public',
+    'table': 'users',
+  },
+});
+```
+
+### Dead Letter Queue Pattern
+
+```typescript
+try {
+  await processMessage(message);
+} catch (error) {
+  // Send to DLQ for manual review
+  await kafka.publish('events-dlq', {
+    originalTopic: 'events',
+    error: error.message,
+    message: message,
+  });
+}
+```
+
+## Troubleshooting
+
+### Connection Issues
+
+```typescript
+// Use multiple brokers for redundancy
+const kafka = new AfKafka({
+  brokers: ['kafka1:9092', 'kafka2:9092', 'kafka3:9092'],
+  clientId: 'my-service',
+});
+```
+
+### Performance Tuning
+
+For high-throughput scenarios, use batch publishing:
+
+```typescript
+// Batch multiple messages together
+await kafka.publishBatch({
+  topic: 'events',
+  messages: events.map(e => ({ value: e })),
+});
+```
+
+## License
+
+Proprietary - Autofleet
+
+## Support
+
+For issues or questions, please contact the platform team or create an issue in the repository.

package/dist/index.cjs

@@ -0,0 +1,2 @@
+Object.defineProperty(exports,`__esModule`,{value:!0});let e=require(`@platformatic/kafka`);const t={info:(...e)=>console.log(`[INFO]`,...e),error:(...e)=>console.error(`[ERROR]`,...e),warn:(...e)=>console.warn(`[WARN]`,...e),debug:(...e)=>console.debug(`[DEBUG]`,...e)};var n=t,r=class extends Error{constructor(e){super(e),this.name=`KafkaError`}};const i=`x-timestamp`,a=`autofleet-kafka-producer`;var o=class{constructor(t){if(this.isDisconnected=!1,this.isVerified=!1,this.gracefulShutdownStarted=!1,!t.brokers||t.brokers.length===0)throw new r(`At least one broker is required`);this.logger=t.logger??n,this.producer=new e.Producer({bootstrapBrokers:t.brokers,clientId:t.clientId||a,serializers:e.stringSerializers}),this.logger.info(`Kafka: Initializing Kafka producer`,{clientId:t.clientId||a,brokers:t.brokers}),t.dontGracefulShutdown||this.setupGracefulShutdown()}setupGracefulShutdown(){this.logger.info(`Kafka: [graceful-shutdown] adding graceful shutdown for process.pid ${process.pid}`),process.on(`SIGTERM`,async()=>{await this.gracefulShutdown(`SIGTERM`)}),process.on(`SIGINT`,async()=>{await this.gracefulShutdown(`SIGINT`)})}async gracefulShutdown(e){if(!this.gracefulShutdownStarted){this.gracefulShutdownStarted=!0,this.logger.info(`Kafka: [graceful-shutdown] received ${e}! Disconnecting producer...`);try{await this.disconnect(),this.logger.info(`Kafka: [graceful-shutdown] producer disconnected successfully`)}catch(e){throw this.logger.error(`Kafka: [graceful-shutdown] error during shutdown`,{error:e}),e}}}get isConnected(){return this.producer.isConnected()}async ping(){if(!this.isVerified)try{let e=await this.producer.metadata({topics:[]});this.isVerified=!0,this.logger.info(`Kafka: Successfully connected to cluster`,{clusterId:e.id,brokers:e.brokers.size})}catch(e){throw this.logger.error(`Kafka: Failed to connect to brokers`,{error:e}),new r(`Failed to connect to Kafka brokers: ${e.message}`)}}async publish(e,t,n){if(!e)throw new r(`Topic name is required`);await this.ping();try{let r={[i]:Date.now().toString(),...n?.headers},a=await this.producer.send({messages:[{topic:e,value:JSON.stringify(t),key:n?.key,partition:n?.partition,headers:r}]});return this.logger.debug(`Kafka: Published message to topic ${e}`,{topic:e}),[a]}catch(n){let i=n;throw this.logger.error(`Kafka: Error publishing to topic ${e}`,{error:n,value:t}),new r(`Failed to publish to topic ${e}: ${i.message||`Unknown error`}`)}}async publishBatch(e){if(!e.topic)throw new r(`Topic name is required`);if(!e.messages||e.messages.length===0)throw new r(`At least one message is required`);await this.ping();try{let t=e.messages.map(t=>({topic:e.topic,value:JSON.stringify(t.value),key:t.key,partition:t.partition,headers:{[i]:Date.now().toString(),...t.headers}})),n=await this.producer.send({messages:t});return this.logger.debug(`Kafka: Published ${t.length} messages to topic ${e.topic}`,{topic:e.topic,count:t.length}),[n]}catch(t){let n=t;throw this.logger.error(`Kafka: Error publishing batch to topic ${e.topic}`,{error:t}),new r(`Failed to publish batch to topic ${e.topic}: ${n.message||`Unknown error`}`)}}async disconnect(){if(this.isDisconnected){this.logger.debug(`Kafka: Producer already disconnected`);return}this.logger.info(`Kafka: Disconnecting producer`);try{await this.producer.close(),this.isDisconnected=!0,this.logger.info(`Kafka: Producer disconnected successfully`)}catch(e){throw this.logger.error(`Kafka: Error disconnecting producer`,{error:e}),new r(`Failed to disconnect producer: ${e.message}`)}}},s=o;exports.KafkaError=r,exports.default=s;
+//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs","names":["fallbackLogger: LoggerInstanceManager","fallbackLogger","Producer","stringSerializers","headers: Record<string, string>"],"sources":["../src/logger.ts","../src/kafkaError.ts","../src/consts.ts","../src/index.ts"],"sourcesContent":["import type { LoggerInstanceManager } from '@autofleet/logger';\n\n/* eslint-disable no-console */\nconst fallbackLogger: LoggerInstanceManager = {\n  info: (...args: unknown[]) => console.log('[INFO]', ...args),\n  error: (...args: unknown[]) => console.error('[ERROR]', ...args),\n  warn: (...args: unknown[]) => console.warn('[WARN]', ...args),\n  debug: (...args: unknown[]) => console.debug('[DEBUG]', ...args),\n} as LoggerInstanceManager;\n/* eslint-enable no-console */\n\nexport default fallbackLogger;\n","export default class KafkaError extends Error {\n  constructor(message: string) {\n    super(message);\n    this.name = 'KafkaError';\n  }\n}\n","export const TIMESTAMP_HEADER = 'x-timestamp';\nexport const CORRELATION_ID_HEADER = 'x-correlation-id';\nexport const SOURCE_HEADER = 'x-source';\n\nexport const DEFAULT_CLIENT_ID = 'autofleet-kafka-producer';\nexport const DEFAULT_TIMEOUT = 30000; // 30 seconds\nexport const DEFAULT_RETRY = {\n  retries: 5,\n  initialRetryTime: 300,\n  maxRetryTime: 30000,\n};\n","import { Producer, type ProduceResult, stringSerializers } from '@platformatic/kafka';\nimport type { LoggerInstanceManager } from '@autofleet/logger';\nimport fallbackLogger from './logger';\nimport KafkaError from './kafkaError';\nimport {\n  DEFAULT_CLIENT_ID,\n  TIMESTAMP_HEADER,\n} from './consts';\nimport type {\n  KafkaOptions,\n  PublishOptions,\n  PublishBatchOptions,\n  RecordMetadata,\n} from './types';\n\nexport interface IAfKafka {\n  ping(): Promise<void>;\n  publish<T = unknown>(topic: string, value: T, options?: PublishOptions): Promise<ProduceResult[]>;\n  publishBatch(options: PublishBatchOptions): Promise<ProduceResult[]>;\n  disconnect(): Promise<void>;\n}\n\nclass AfKafka implements IAfKafka {\n  private readonly producer: Producer<string, string, string, string>;\n  private readonly logger: LoggerInstanceManager;\n  private isDisconnected = false;\n  private isVerified = false;\n  private gracefulShutdownStarted = false;\n\n  constructor(options: KafkaOptions) {\n    if (!options.brokers || options.brokers.length === 0) {\n      throw new KafkaError('At least one broker is required');\n    }\n\n    this.logger = options.logger ?? fallbackLogger;\n\n    this.producer = new Producer({\n      bootstrapBrokers: options.brokers,\n      clientId: options.clientId || DEFAULT_CLIENT_ID,\n      serializers: stringSerializers,\n    });\n\n    this.logger.info('Kafka: Initializing Kafka producer', {\n      clientId: options.clientId || DEFAULT_CLIENT_ID,\n      brokers: options.brokers,\n    });\n\n    if (!options.dontGracefulShutdown) {\n      this.setupGracefulShutdown();\n    }\n  }\n\n  private setupGracefulShutdown(): void {\n    this.logger.info(`Kafka: [graceful-shutdown] adding graceful shutdown for process.pid ${process.pid}`);\n\n    process.on('SIGTERM', async () => {\n      await this.gracefulShutdown('SIGTERM');\n    });\n\n    process.on('SIGINT', async () => {\n      await this.gracefulShutdown('SIGINT');\n    });\n  }\n\n  private async gracefulShutdown(signal: string): Promise<void> {\n    if (this.gracefulShutdownStarted) {\n      return;\n    }\n\n    this.gracefulShutdownStarted = true;\n\n    this.logger.info(`Kafka: [graceful-shutdown] received ${signal}! Disconnecting producer...`);\n\n    try {\n      await this.disconnect();\n      this.logger.info('Kafka: [graceful-shutdown] producer disconnected successfully');\n    } catch (error) {\n      this.logger.error('Kafka: [graceful-shutdown] error during shutdown', { error });\n      throw error;\n    }\n  }\n\n  get isConnected(): boolean {\n    return this.producer.isConnected();\n  }\n\n  /**\n   * Ping Kafka brokers to verify connectivity\n   */\n  async ping(): Promise<void> {\n    if (this.isVerified) {\n      return;\n    }\n\n    try {\n      // Fetch metadata to verify connection\n      const metadata = await this.producer.metadata({ topics: [] });\n      this.isVerified = true;\n\n      this.logger.info('Kafka: Successfully connected to cluster', {\n        clusterId: metadata.id,\n        brokers: metadata.brokers.size,\n      });\n    } catch (error) {\n      this.logger.error('Kafka: Failed to connect to brokers', { error });\n      throw new KafkaError(`Failed to connect to Kafka brokers: ${(error as Error).message}`);\n    }\n  }\n\n  /**\n   * Publish a single message to a topic\n   */\n  async publish<T = unknown>(\n    topic: string,\n    value: T,\n    options?: PublishOptions,\n  ): Promise<ProduceResult[]> {\n    if (!topic) {\n      throw new KafkaError('Topic name is required');\n    }\n\n    // Verify connection on first publish\n    await this.ping();\n\n    try {\n      const headers: Record<string, string> = {\n        [TIMESTAMP_HEADER]: Date.now().toString(),\n        ...options?.headers,\n      };\n\n      const res = await this.producer.send({\n        messages: [{\n          topic,\n          value: JSON.stringify(value),\n          key: options?.key,\n          partition: options?.partition,\n          headers,\n        }],\n      });\n\n      this.logger.debug(`Kafka: Published message to topic ${topic}`, {\n        topic,\n      });\n\n      return [res];\n    } catch (error) {\n      const err = error as { message?: string; };\n      this.logger.error(`Kafka: Error publishing to topic ${topic}`, { error, value });\n      throw new KafkaError(`Failed to publish to topic ${topic}: ${err.message || 'Unknown error'}`);\n    }\n  }\n\n  /**\n   * Publish multiple messages in a batch\n   */\n  async publishBatch(options: PublishBatchOptions): Promise<ProduceResult[]> {\n    if (!options.topic) {\n      throw new KafkaError('Topic name is required');\n    }\n\n    if (!options.messages || options.messages.length === 0) {\n      throw new KafkaError('At least one message is required');\n    }\n\n    // Verify connection on first publish\n    await this.ping();\n\n    try {\n      const messages = options.messages.map(msg => ({\n        topic: options.topic,\n        value: JSON.stringify(msg.value),\n        key: msg.key,\n        partition: msg.partition,\n        headers: {\n          [TIMESTAMP_HEADER]: Date.now().toString(),\n          ...msg.headers,\n        },\n      }));\n\n      const res = await this.producer.send({ messages });\n\n      this.logger.debug(`Kafka: Published ${messages.length} messages to topic ${options.topic}`, {\n        topic: options.topic,\n        count: messages.length,\n      });\n\n      // Return mock metadata since @platformatic/kafka send() returns void\n      return [res];\n    } catch (error) {\n      const err = error as { message?: string; };\n      this.logger.error(`Kafka: Error publishing batch to topic ${options.topic}`, { error });\n      throw new KafkaError(`Failed to publish batch to topic ${options.topic}: ${err.message || 'Unknown error'}`);\n    }\n  }\n\n  /**\n   * Disconnect the producer and clean up resources\n   */\n  async disconnect(): Promise<void> {\n    if (this.isDisconnected) {\n      this.logger.debug('Kafka: Producer already disconnected');\n      return;\n    }\n\n    this.logger.info('Kafka: Disconnecting producer');\n\n    try {\n      await this.producer.close();\n      this.isDisconnected = true;\n      this.logger.info('Kafka: Producer disconnected successfully');\n    } catch (error) {\n      this.logger.error('Kafka: Error disconnecting producer', { error });\n      throw new KafkaError(`Failed to disconnect producer: ${(error as Error).message}`);\n    }\n  }\n}\n\nexport default AfKafka;\nexport { KafkaError };\nexport type {\n  KafkaOptions,\n  PublishOptions,\n  PublishBatchOptions,\n  RecordMetadata,\n};\n"],"mappings":"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"}

package/dist/index.d.cts

@@ -0,0 +1,84 @@
+import { ProduceResult } from "@platformatic/kafka";
+import { LoggerInstanceManager } from "@autofleet/logger";
+
+//#region src/kafkaError.d.ts
+declare class KafkaError extends Error {
+  constructor(message: string);
+}
+//#endregion
+//#region src/types.d.ts
+interface KafkaOptions {
+  /** Kafka broker addresses */
+  brokers: string[];
+  /** Client ID for this producer */
+  clientId?: string;
+  /** Custom logger instance */
+  logger?: LoggerInstanceManager;
+  /**
+  * When you want your own graceful shutdown, set this to true.
+  * @default false
+  */
+  dontGracefulShutdown?: boolean;
+}
+interface PublishOptions {
+  /** Custom headers to attach to the message */
+  headers?: Record<string, string>;
+  /** Message key for partitioning */
+  key?: string;
+  /** Specific partition to send to */
+  partition?: number;
+}
+interface PublishBatchOptions {
+  /** Topic to publish to */
+  topic: string;
+  /** Messages to publish */
+  messages: {
+    value: unknown;
+    key?: string;
+    headers?: Record<string, string>;
+    partition?: number;
+  }[];
+}
+interface RecordMetadata {
+  topic: string;
+  partition: number;
+  offset: string;
+}
+//#endregion
+//#region src/index.d.ts
+interface IAfKafka {
+  ping(): Promise<void>;
+  publish<T = unknown>(topic: string, value: T, options?: PublishOptions): Promise<ProduceResult[]>;
+  publishBatch(options: PublishBatchOptions): Promise<ProduceResult[]>;
+  disconnect(): Promise<void>;
+}
+declare class AfKafka implements IAfKafka {
+  private readonly producer;
+  private readonly logger;
+  private isDisconnected;
+  private isVerified;
+  private gracefulShutdownStarted;
+  constructor(options: KafkaOptions);
+  private setupGracefulShutdown;
+  private gracefulShutdown;
+  get isConnected(): boolean;
+  /**
+  * Ping Kafka brokers to verify connectivity
+  */
+  ping(): Promise<void>;
+  /**
+  * Publish a single message to a topic
+  */
+  publish<T = unknown>(topic: string, value: T, options?: PublishOptions): Promise<ProduceResult[]>;
+  /**
+  * Publish multiple messages in a batch
+  */
+  publishBatch(options: PublishBatchOptions): Promise<ProduceResult[]>;
+  /**
+  * Disconnect the producer and clean up resources
+  */
+  disconnect(): Promise<void>;
+}
+//#endregion
+export { IAfKafka, KafkaError, type KafkaOptions, type PublishBatchOptions, type PublishOptions, type RecordMetadata, AfKafka as default };
+//# sourceMappingURL=index.d.cts.map

package/dist/index.d.ts

@@ -0,0 +1,84 @@
+import { ProduceResult } from "@platformatic/kafka";
+import { LoggerInstanceManager } from "@autofleet/logger";
+
+//#region src/kafkaError.d.ts
+declare class KafkaError extends Error {
+  constructor(message: string);
+}
+//#endregion
+//#region src/types.d.ts
+interface KafkaOptions {
+  /** Kafka broker addresses */
+  brokers: string[];
+  /** Client ID for this producer */
+  clientId?: string;
+  /** Custom logger instance */
+  logger?: LoggerInstanceManager;
+  /**
+  * When you want your own graceful shutdown, set this to true.
+  * @default false
+  */
+  dontGracefulShutdown?: boolean;
+}
+interface PublishOptions {
+  /** Custom headers to attach to the message */
+  headers?: Record<string, string>;
+  /** Message key for partitioning */
+  key?: string;
+  /** Specific partition to send to */
+  partition?: number;
+}
+interface PublishBatchOptions {
+  /** Topic to publish to */
+  topic: string;
+  /** Messages to publish */
+  messages: {
+    value: unknown;
+    key?: string;
+    headers?: Record<string, string>;
+    partition?: number;
+  }[];
+}
+interface RecordMetadata {
+  topic: string;
+  partition: number;
+  offset: string;
+}
+//#endregion
+//#region src/index.d.ts
+interface IAfKafka {
+  ping(): Promise<void>;
+  publish<T = unknown>(topic: string, value: T, options?: PublishOptions): Promise<ProduceResult[]>;
+  publishBatch(options: PublishBatchOptions): Promise<ProduceResult[]>;
+  disconnect(): Promise<void>;
+}
+declare class AfKafka implements IAfKafka {
+  private readonly producer;
+  private readonly logger;
+  private isDisconnected;
+  private isVerified;
+  private gracefulShutdownStarted;
+  constructor(options: KafkaOptions);
+  private setupGracefulShutdown;
+  private gracefulShutdown;
+  get isConnected(): boolean;
+  /**
+  * Ping Kafka brokers to verify connectivity
+  */
+  ping(): Promise<void>;
+  /**
+  * Publish a single message to a topic
+  */
+  publish<T = unknown>(topic: string, value: T, options?: PublishOptions): Promise<ProduceResult[]>;
+  /**
+  * Publish multiple messages in a batch
+  */
+  publishBatch(options: PublishBatchOptions): Promise<ProduceResult[]>;
+  /**
+  * Disconnect the producer and clean up resources
+  */
+  disconnect(): Promise<void>;
+}
+//#endregion
+export { IAfKafka, KafkaError, type KafkaOptions, type PublishBatchOptions, type PublishOptions, type RecordMetadata, AfKafka as default };
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,2 @@
+import{Producer as e,stringSerializers as t}from"@platformatic/kafka";var n={info:(...e)=>console.log(`[INFO]`,...e),error:(...e)=>console.error(`[ERROR]`,...e),warn:(...e)=>console.warn(`[WARN]`,...e),debug:(...e)=>console.debug(`[DEBUG]`,...e)},r=class extends Error{constructor(e){super(e),this.name=`KafkaError`}};const i=`x-timestamp`,a=`autofleet-kafka-producer`;var o=class{constructor(i){if(this.isDisconnected=!1,this.isVerified=!1,this.gracefulShutdownStarted=!1,!i.brokers||i.brokers.length===0)throw new r(`At least one broker is required`);this.logger=i.logger??n,this.producer=new e({bootstrapBrokers:i.brokers,clientId:i.clientId||a,serializers:t}),this.logger.info(`Kafka: Initializing Kafka producer`,{clientId:i.clientId||a,brokers:i.brokers}),i.dontGracefulShutdown||this.setupGracefulShutdown()}setupGracefulShutdown(){this.logger.info(`Kafka: [graceful-shutdown] adding graceful shutdown for process.pid ${process.pid}`),process.on(`SIGTERM`,async()=>{await this.gracefulShutdown(`SIGTERM`)}),process.on(`SIGINT`,async()=>{await this.gracefulShutdown(`SIGINT`)})}async gracefulShutdown(e){if(!this.gracefulShutdownStarted){this.gracefulShutdownStarted=!0,this.logger.info(`Kafka: [graceful-shutdown] received ${e}! Disconnecting producer...`);try{await this.disconnect(),this.logger.info(`Kafka: [graceful-shutdown] producer disconnected successfully`)}catch(e){throw this.logger.error(`Kafka: [graceful-shutdown] error during shutdown`,{error:e}),e}}}get isConnected(){return this.producer.isConnected()}async ping(){if(!this.isVerified)try{let e=await this.producer.metadata({topics:[]});this.isVerified=!0,this.logger.info(`Kafka: Successfully connected to cluster`,{clusterId:e.id,brokers:e.brokers.size})}catch(e){throw this.logger.error(`Kafka: Failed to connect to brokers`,{error:e}),new r(`Failed to connect to Kafka brokers: ${e.message}`)}}async publish(e,t,n){if(!e)throw new r(`Topic name is required`);await this.ping();try{let r={[i]:Date.now().toString(),...n?.headers},a=await this.producer.send({messages:[{topic:e,value:JSON.stringify(t),key:n?.key,partition:n?.partition,headers:r}]});return this.logger.debug(`Kafka: Published message to topic ${e}`,{topic:e}),[a]}catch(n){let i=n;throw this.logger.error(`Kafka: Error publishing to topic ${e}`,{error:n,value:t}),new r(`Failed to publish to topic ${e}: ${i.message||`Unknown error`}`)}}async publishBatch(e){if(!e.topic)throw new r(`Topic name is required`);if(!e.messages||e.messages.length===0)throw new r(`At least one message is required`);await this.ping();try{let t=e.messages.map(t=>({topic:e.topic,value:JSON.stringify(t.value),key:t.key,partition:t.partition,headers:{[i]:Date.now().toString(),...t.headers}})),n=await this.producer.send({messages:t});return this.logger.debug(`Kafka: Published ${t.length} messages to topic ${e.topic}`,{topic:e.topic,count:t.length}),[n]}catch(t){let n=t;throw this.logger.error(`Kafka: Error publishing batch to topic ${e.topic}`,{error:t}),new r(`Failed to publish batch to topic ${e.topic}: ${n.message||`Unknown error`}`)}}async disconnect(){if(this.isDisconnected){this.logger.debug(`Kafka: Producer already disconnected`);return}this.logger.info(`Kafka: Disconnecting producer`);try{await this.producer.close(),this.isDisconnected=!0,this.logger.info(`Kafka: Producer disconnected successfully`)}catch(e){throw this.logger.error(`Kafka: Error disconnecting producer`,{error:e}),new r(`Failed to disconnect producer: ${e.message}`)}}};export{r as KafkaError,o as default};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":["fallbackLogger: LoggerInstanceManager","fallbackLogger","headers: Record<string, string>"],"sources":["../src/logger.ts","../src/kafkaError.ts","../src/consts.ts","../src/index.ts"],"sourcesContent":["import type { LoggerInstanceManager } from '@autofleet/logger';\n\n/* eslint-disable no-console */\nconst fallbackLogger: LoggerInstanceManager = {\n  info: (...args: unknown[]) => console.log('[INFO]', ...args),\n  error: (...args: unknown[]) => console.error('[ERROR]', ...args),\n  warn: (...args: unknown[]) => console.warn('[WARN]', ...args),\n  debug: (...args: unknown[]) => console.debug('[DEBUG]', ...args),\n} as LoggerInstanceManager;\n/* eslint-enable no-console */\n\nexport default fallbackLogger;\n","export default class KafkaError extends Error {\n  constructor(message: string) {\n    super(message);\n    this.name = 'KafkaError';\n  }\n}\n","export const TIMESTAMP_HEADER = 'x-timestamp';\nexport const CORRELATION_ID_HEADER = 'x-correlation-id';\nexport const SOURCE_HEADER = 'x-source';\n\nexport const DEFAULT_CLIENT_ID = 'autofleet-kafka-producer';\nexport const DEFAULT_TIMEOUT = 30000; // 30 seconds\nexport const DEFAULT_RETRY = {\n  retries: 5,\n  initialRetryTime: 300,\n  maxRetryTime: 30000,\n};\n","import { Producer, type ProduceResult, stringSerializers } from '@platformatic/kafka';\nimport type { LoggerInstanceManager } from '@autofleet/logger';\nimport fallbackLogger from './logger';\nimport KafkaError from './kafkaError';\nimport {\n  DEFAULT_CLIENT_ID,\n  TIMESTAMP_HEADER,\n} from './consts';\nimport type {\n  KafkaOptions,\n  PublishOptions,\n  PublishBatchOptions,\n  RecordMetadata,\n} from './types';\n\nexport interface IAfKafka {\n  ping(): Promise<void>;\n  publish<T = unknown>(topic: string, value: T, options?: PublishOptions): Promise<ProduceResult[]>;\n  publishBatch(options: PublishBatchOptions): Promise<ProduceResult[]>;\n  disconnect(): Promise<void>;\n}\n\nclass AfKafka implements IAfKafka {\n  private readonly producer: Producer<string, string, string, string>;\n  private readonly logger: LoggerInstanceManager;\n  private isDisconnected = false;\n  private isVerified = false;\n  private gracefulShutdownStarted = false;\n\n  constructor(options: KafkaOptions) {\n    if (!options.brokers || options.brokers.length === 0) {\n      throw new KafkaError('At least one broker is required');\n    }\n\n    this.logger = options.logger ?? fallbackLogger;\n\n    this.producer = new Producer({\n      bootstrapBrokers: options.brokers,\n      clientId: options.clientId || DEFAULT_CLIENT_ID,\n      serializers: stringSerializers,\n    });\n\n    this.logger.info('Kafka: Initializing Kafka producer', {\n      clientId: options.clientId || DEFAULT_CLIENT_ID,\n      brokers: options.brokers,\n    });\n\n    if (!options.dontGracefulShutdown) {\n      this.setupGracefulShutdown();\n    }\n  }\n\n  private setupGracefulShutdown(): void {\n    this.logger.info(`Kafka: [graceful-shutdown] adding graceful shutdown for process.pid ${process.pid}`);\n\n    process.on('SIGTERM', async () => {\n      await this.gracefulShutdown('SIGTERM');\n    });\n\n    process.on('SIGINT', async () => {\n      await this.gracefulShutdown('SIGINT');\n    });\n  }\n\n  private async gracefulShutdown(signal: string): Promise<void> {\n    if (this.gracefulShutdownStarted) {\n      return;\n    }\n\n    this.gracefulShutdownStarted = true;\n\n    this.logger.info(`Kafka: [graceful-shutdown] received ${signal}! Disconnecting producer...`);\n\n    try {\n      await this.disconnect();\n      this.logger.info('Kafka: [graceful-shutdown] producer disconnected successfully');\n    } catch (error) {\n      this.logger.error('Kafka: [graceful-shutdown] error during shutdown', { error });\n      throw error;\n    }\n  }\n\n  get isConnected(): boolean {\n    return this.producer.isConnected();\n  }\n\n  /**\n   * Ping Kafka brokers to verify connectivity\n   */\n  async ping(): Promise<void> {\n    if (this.isVerified) {\n      return;\n    }\n\n    try {\n      // Fetch metadata to verify connection\n      const metadata = await this.producer.metadata({ topics: [] });\n      this.isVerified = true;\n\n      this.logger.info('Kafka: Successfully connected to cluster', {\n        clusterId: metadata.id,\n        brokers: metadata.brokers.size,\n      });\n    } catch (error) {\n      this.logger.error('Kafka: Failed to connect to brokers', { error });\n      throw new KafkaError(`Failed to connect to Kafka brokers: ${(error as Error).message}`);\n    }\n  }\n\n  /**\n   * Publish a single message to a topic\n   */\n  async publish<T = unknown>(\n    topic: string,\n    value: T,\n    options?: PublishOptions,\n  ): Promise<ProduceResult[]> {\n    if (!topic) {\n      throw new KafkaError('Topic name is required');\n    }\n\n    // Verify connection on first publish\n    await this.ping();\n\n    try {\n      const headers: Record<string, string> = {\n        [TIMESTAMP_HEADER]: Date.now().toString(),\n        ...options?.headers,\n      };\n\n      const res = await this.producer.send({\n        messages: [{\n          topic,\n          value: JSON.stringify(value),\n          key: options?.key,\n          partition: options?.partition,\n          headers,\n        }],\n      });\n\n      this.logger.debug(`Kafka: Published message to topic ${topic}`, {\n        topic,\n      });\n\n      return [res];\n    } catch (error) {\n      const err = error as { message?: string; };\n      this.logger.error(`Kafka: Error publishing to topic ${topic}`, { error, value });\n      throw new KafkaError(`Failed to publish to topic ${topic}: ${err.message || 'Unknown error'}`);\n    }\n  }\n\n  /**\n   * Publish multiple messages in a batch\n   */\n  async publishBatch(options: PublishBatchOptions): Promise<ProduceResult[]> {\n    if (!options.topic) {\n      throw new KafkaError('Topic name is required');\n    }\n\n    if (!options.messages || options.messages.length === 0) {\n      throw new KafkaError('At least one message is required');\n    }\n\n    // Verify connection on first publish\n    await this.ping();\n\n    try {\n      const messages = options.messages.map(msg => ({\n        topic: options.topic,\n        value: JSON.stringify(msg.value),\n        key: msg.key,\n        partition: msg.partition,\n        headers: {\n          [TIMESTAMP_HEADER]: Date.now().toString(),\n          ...msg.headers,\n        },\n      }));\n\n      const res = await this.producer.send({ messages });\n\n      this.logger.debug(`Kafka: Published ${messages.length} messages to topic ${options.topic}`, {\n        topic: options.topic,\n        count: messages.length,\n      });\n\n      // Return mock metadata since @platformatic/kafka send() returns void\n      return [res];\n    } catch (error) {\n      const err = error as { message?: string; };\n      this.logger.error(`Kafka: Error publishing batch to topic ${options.topic}`, { error });\n      throw new KafkaError(`Failed to publish batch to topic ${options.topic}: ${err.message || 'Unknown error'}`);\n    }\n  }\n\n  /**\n   * Disconnect the producer and clean up resources\n   */\n  async disconnect(): Promise<void> {\n    if (this.isDisconnected) {\n      this.logger.debug('Kafka: Producer already disconnected');\n      return;\n    }\n\n    this.logger.info('Kafka: Disconnecting producer');\n\n    try {\n      await this.producer.close();\n      this.isDisconnected = true;\n      this.logger.info('Kafka: Producer disconnected successfully');\n    } catch (error) {\n      this.logger.error('Kafka: Error disconnecting producer', { error });\n      throw new KafkaError(`Failed to disconnect producer: ${(error as Error).message}`);\n    }\n  }\n}\n\nexport default AfKafka;\nexport { KafkaError };\nexport type {\n  KafkaOptions,\n  PublishOptions,\n  PublishBatchOptions,\n  RecordMetadata,\n};\n"],"mappings":"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"}

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "@autofleet/kafka",
+  "version": "0.0.1",
+  "description": "Internal wrapper for Apache Kafka producer",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      }
+    }
+  },
+  "files": [
+    "dist/"
+  ],
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "test": "vitest",
+    "coverage": "vitest --coverage"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Autofleet/autorepo.git"
+  },
+  "bugs": {
+    "url": "https://github.com/Autofleet/autorepo/issues"
+  },
+  "homepage": "https://github.com/Autofleet/autorepo/tree/master/packages/kafka#readme",
+  "dependencies": {
+    "@platformatic/kafka": "^1.21.0"
+  },
+  "peerDependencies": {
+    "@autofleet/logger": "*"
+  },
+  "devDependencies": {
+    "@autofleet/logger": "workspace:^",
+    "@types/node": "^20.14.11"
+  },
+  "keywords": ["kafka", "producer", "messaging"],
+  "author": "",
+  "license": "Proprietary",
+  "packageManager": "pnpm@10.24.0"
+}