kafka-ts 0.0.1-beta → 0.0.1-beta.1

package/src/{request-handler.test.ts → cluster.test.ts}

@@ -1,21 +1,22 @@
-import { randomBytes } from "crypto";
-import { readFileSync } from "fs";
-import { afterAll, beforeAll, describe, expect, it } from "vitest";
-import { API } from "./api";
-import { KEY_TYPE } from "./api/find-coordinator";
-import { createKafkaClient } from "./client";
-import { Cluster } from "./cluster";
-import { KafkaTSApiError } from "./utils/error";
+import { randomBytes } from 'crypto';
+import { readFileSync } from 'fs';
+import { afterAll, beforeAll, describe, expect, it } from 'vitest';
+import { API } from './api';
+import { KEY_TYPE } from './api/find-coordinator';
+import { saslPlain } from './auth';
+import { createKafkaClient } from './client';
+import { Cluster } from './cluster';
+import { KafkaTSApiError } from './utils/error';
 
 export const kafka = createKafkaClient({
-    clientId: "kafkats",
-    bootstrapServers: [{ host: "localhost", port: 9092 }],
-    sasl: { mechanism: "PLAIN", username: "admin", password: "admin" },
-    ssl: { ca: readFileSync("./certs/ca.crt").toString() },
+    clientId: 'kafka-ts',
+    bootstrapServers: [{ host: 'localhost', port: 9092 }],
+    sasl: saslPlain({ username: 'admin', password: 'admin' }),
+    ssl: { ca: readFileSync('./certs/ca.crt').toString() },
 });
 
