kafka-ts 1.1.8 → 1.2.0

package/dist/src/request-handler.test.js

@@ -1,321 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const vitest_1 = require("vitest");
-const api_versions_1 = require("./api/api-versions");
-const create_topics_1 = require("./api/create-topics");
-const fetch_1 = require("./api/fetch");
-const metadata_1 = require("./api/metadata");
-const connection_1 = require("./connection");
-const request_handler_1 = require("./request-handler");
-const delete_topics_1 = require("./api/delete-topics");
-const produce_1 = require("./api/produce");
-const find_coordinator_1 = require("./api/find-coordinator");
-const join_group_1 = require("./api/join-group");
-const crypto_1 = require("crypto");
-const sync_group_1 = require("./api/sync-group");
-const offset_commit_1 = require("./api/offset-commit");
-const offset_fetch_1 = require("./api/offset-fetch");
-const heartbeat_1 = require("./api/heartbeat");
-const leave_group_1 = require("./api/leave-group");
-const init_producer_id_1 = require("./api/init-producer-id");
-vitest_1.describe.sequential("Request handler", () => {
-    const connection = (0, connection_1.createConnection)({ host: "localhost", port: 9092 });
-    let sendRequest;
-    const groupId = (0, crypto_1.randomBytes)(16).toString("hex");
-    (0, vitest_1.beforeAll)(async () => {
-        await connection.connect();
-        const handler = (0, request_handler_1.createRequestHandler)({ clientId: 'kafkats', connection });
-        sendRequest = handler.sendRequest;
-        const metadataResult = await sendRequest(metadata_1.METADATA, {
-            topics: null,
-            allowTopicAutoCreation: false,
-            includeTopicAuthorizedOperations: false,
-        });
-        if (metadataResult.topics.some((topic) => topic.name === "kafkats-test-topic")) {
-            await sendRequest(delete_topics_1.DELETE_TOPICS, {
-                topics: [{ name: "kafkats-test-topic", topicId: null }],
-                timeoutMs: 10000,
-            });
-        }
-    });
-    (0, vitest_1.afterAll)(async () => {
-        await connection.disconnect();
-    });
-    (0, vitest_1.it)("should request api versions", async () => {
-        const result = await sendRequest(api_versions_1.API_VERSIONS, {});
-        (0, vitest_1.expect)(result).toMatchSnapshot();
-    });
-    let topicId = "d6718d178e1b47c886441ad2d19faea5";
-    (0, vitest_1.it)("should create topics", async () => {
-        const result = await sendRequest(create_topics_1.CREATE_TOPICS, {
-            topics: [
-                {
-                    name: "kafkats-test-topic",
-                    numPartitions: 1,
-                    replicationFactor: 1,
-                    assignments: [],
-                    configs: [],
-                },
-            ],
-            timeoutMs: 10000,
-            validateOnly: false,
-        });
-        topicId = result.topics[0].topicId;
-        console.log({ topicId });
-        result.topics.forEach((topic) => {
-            topic.topicId = "Any<UUID>";
-        });
-        (0, vitest_1.expect)(result).toMatchSnapshot();
-    });
-    (0, vitest_1.it)("should request metadata for all topics", async () => {
-        const result = await sendRequest(metadata_1.METADATA, {
-            topics: null,
-            allowTopicAutoCreation: false,
-            includeTopicAuthorizedOperations: false,
-        });
-        result.topics.forEach((topic) => {
-            topic.topicId = "Any<UUID>";
-        });
-        (0, vitest_1.expect)(result).toMatchSnapshot();
-    });
-    (0, vitest_1.it)("should request metadata for a topic", async () => {
-        const result = await sendRequest(metadata_1.METADATA, {
-            topics: [{ id: topicId, name: "kafkats-test-topic" }],
-            allowTopicAutoCreation: false,
-            includeTopicAuthorizedOperations: false,
-        });
-        result.topics.forEach((topic) => {
-            topic.topicId = "Any<UUID>";
-        });
-        (0, vitest_1.expect)(result).toMatchSnapshot();
-    });
-    (0, vitest_1.it)('should init producer id', async () => {
-        const result = await sendRequest(init_producer_id_1.INIT_PRODUCER_ID, {
-            transactionalId: null,
-            transactionTimeoutMs: 0,
-            producerId: 0n,
-            producerEpoch: 0,
-        });
-        (0, vitest_1.expect)(result).toMatchSnapshot();
-    });
-    (0, vitest_1.it)("should produce messages", async () => {
-        const now = Date.now();
-        const result = await sendRequest(produce_1.PRODUCE, {
-            transactionalId: null,
-            timeoutMs: 10000,
-            acks: 1,
-            topicData: [
-                {
-                    name: "kafkats-test-topic",
-                    partitionData: [
-                        {
-                            index: 0,
-                            baseOffset: 0n,
-                            partitionLeaderEpoch: 0,
-                            attributes: 0,
-                            baseSequence: 0,
-                            baseTimestamp: BigInt(now),
-                            lastOffsetDelta: 0,
-                            maxTimestamp: BigInt(now),
-                            producerEpoch: 0,
-                            producerId: 9n,
-                            records: [
-                                {
-                                    attributes: 0,
-                                    offsetDelta: 0,
-                                    timestampDelta: 0n,
-                                    key: "key",
-                                    value: "value",
-                                    headers: [
-                                        {
-                                            key: "header-key",
-                                            value: "header-value",
-                                        },
-                                    ],
-                                },
-                            ],
-                        },
-                    ],
-                },
-            ],
-        });
-        (0, vitest_1.expect)(result).toMatchSnapshot();
-    });
-    (0, vitest_1.it)("should fetch messages", async () => {
-        const result = await sendRequest(fetch_1.FETCH, {
-            maxWaitMs: 100,
-            minBytes: 1,
-            maxBytes: 10485760,
-            isolationLevel: 1,
-            sessionId: 0,
-            sessionEpoch: -1,
-            topics: [
-                {
-                    topicId,
-                    partitions: [
-                        {
-                            partition: 0,
-                            currentLeaderEpoch: -1,
-                            fetchOffset: 0n,
-                            lastFetchedEpoch: 0,
-                            logStartOffset: -1n,
-                            partitionMaxBytes: 10485760,
-                        },
-                    ],
-                },
-            ],
-            forgottenTopicsData: [],
-            rackId: "",
-        });
-        result.responses.forEach((response) => {
-            response.topicId = "Any<UUID>";
-            response.partitions.forEach((partition) => {
-                partition.records.forEach((record) => {
-                    (0, vitest_1.expect)(record.baseTimestamp).toBeGreaterThan(1721926744730n);
-                    (0, vitest_1.expect)(record.maxTimestamp).toBeGreaterThan(1721926744730n);
-                    (0, vitest_1.expect)(record.crc).toBeGreaterThan(0);
-                    record.baseTimestamp = 0n;
-                    record.maxTimestamp = 0n;
-                    record.crc = 0;
-                });
-            });
-        });
-        (0, vitest_1.expect)(result).toMatchSnapshot();
-    });
-    (0, vitest_1.it)("should find coordinator", async () => {
-        const result = await sendRequest(find_coordinator_1.FIND_COORDINATOR, { keyType: find_coordinator_1.KEY_TYPE.GROUP, keys: [groupId] });
-        result.coordinators.forEach((coordinator) => {
-            coordinator.key = "Any<String>";
-        });
-        (0, vitest_1.expect)(result).toMatchSnapshot();
-    });
-    let memberId = "";
-    (0, vitest_1.it)("should fail join group request with new memberId", async () => {
-        const result = await sendRequest(join_group_1.JOIN_GROUP, {
-            groupId: groupId,
-            sessionTimeoutMs: 30000,
-            rebalanceTimeoutMs: 60000,
-            memberId,
-            groupInstanceId: null,
-            protocolType: "consumer",
-            protocols: [
-                {
-                    name: "RoundRobinAssigner",
-                    metadata: { version: 0, topics: ["kafkats-test-topic"] },
-                },
-            ],
-            reason: null,
-        });
-        memberId = String(result.memberId ?? "");
-        result.memberId = "Any<UUID>";
-        (0, vitest_1.expect)(result).toMatchSnapshot();
-    });
-    (0, vitest_1.it)("should join group", async () => {
-        const result = await sendRequest(join_group_1.JOIN_GROUP, {
-            groupId: groupId,
-            sessionTimeoutMs: 30000,
-            rebalanceTimeoutMs: 60000,
-            memberId,
-            groupInstanceId: null,
-            protocolType: "consumer",
-            protocols: [
-                {
-                    name: "RoundRobinAssigner",
-                    metadata: { version: 0, topics: ["kafkats-test-topic"] },
-                },
-            ],
-            reason: null,
-        });
-        result.memberId = "Any<UUID>";
-        result.leader = "Any<UUID>";
-        result.members.forEach((member) => {
-            member.memberId = "Any<UUID>";
-        });
-        (0, vitest_1.expect)(result).toMatchSnapshot();
-    });
-    (0, vitest_1.it)("should sync group", async () => {
-        const result = await sendRequest(sync_group_1.SYNC_GROUP, {
-            groupId,
-            generationId: 1,
-            memberId,
-            groupInstanceId: null,
-            protocolType: "consumer",
-            protocolName: "RoundRobinAssigner",
-            assignments: [
-                {
-                    memberId,
-                    assignment: { "kafka-test-topic": [0] },
-                },
-            ],
-        });
-        (0, vitest_1.expect)(result).toMatchSnapshot();
-    });
-    (0, vitest_1.it)("should commit offsets", async () => {
-        const result = await sendRequest(offset_commit_1.OFFSET_COMMIT, {
-            groupId,
-            generationIdOrMemberEpoch: 1,
-            memberId,
-            groupInstanceId: null,
-            topics: [
-                {
-                    name: "kafkats-test-topic",
-                    partitions: [
-                        { partitionIndex: 0, committedOffset: 1n, committedLeaderEpoch: 0, committedMetadata: null },
-                    ],
-                },
-            ],
-        });
-        (0, vitest_1.expect)(result).toMatchSnapshot();
-    });
-    (0, vitest_1.it)("should fetch offsets", async () => {
-        const result = await sendRequest(offset_fetch_1.OFFSET_FETCH, {
-            groups: [
-                {
-                    groupId,
-                    memberId,
-                    memberEpoch: 0,
-                    topics: [
-                        {
-                            name: "kafkats-test-topic",
-                            partitionIndexes: [0],
-                        },
-                    ],
-                },
-            ],
-            requireStable: false,
-        });
-        result.groups.forEach((group) => {
-            group.groupId = "Any<String>";
-        });
-        (0, vitest_1.expect)(result).toMatchSnapshot();
-    });
-    (0, vitest_1.it)("should heartbeat", async () => {
-        const result = await sendRequest(heartbeat_1.HEARTBEAT, {
-            groupId,
-            generationId: 1,
-            memberId,
-            groupInstanceId: null,
-        });
-        (0, vitest_1.expect)(result).toMatchSnapshot();
-    });
-    (0, vitest_1.it)("should leave group", async () => {
-        const result = await sendRequest(leave_group_1.LEAVE_GROUP, {
-            groupId,
-            members: [{ memberId, groupInstanceId: null, reason: null }],
-        });
-        result.members.forEach((member) => {
-            member.memberId = "Any<UUID>";
-        });
-        (0, vitest_1.expect)(result).toMatchSnapshot();
-    });
-    vitest_1.it.skip("should delete topics", async () => {
-        const result = await sendRequest(delete_topics_1.DELETE_TOPICS, {
-            topics: [{ name: "kafkats-test-topic", topicId: null }],
-            timeoutMs: 10000,
-        });
-        result.responses.forEach((response) => {
-            response.topicId = "Any<UUID>";
-        });
-        (0, vitest_1.expect)(result).toMatchSnapshot();
-    });
-});

