kafka-ts 0.0.1-beta → 0.0.3-beta

package/src/api/api-versions.ts

@@ -1,5 +1,5 @@
-import { createApi } from "../utils/api.js";
-import { KafkaTSApiError } from "../utils/error.js";
+import { createApi } from '../utils/api.js';
+import { KafkaTSApiError } from '../utils/error.js';
 
 export const API_VERSIONS = createApi({
     apiKey: 18,

package/src/api/create-topics.ts

@@ -1,5 +1,5 @@
-import { createApi } from "../utils/api";
-import { KafkaTSApiError } from "../utils/error";
+import { createApi } from '../utils/api';
+import { KafkaTSApiError } from '../utils/error';
 
 export const CREATE_TOPICS = createApi({
     apiKey: 19,

package/src/api/delete-topics.ts

@@ -1,5 +1,5 @@
-import { createApi } from "../utils/api";
-import { KafkaTSApiError } from "../utils/error";
+import { createApi } from '../utils/api';
+import { KafkaTSApiError } from '../utils/error';
 
 export const DELETE_TOPICS = createApi({
     apiKey: 20,

package/src/api/fetch.ts

@@ -1,6 +1,6 @@
-import { createApi } from "../utils/api";
-import { Decoder } from "../utils/decoder";
-import { KafkaTSApiError } from "../utils/error";
+import { createApi } from '../utils/api';
+import { Decoder } from '../utils/decoder';
+import { KafkaTSApiError } from '../utils/error';
 
 export const enum IsolationLevel {
     READ_UNCOMMITTED = 0,

package/src/api/find-coordinator.ts

@@ -1,5 +1,5 @@
-import { createApi } from "../utils/api";
-import { KafkaTSApiError } from "../utils/error";
+import { createApi } from '../utils/api';
+import { KafkaTSApiError } from '../utils/error';
 
 export const KEY_TYPE = {
     GROUP: 0,

package/src/api/heartbeat.ts

@@ -1,5 +1,5 @@
-import { createApi } from "../utils/api";
-import { KafkaTSApiError } from "../utils/error";
+import { createApi } from '../utils/api';
+import { KafkaTSApiError } from '../utils/error';
 
 export const HEARTBEAT = createApi({
     apiKey: 12,

package/src/api/index.ts

@@ -1,21 +1,21 @@
-import { Api } from "../utils/api";
-import { API_VERSIONS } from "./api-versions";
-import { CREATE_TOPICS } from "./create-topics";
-import { DELETE_TOPICS } from "./delete-topics";
-import { FETCH } from "./fetch";
-import { FIND_COORDINATOR } from "./find-coordinator";
-import { HEARTBEAT } from "./heartbeat";
-import { INIT_PRODUCER_ID } from "./init-producer-id";
-import { JOIN_GROUP } from "./join-group";
-import { LEAVE_GROUP } from "./leave-group";
-import { LIST_OFFSETS } from "./list-offsets";
-import { METADATA } from "./metadata";
-import { OFFSET_COMMIT } from "./offset-commit";
-import { OFFSET_FETCH } from "./offset-fetch";
-import { PRODUCE } from "./produce";
-import { SASL_AUTHENTICATE } from "./sasl-authenticate";
-import { SASL_HANDSHAKE } from "./sasl-handshake";
-import { SYNC_GROUP } from "./sync-group";
+import { Api } from '../utils/api';
+import { API_VERSIONS } from './api-versions';
+import { CREATE_TOPICS } from './create-topics';
+import { DELETE_TOPICS } from './delete-topics';
+import { FETCH } from './fetch';
+import { FIND_COORDINATOR } from './find-coordinator';
+import { HEARTBEAT } from './heartbeat';
+import { INIT_PRODUCER_ID } from './init-producer-id';
+import { JOIN_GROUP } from './join-group';
+import { LEAVE_GROUP } from './leave-group';
+import { LIST_OFFSETS } from './list-offsets';
+import { METADATA } from './metadata';
+import { OFFSET_COMMIT } from './offset-commit';
+import { OFFSET_FETCH } from './offset-fetch';
+import { PRODUCE } from './produce';
+import { SASL_AUTHENTICATE } from './sasl-authenticate';
+import { SASL_HANDSHAKE } from './sasl-handshake';
+import { SYNC_GROUP } from './sync-group';
 
 export const API = {
     API_VERSIONS,

package/src/api/init-producer-id.ts

@@ -1,5 +1,5 @@
-import { createApi } from "../utils/api";
-import { KafkaTSApiError } from "../utils/error";
+import { createApi } from '../utils/api';
+import { KafkaTSApiError } from '../utils/error';
 
 export const INIT_PRODUCER_ID = createApi({
     apiKey: 22,

package/src/api/join-group.ts

@@ -1,6 +1,6 @@
-import { createApi } from "../utils/api";
-import { Encoder } from "../utils/encoder";
-import { KafkaTSApiError } from "../utils/error";
+import { createApi } from '../utils/api';
+import { Encoder } from '../utils/encoder';
+import { KafkaTSApiError } from '../utils/error';
 
 export const JOIN_GROUP = createApi({
     apiKey: 11,

package/src/api/leave-group.ts

@@ -1,5 +1,5 @@
-import { createApi } from "../utils/api";
-import { KafkaTSApiError } from "../utils/error";
+import { createApi } from '../utils/api';
+import { KafkaTSApiError } from '../utils/error';
 
 export const LEAVE_GROUP = createApi({
     apiKey: 13,

package/src/api/list-offsets.ts

@@ -1,6 +1,6 @@
-import { createApi } from "../utils/api";
-import { KafkaTSApiError } from "../utils/error";
-import { IsolationLevel } from "./fetch";
+import { createApi } from '../utils/api';
+import { KafkaTSApiError } from '../utils/error';
+import { IsolationLevel } from './fetch';
 
 export const LIST_OFFSETS = createApi({
     apiKey: 2,

package/src/api/metadata.ts

@@ -1,7 +1,7 @@
-import { createApi } from "../utils/api";
-import { KafkaTSApiError } from "../utils/error";
+import { createApi } from '../utils/api';
+import { KafkaTSApiError } from '../utils/error';
 
-export type Metadata = ReturnType<(typeof METADATA)["response"]>;
+export type Metadata = ReturnType<(typeof METADATA)['response']>;
 
 export const METADATA = createApi({
     apiKey: 3,

package/src/api/offset-commit.ts

@@ -1,5 +1,5 @@
-import { createApi } from "../utils/api";
-import { KafkaTSApiError } from "../utils/error";
+import { createApi } from '../utils/api';
+import { KafkaTSApiError } from '../utils/error';
 
 export const OFFSET_COMMIT = createApi({
     apiKey: 8,

package/src/api/offset-fetch.ts

@@ -1,5 +1,5 @@
-import { createApi } from "../utils/api";
-import { KafkaTSApiError } from "../utils/error";
+import { createApi } from '../utils/api';
+import { KafkaTSApiError } from '../utils/error';
 
 export const OFFSET_FETCH = createApi({
     apiKey: 9,

package/src/api/produce.ts

@@ -1,6 +1,6 @@
-import { createApi } from "../utils/api.js";
-import { Encoder } from "../utils/encoder.js";
-import { KafkaTSApiError } from "../utils/error.js";
+import { createApi } from '../utils/api.js';
+import { Encoder } from '../utils/encoder.js';
+import { KafkaTSApiError } from '../utils/error.js';
 
 export const PRODUCE = createApi({
     apiKey: 0,

package/src/api/sasl-authenticate.ts

@@ -1,5 +1,5 @@
-import { createApi } from "../utils/api";
-import { KafkaTSApiError } from "../utils/error";
+import { createApi } from '../utils/api';
+import { KafkaTSApiError } from '../utils/error';
 
 export const SASL_AUTHENTICATE = createApi({
     apiKey: 36,

package/src/api/sasl-handshake.ts

@@ -1,5 +1,5 @@
-import { createApi } from "../utils/api";
-import { KafkaTSApiError } from "../utils/error";
+import { createApi } from '../utils/api';
+import { KafkaTSApiError } from '../utils/error';
 
 export const SASL_HANDSHAKE = createApi({
     apiKey: 17,

package/src/api/sync-group.ts

@@ -1,5 +1,5 @@
-import { createApi } from "../utils/api";
-import { KafkaTSApiError } from "../utils/error";
+import { createApi } from '../utils/api';
+import { KafkaTSApiError } from '../utils/error';
 
 export type Assignment = { [topic: string]: number[] };
 

package/src/broker.ts

@@ -1,11 +1,11 @@
-import { TcpSocketConnectOpts } from "net";
-import { TLSSocketOptions } from "tls";
-import { API } from "./api";
-import { Connection, SendRequest } from "./connection";
-import { KafkaTSError } from "./utils/error";
-import { memo } from "./utils/memo";
+import { TcpSocketConnectOpts } from 'net';
+import { TLSSocketOptions } from 'tls';
+import { API } from './api';
+import { Connection, SendRequest } from './connection';
+import { KafkaTSError } from './utils/error';
+import { memo } from './utils/memo';
 
-export type SASLOptions = { mechanism: "PLAIN"; username: string; password: string };
+export type SASLOptions = { mechanism: 'PLAIN'; username: string; password: string };
 
 type BrokerOptions = {
     clientId: string | null;
@@ -64,11 +64,11 @@ export class Broker {
     }
 
     private async saslAuthenticate() {
-        if (this.options.sasl?.mechanism !== "PLAIN") {
+        if (this.options.sasl?.mechanism !== 'PLAIN') {
             return;
         }
         const { username, password } = this.options.sasl;
-        const authBytes = [null, username, password].join("\u0000");
+        const authBytes = [null, username, password].join('\u0000');
         await this.sendRequest(API.SASL_AUTHENTICATE, { authBytes: Buffer.from(authBytes) });
     }
 }

package/src/client.ts

@@ -1,9 +1,9 @@
-import { TcpSocketConnectOpts } from "net";
-import { TLSSocketOptions } from "tls";
-import { SASLOptions } from "./broker";
-import { Cluster } from "./cluster";
-import { Consumer, ConsumerOptions } from "./consumer/consumer";
-import { Producer, ProducerOptions } from "./producer/producer";
+import { TcpSocketConnectOpts } from 'net';
+import { TLSSocketOptions } from 'tls';
+import { SASLOptions } from './broker';
+import { Cluster } from './cluster';
+import { Consumer, ConsumerOptions } from './consumer/consumer';
+import { Producer, ProducerOptions } from './producer/producer';
 
 type ClientOptions = {
     clientId?: string | null;

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

@@ -1,21 +1,21 @@
-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 { 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: { mechanism: 'PLAIN', 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 +27,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 +39,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 +62,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 +90,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 +109,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 +130,7 @@ describe.sequential("Request handler", () => {
             acks: 1,
             topicData: [
                 {
-                    name: "kafkats-test-topic",
+                    name: 'kafka-ts-test-topic',
                     partitionData: [
                         {
                             index: 0,
@@ -139,18 +142,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 +166,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 +190,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 +211,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 +224,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 +234,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 +302,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 +312,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 +321,7 @@ describe.sequential("Request handler", () => {
                     memberEpoch: 0,
                     topics: [
                         {
-                            name: "kafkats-test-topic",
+                            name: 'kafka-ts-test-topic',
                             partitionIndexes: [0],
                         },
                     ],
@@ -327,12 +330,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 +345,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();
     });