-describe.sequential("Request handler", () => {
-    const groupId = randomBytes(16).toString("hex");
+describe.sequential('Request handler', () => {
+    const groupId = randomBytes(16).toString('hex');
 
     let cluster: Cluster;
 
@@ -27,9 +28,9 @@ describe.sequential("Request handler", () => {
             allowTopicAutoCreation: false,
             includeTopicAuthorizedOperations: false,
         });
-        if (metadataResult.topics.some((topic) => topic.name === "kafkats-test-topic")) {
+        if (metadataResult.topics.some((topic) => topic.name === 'kafka-ts-test-topic')) {
             await cluster.sendRequest(API.DELETE_TOPICS, {
-                topics: [{ name: "kafkats-test-topic", topicId: null }],
+                topics: [{ name: 'kafka-ts-test-topic', topicId: null }],
                 timeoutMs: 10000,
             });
         }
@@ -39,18 +40,18 @@ describe.sequential("Request handler", () => {
         await cluster.disconnect();
     });
 
-    it("should request api versions", async () => {
+    it('should request api versions', async () => {
         const result = await cluster.sendRequest(API.API_VERSIONS, {});
         expect(result).toMatchSnapshot();
     });
 
-    let topicId: string = "d6718d178e1b47c886441ad2d19faea5";
+    let topicId: string = 'd6718d178e1b47c886441ad2d19faea5';
 
-    it("should create topics", async () => {
+    it('should create topics', async () => {
         const result = await cluster.sendRequest(API.CREATE_TOPICS, {
             topics: [
                 {
-                    name: "kafkats-test-topic",
+                    name: 'kafka-ts-test-topic',
                     numPartitions: 1,
                     replicationFactor: 1,
                     assignments: [],
@@ -62,22 +63,23 @@ describe.sequential("Request handler", () => {
         });
         topicId = result.topics[0].topicId;
         result.topics.forEach((topic) => {
-            topic.topicId = "Any<UUID>";
+            topic.topicId = 'Any<UUID>';
         });
         expect(result).toMatchSnapshot();
 
         await new Promise((resolve) => setTimeout(resolve, 1000));
     });
 
-    it("should request metadata for all topics", async () => {
+    it('should request metadata for all topics', async () => {
         const result = await cluster.sendRequest(API.METADATA, {
             topics: null,
             allowTopicAutoCreation: false,
             includeTopicAuthorizedOperations: false,
         });
         result.controllerId = 0;
+        result.topics = result.topics.filter((topic) => topic.name !== '__consumer_offsets');
         result.topics.forEach((topic) => {
-            topic.topicId = "Any<UUID>";
+            topic.topicId = 'Any<UUID>';
             topic.partitions.forEach((partition) => {
                 partition.leaderId = 0;
                 partition.isrNodes = [0];
@@ -89,16 +91,16 @@ describe.sequential("Request handler", () => {
 
     let leaderId = 0;
 
-    it("should request metadata for a topic", async () => {
+    it('should request metadata for a topic', async () => {
         const result = await cluster.sendRequest(API.METADATA, {
-            topics: [{ id: topicId, name: "kafkats-test-topic" }],
+            topics: [{ id: topicId, name: 'kafka-ts-test-topic' }],
             allowTopicAutoCreation: false,
             includeTopicAuthorizedOperations: false,
         });
         leaderId = result.topics[0].partitions[0].leaderId;
         result.controllerId = 0;
         result.topics.forEach((topic) => {
-            topic.topicId = "Any<UUID>";
+            topic.topicId = 'Any<UUID>';
             topic.partitions.forEach((partition) => {
                 partition.leaderId = 0;
                 partition.isrNodes = [0];
@@ -108,18 +110,20 @@ describe.sequential("Request handler", () => {
         expect(result).toMatchSnapshot();
     });
 
-    it("should init producer id", async () => {
+    let producerId = 9n;
+
+    it('should init producer id', async () => {
         const result = await cluster.sendRequest(API.INIT_PRODUCER_ID, {
             transactionalId: null,
             transactionTimeoutMs: 0,
-            producerId: 0n,
+            producerId,
             producerEpoch: 0,
         });
         result.producerId = 0n;
         expect(result).toMatchSnapshot();
     });
 
-    it("should produce messages", async () => {
+    it('should produce messages', async () => {
         const now = Date.now();
         const result = await cluster.sendRequestToNode(leaderId)(API.PRODUCE, {
             transactionalId: null,
@@ -127,7 +131,7 @@ describe.sequential("Request handler", () => {
             acks: 1,
             topicData: [
                 {
-                    name: "kafkats-test-topic",
+                    name: 'kafka-ts-test-topic',
                     partitionData: [
                         {
                             index: 0,
@@ -139,18 +143,18 @@ describe.sequential("Request handler", () => {
                             lastOffsetDelta: 0,
                             maxTimestamp: BigInt(now),
                             producerEpoch: 0,
-                            producerId: 9n,
+                            producerId,
                             records: [
                                 {
                                     attributes: 0,
                                     offsetDelta: 0,
                                     timestampDelta: 0n,
-                                    key: "key",
-                                    value: "value",
+                                    key: 'key',
+                                    value: 'value',
                                     headers: [
                                         {
-                                            key: "header-key",
-                                            value: "header-value",
+                                            key: 'header-key',
+                                            value: 'header-value',
                                         },
                                     ],
                                 },
@@ -163,7 +167,7 @@ describe.sequential("Request handler", () => {
         expect(result).toMatchSnapshot();
     });
 
-    it("should fetch messages", async () => {
+    it('should fetch messages', async () => {
         const result = await cluster.sendRequestToNode(leaderId)(API.FETCH, {
             maxWaitMs: 100,
             minBytes: 1,
@@ -187,10 +191,10 @@ describe.sequential("Request handler", () => {
                 },
             ],
             forgottenTopicsData: [],
-            rackId: "",
+            rackId: '',
         });
         result.responses.forEach((response) => {
-            response.topicId = "Any<UUID>";
+            response.topicId = 'Any<UUID>';
             response.partitions.forEach((partition) => {
                 partition.records.forEach((record) => {
                     expect(record.baseTimestamp).toBeGreaterThan(1721926744730n);
@@ -208,10 +212,10 @@ describe.sequential("Request handler", () => {
 
     let coordinatorId = -1;
 
-    it("should find coordinator", async () => {
+    it('should find coordinator', async () => {
         const result = await cluster.sendRequest(API.FIND_COORDINATOR, { keyType: KEY_TYPE.GROUP, keys: [groupId] });
         result.coordinators.forEach((coordinator) => {
-            coordinator.key = "Any<String>";
+            coordinator.key = 'Any<String>';
         });
         coordinatorId = result.coordinators[0].nodeId;
         result.coordinators.forEach((coordinator) => {
@@ -221,9 +225,9 @@ describe.sequential("Request handler", () => {
         expect(result).toMatchSnapshot();
     });
 
-    let memberId = "";
+    let memberId = '';
 
-    it("should fail join group request with new memberId", async () => {
+    it('should fail join group request with new memberId', async () => {
         try {
             const result = await cluster.sendRequestToNode(coordinatorId)(API.JOIN_GROUP, {
                 groupId,
@@ -231,67 +235,67 @@ describe.sequential("Request handler", () => {
                 rebalanceTimeoutMs: 60000,
                 memberId,
                 groupInstanceId: null,
-                protocolType: "consumer",
+                protocolType: 'consumer',
                 protocols: [
                     {
-                        name: "RoundRobinAssigner",
-                        metadata: { version: 0, topics: ["kafkats-test-topic"] },
+                        name: 'RoundRobinAssigner',
+                        metadata: { version: 0, topics: ['kafka-ts-test-topic'] },
                     },
                 ],
                 reason: null,
             });
-            expect(false, "Should throw an error").toBe(true);
+            expect(false, 'Should throw an error').toBe(true);
         } catch (error) {
             const { response } = error as KafkaTSApiError;
             memberId = response.memberId;
-            response.memberId = "Any<UUID>";
+            response.memberId = 'Any<UUID>';
             expect(response).toMatchSnapshot();
         }
     });
 
-    it("should join group", async () => {
+    it('should join group', async () => {
         const result = await cluster.sendRequestToNode(coordinatorId)(API.JOIN_GROUP, {
             groupId,
             sessionTimeoutMs: 30000,
             rebalanceTimeoutMs: 60000,
             memberId,
             groupInstanceId: null,
-            protocolType: "consumer",
+            protocolType: 'consumer',
             protocols: [
                 {
-                    name: "RoundRobinAssigner",
-                    metadata: { version: 0, topics: ["kafkats-test-topic"] },
+                    name: 'RoundRobinAssigner',
+                    metadata: { version: 0, topics: ['kafka-ts-test-topic'] },
                 },
             ],
             reason: null,
         });
-        result.memberId = "Any<UUID>";
-        result.leader = "Any<UUID>";
+        result.memberId = 'Any<UUID>';
+        result.leader = 'Any<UUID>';
         result.members.forEach((member) => {
-            member.memberId = "Any<UUID>";
+            member.memberId = 'Any<UUID>';
         });
         expect(result).toMatchSnapshot();
     });
 
-    it("should sync group", async () => {
+    it('should sync group', async () => {
         const result = await cluster.sendRequestToNode(coordinatorId)(API.SYNC_GROUP, {
             groupId,
             generationId: 1,
             memberId,
             groupInstanceId: null,
-            protocolType: "consumer",
-            protocolName: "RoundRobinAssigner",
+            protocolType: 'consumer',
+            protocolName: 'RoundRobinAssigner',
             assignments: [
                 {
                     memberId,
-                    assignment: { "kafka-test-topic": [0] },
+                    assignment: { 'kafka-test-topic': [0] },
                 },
             ],
         });
         expect(result).toMatchSnapshot();
     });
 
-    it("should commit offsets", async () => {
+    it('should commit offsets', async () => {
         const result = await cluster.sendRequestToNode(coordinatorId)(API.OFFSET_COMMIT, {
             groupId,
             generationIdOrMemberEpoch: 1,
@@ -299,7 +303,7 @@ describe.sequential("Request handler", () => {
             groupInstanceId: null,
             topics: [
                 {
-                    name: "kafkats-test-topic",
+                    name: 'kafka-ts-test-topic',
                     partitions: [
                         { partitionIndex: 0, committedOffset: 1n, committedLeaderEpoch: 0, committedMetadata: null },
                     ],
@@ -309,7 +313,7 @@ describe.sequential("Request handler", () => {
         expect(result).toMatchSnapshot();
     });
 
-    it("should fetch offsets", async () => {
+    it('should fetch offsets', async () => {
         const result = await cluster.sendRequestToNode(coordinatorId)(API.OFFSET_FETCH, {
             groups: [
                 {
@@ -318,7 +322,7 @@ describe.sequential("Request handler", () => {
                     memberEpoch: 0,
                     topics: [
                         {
-                            name: "kafkats-test-topic",
+                            name: 'kafka-ts-test-topic',
                             partitionIndexes: [0],
                         },
                     ],
@@ -327,12 +331,12 @@ describe.sequential("Request handler", () => {
             requireStable: false,
         });
         result.groups.forEach((group) => {
-            group.groupId = "Any<String>";
+            group.groupId = 'Any<String>';
         });
         expect(result).toMatchSnapshot();
     });
 
-    it("should heartbeat", async () => {
+    it('should heartbeat', async () => {
         const result = await cluster.sendRequestToNode(coordinatorId)(API.HEARTBEAT, {
             groupId,
             generationId: 1,
@@ -342,24 +346,24 @@ describe.sequential("Request handler", () => {
         expect(result).toMatchSnapshot();
     });
 
-    it("should leave group", async () => {
+    it('should leave group', async () => {
         const result = await cluster.sendRequestToNode(coordinatorId)(API.LEAVE_GROUP, {
             groupId,
             members: [{ memberId, groupInstanceId: null, reason: null }],
         });
         result.members.forEach((member) => {
-            member.memberId = "Any<UUID>";
+            member.memberId = 'Any<UUID>';
         });
         expect(result).toMatchSnapshot();
     });
 
-    it("should delete topics", async () => {
+    it('should delete topics', async () => {
         const result = await cluster.sendRequest(API.DELETE_TOPICS, {
-            topics: [{ name: "kafkats-test-topic", topicId: null }],
+            topics: [{ name: 'kafka-ts-test-topic', topicId: null }],
             timeoutMs: 10000,
         });
         result.responses.forEach((response) => {
-            response.topicId = "Any<UUID>";
+            response.topicId = 'Any<UUID>';
         });
         expect(result).toMatchSnapshot();
     });

package/src/cluster.ts

@@ -1,14 +1,14 @@
-import { TcpSocketConnectOpts } from "net";
-import { TLSSocketOptions } from "tls";
-import { API } from "./api";
-import { Broker, SASLOptions } from "./broker";
-import { SendRequest } from "./connection";
-import { ConnectionError, KafkaTSError } from "./utils/error";
+import { TcpSocketConnectOpts } from 'net';
+import { TLSSocketOptions } from 'tls';
+import { API } from './api';
+import { Broker, SASLProvider } from './broker';
+import { SendRequest } from './connection';
+import { ConnectionError, KafkaTSError } from './utils/error';
 
 type ClusterOptions = {
     clientId: string | null;
     bootstrapServers: TcpSocketConnectOpts[];
-    sasl: SASLOptions | null;
+    sasl: SASLProvider | null;
     ssl: TLSSocketOptions | null;
 };
 
@@ -82,6 +82,6 @@ export class Cluster {
                 console.warn(`Failed to connect to seed broker ${options.host}:${options.port}`, error);
             }
         }
-        throw new KafkaTSError("No seed brokers found");
+        throw new KafkaTSError('No seed brokers found');
     }
 }

package/src/connection.ts

@@ -1,12 +1,14 @@
-import assert from "assert";
-import net, { isIP, Socket, TcpSocketConnectOpts } from "net";
-import tls, { TLSSocketOptions } from "tls";
-import { getApiName } from "./api";
-import { Api } from "./utils/api";
-import { Decoder } from "./utils/decoder";
-import { Encoder } from "./utils/encoder";
-import { ConnectionError } from "./utils/error";
-import { trace } from "./utils/tracer";
+import assert from 'assert';
+import net, { isIP, Socket, TcpSocketConnectOpts } from 'net';
+import tls, { TLSSocketOptions } from 'tls';
+import { getApiName } from './api';
+import { Api } from './utils/api';
+import { Decoder } from './utils/decoder';
+import { Encoder } from './utils/encoder';
+import { ConnectionError } from './utils/error';
+import { createTracer } from './utils/tracer';
+
+const trace = createTracer('Connection');
 
 export type ConnectionOptions = {
     clientId: string | null;
@@ -44,14 +46,14 @@ export class Connection {
                       resolve,
                   )
                 : net.connect(connection, resolve);
-            this.socket.once("error", reject);
+            this.socket.once('error', reject);
         });
-        this.socket.removeAllListeners("error");
+        this.socket.removeAllListeners('error');
 
-        this.socket.on("data", (data) => this.handleData(data));
-        this.socket.once("close", async () => {
+        this.socket.on('data', (data) => this.handleData(data));
+        this.socket.once('close', async () => {
             Object.values(this.queue).forEach(({ reject }) => {
-                reject(new ConnectionError("Socket closed unexpectedly"));
+                reject(new ConnectionError('Socket closed unexpectedly'));
             });
             this.queue = {};
         });
@@ -100,7 +102,7 @@ export class Connection {
 
     private write(buffer: Buffer) {
         return new Promise<void>((resolve, reject) => {
-            const { stack } = new Error("Write error");
+            const { stack } = new Error('Write error');
             this.socket.write(buffer, (error) => {
                 if (error) {
                     const err = new ConnectionError(error.message);

package/src/consumer/consumer-group.ts

@@ -1,10 +1,10 @@
-import { API, API_ERROR } from "../api";
-import { KEY_TYPE } from "../api/find-coordinator";
-import { Assignment, MemberAssignment } from "../api/sync-group";
-import { Cluster } from "../cluster";
-import { KafkaTSApiError, KafkaTSError } from "../utils/error";
-import { ConsumerMetadata } from "./consumer-metadata";
-import { OffsetManager } from "./offset-manager";
+import { API, API_ERROR } from '../api';
+import { KEY_TYPE } from '../api/find-coordinator';
+import { Assignment, MemberAssignment } from '../api/sync-group';
+import { Cluster } from '../cluster';
+import { KafkaTSApiError, KafkaTSError } from '../utils/error';
+import { ConsumerMetadata } from './consumer-metadata';
+import { OffsetManager } from './offset-manager';
 
 type ConsumerGroupOptions = {
     cluster: Cluster;
@@ -19,9 +19,9 @@ type ConsumerGroupOptions = {
 
 export class ConsumerGroup {
     private coordinatorId = -1;
-    private memberId = "";
+    private memberId = '';
     private generationId = -1;
-    private leaderId = "";
+    private leaderId = '';
     private memberIds: string[] = [];
     private heartbeatInterval: NodeJS.Timeout | null = null;
     private heartbeatError: KafkaTSError | null = null;
@@ -76,8 +76,8 @@ export class ConsumerGroup {
                 memberId: this.memberId,
                 sessionTimeoutMs,
                 rebalanceTimeoutMs,
-                protocolType: "consumer",
-                protocols: [{ name: "RoundRobinAssigner", metadata: { version: 0, topics } }],
+                protocolType: 'consumer',
+                protocols: [{ name: 'RoundRobinAssigner', metadata: { version: 0, topics } }],
                 reason: null,
             });
             this.memberId = response.memberId;
@@ -118,11 +118,11 @@ export class ConsumerGroup {
             groupInstanceId,
             memberId: this.memberId,
             generationId: this.generationId,
-            protocolType: "consumer",
-            protocolName: "RoundRobinAssigner",
+            protocolType: 'consumer',
+            protocolName: 'RoundRobinAssigner',
             assignments,
         });
-        metadata.setAssignment(JSON.parse(response.assignments || "{}") as Assignment);
+        metadata.setAssignment(JSON.parse(response.assignments || '{}') as Assignment);
     }
 
     private async offsetFetch() {

package/src/consumer/consumer-metadata.ts

@@ -1,5 +1,5 @@
-import { Assignment } from "../api/sync-group";
-import { Metadata } from "../metadata";
+import { Assignment } from '../api/sync-group';
+import { Metadata } from '../metadata';
 
 export class ConsumerMetadata extends Metadata {
     private assignment: Assignment = {};