package/dist/src/types.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

package/dist/src/utils/api.js

@@ -1,5 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createApi = void 0;
-const createApi = (api) => api;
-exports.createApi = createApi;

package/dist/src/utils/decoder.js

@@ -1,161 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createDecoder = void 0;
-const createDecoder = ({ buffer, offset = 0 }) => {
-    const readInt8 = () => {
-        const value = buffer.readInt8(offset);
-        offset += 1;
-        return value;
-    };
-    const readInt16 = () => {
-        const value = buffer.readInt16BE(offset);
-        offset += 2;
-        return value;
-    };
-    const readInt32 = () => {
-        const value = buffer.readInt32BE(offset);
-        offset += 4;
-        return value;
-    };
-    const readUInt32 = () => {
-        const value = buffer.readUInt32BE(offset);
-        offset += 4;
-        return value;
-    };
-    const readInt64 = () => {
-        const value = buffer.readBigInt64BE(offset);
-        offset += 8;
-        return value;
-    };
-    const readString = () => {
-        const length = readInt16();
-        if (length === -1) {
-            return null;
-        }
-        const value = buffer.toString('utf-8', offset, offset + length);
-        offset += length;
-        return value;
-    };
-    const readCompactString = () => {
-        const length = readUVarInt() - 1;
-        if (length < 0) {
-            return null;
-        }
-        const value = buffer.toString('utf-8', offset, offset + length);
-        offset += length;
-        return value;
-    };
-    const readVarInt = () => {
-        let currentByte;
-        let result = 0;
-        let i = 0;
-        while (((currentByte = buffer[offset++]) & 0x80) !== 0) {
-            result |= (currentByte & 0x7f) << i;
-            i += 7;
-            if (i > 28) {
-                throw new Error("Invalid VarInt, must contain 5 bytes or less");
-            }
-        }
-        result |= currentByte << i;
-        return result;
-    };
-    const readUVarInt = () => {
-        const result = readVarInt();
-        return result >>> 0;
-    };
-    const readVarLong = () => {
-        let currentByte;
-        let result = BigInt(0);
-        let i = 0;
-        while (((currentByte = buffer[offset++]) & 0x80) !== 0) {
-            result |= BigInt(currentByte & 0x7f) << BigInt(i);
-            i += 7;
-            if (i > 63) {
-                throw new Error("Invalid VarLong, must contain 9 bytes or less");
-            }
-        }
-        result |= BigInt(currentByte) << BigInt(i);
-        return result;
-    };
-    const readUUID = () => {
-        const value = buffer.toString("hex", offset, offset + 16);
-        offset += 16;
-        return value;
-    };
-    const readBoolean = () => {
-        const value = buffer.readInt8(offset) === 1;
-        offset += 1;
-        return value;
-    };
-    const readArray = (callback) => {
-        const length = readInt32();
-        const decoder = (0, exports.createDecoder)({ buffer, offset });
-        const results = Array.from({ length }).map(() => callback(decoder));
-        offset = decoder.offset;
-        return results;
-    };
-    const readCompactArray = (callback) => {
-        const length = readUVarInt() - 1;
-        const decoder = (0, exports.createDecoder)({ buffer, offset });
-        const results = Array.from({ length }).map(() => callback(decoder));
-        offset = decoder.offset;
-        return results;
-    };
-    const readRecords = (callback) => {
-        const length = readInt32();
-        return Array.from({ length }).map(() => {
-            const size = Math.ceil((readVarInt() - 1) / 2);
-            const child = (0, exports.createDecoder)({ buffer: buffer.subarray(offset, offset + size) });
-            offset += size;
-            return callback(child);
-        });
-    };
-    const read = (length) => {
-        const value = buffer.subarray(offset, offset + length);
-        offset += length;
-        return value;
-    };
-    const readBytes = () => {
-        const length = readInt32();
-        return read(length);
-    };
-    const readCompactBytes = (divide = false) => {
-        let length = readUVarInt() - 1;
-        if (length < 0) {
-            return null;
-        }
-        if (divide) {
-            length = Math.round(length / 2);
-        }
-        return read(length);
-    };
-    const readTagBuffer = () => {
-        readUVarInt();
-    };
-    return {
-        readInt8,
-        readInt16,
-        readInt32,
-        readInt64,
-        readUInt32,
-        readVarInt,
-        readUVarInt,
-        readVarLong,
-        readString,
-        readBytes,
-        readCompactString,
-        readUUID,
-        readBoolean,
-        readArray,
-        readCompactArray,
-        read,
-        readCompactBytes,
-        readTagBuffer,
-        readRecords,
-        buffer,
-        get offset() {
-            return offset;
-        },
-    };
-};
-exports.createDecoder = createDecoder;

package/dist/src/utils/encoder.js

@@ -1,137 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createEncoder = void 0;
-const createEncoder = ({ buffer = Buffer.alloc(0) } = {}) => {
-    const write = (rightBuffer) => (0, exports.createEncoder)({ buffer: Buffer.concat([buffer, rightBuffer]) });
-    const writeInt8 = (value) => {
-        const buffer = Buffer.alloc(1);
-        buffer.writeInt8(value);
-        return write(buffer);
-    };
-    const writeInt16 = (value) => {
-        const buffer = Buffer.alloc(2);
-        buffer.writeInt16BE(value);
-        return write(buffer);
-    };
-    const writeInt32 = (value) => {
-        const buffer = Buffer.alloc(4);
-        buffer.writeInt32BE(value);
-        return write(buffer);
-    };
-    const writeUInt32 = (value) => {
-        const buffer = Buffer.alloc(4);
-        buffer.writeUInt32BE(value);
-        return write(buffer);
-    };
-    const writeInt64 = (value) => {
-        const buffer = Buffer.alloc(8);
-        buffer.writeBigInt64BE(value);
-        return write(buffer);
-    };
-    const writeString = (value) => {
-        if (value === null) {
-            return writeInt16(-1);
-        }
-        const byteLength = Buffer.byteLength(value, "utf-8");
-        const buffer = Buffer.alloc(2 + byteLength);
-        buffer.writeInt16BE(byteLength);
-        buffer.write(value, 2, byteLength, "utf-8");
-        return write(buffer);
-    };
-    const writeUVarInt = (value) => {
-        const byteArray = [];
-        while ((value & 0xffffffff) !== 0) {
-            byteArray.push((value & 0x7f) | 0x80);
-            value >>>= 7;
-        }
-        byteArray.push(value & 0x7f);
-        return write(Buffer.from(byteArray));
-    };
-    const writeVarInt = (value) => {
-        const encodedValue = (value << 1) ^ (value >> 31);
-        return writeUVarInt(encodedValue);
-    };
-    const writeUVarLong = (value) => {
-        const byteArray = [];
-        while ((value & BigInt(0xffffffffffffffff)) !== BigInt(0)) {
-            byteArray.push(Number(value & BigInt(0x7f) | BigInt(0x80)));
-            value = value >> BigInt(7);
-        }
-        byteArray.push(Number(value));
-        return write(Buffer.from(byteArray));
-    };
-    const writeVarLong = (value) => {
-        const encodedValue = (value << BigInt(1)) ^ (value >> BigInt(63));
-        return writeUVarLong(encodedValue);
-    };
-    // const writeVarLong = (value: bigint) => {
-    //     const encodedValue = (value << BigInt(1)) ^ (value >> BigInt(63));
-    //     return writeUVarInt(Number(encodedValue));
-    // };
-    const writeCompactString = (value) => {
-        if (value === null) {
-            return writeUVarInt(0);
-        }
-        const byteLength = Buffer.byteLength(value, "utf-8");
-        const buffer = Buffer.alloc(byteLength);
-        buffer.write(value, 0, byteLength, "utf-8");
-        return writeUVarInt(byteLength + 1).write(buffer);
-    };
-    const writeVarIntString = (value) => {
-        if (value === null) {
-            return writeVarInt(-1);
-        }
-        return writeVarInt(Buffer.byteLength(value, 'utf-8')).write(Buffer.from(value, 'utf-8'));
-    };
-    const writeUUID = (value) => {
-        if (value === null) {
-            return write(Buffer.alloc(16));
-        }
-        return write(Buffer.from(value, "hex"));
-    };
-    const writeCompactArray = (arr, callback) => {
-        if (arr === null) {
-            return writeUVarInt(0);
-        }
-        const buffers = arr.map((item) => callback((0, exports.createEncoder)(), item).value());
-        return writeUVarInt(buffers.length + 1).write(Buffer.concat(buffers));
-    };
-    const writeArray = (arr, callback) => {
-        const buffers = arr.map((item) => callback((0, exports.createEncoder)(), item).value());
-        return writeInt32(arr.length).write(Buffer.concat(buffers));
-    };
-    const writeBoolean = (value) => {
-        const buffer = Buffer.alloc(1);
-        buffer.writeInt8(value ? 1 : 0);
-        return write(buffer);
-    };
-    const writeBytes = (value) => {
-        return writeInt32(value.length).write(value);
-    };
-    const writeCompactBytes = (value) => {
-        return writeUVarInt(value.length + 1).write(value);
-    };
-    const value = () => buffer;
-    return {
-        write,
-        writeInt8,
-        writeInt16,
-        writeInt32,
-        writeUInt32,
-        writeInt64,
-        writeCompactString,
-        writeVarIntString,
-        writeString,
-        writeUVarInt,
-        writeVarInt,
-        writeVarLong,
-        writeUUID,
-        writeCompactArray,
-        writeArray,
-        writeBoolean,
-        writeBytes,
-        writeCompactBytes,
-        value,
-    };
-};
-exports.createEncoder = createEncoder;

package/dist/src/utils/error.js

@@ -1,10 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.KafkaTSError = void 0;
-class KafkaTSError extends Error {
-    constructor(message) {
-        super(message);
-        this.name = "KafkaTSError";
-    }
-}
-exports.KafkaTSError = KafkaTSError;

package/dist/utils/debug.d.ts

@@ -1,2 +0,0 @@
-export declare const serializer: (_: string, value: unknown) => unknown;
-export declare const createDebugger: (module: string) => (func: string, message: string, data?: unknown) => void;

package/dist/utils/debug.js

@@ -1,11 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createDebugger = exports.serializer = void 0;
-const serializer = (_, value) => (typeof value === 'bigint' ? value.toString() : value);
-exports.serializer = serializer;
-const createDebugger = (module) => (func, message, data) => {
-    if (!process.env.DEBUG?.includes('kafka-ts'))
-        return;
-    console.debug(`[${module}] ${func}: ${message}`, data && `(${data instanceof Error ? data : JSON.stringify(data, exports.serializer, 4)})`);
-};
-exports.createDebugger = createDebugger;

package/dist/utils/lock.d.ts

@@ -1,8 +0,0 @@
-import EventEmitter from 'events';
-export declare class Lock extends EventEmitter {
-    private locks;
-    constructor();
-    acquire(keys: string[], callback: () => Promise<void>): Promise<void>;
-    private acquireKey;
-    private releaseKey;
-}