kafka-ts 0.0.2-beta → 0.0.2

package/dist/utils/encoder.js

@@ -0,0 +1,125 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Encoder = void 0;
+class Encoder {
+    chunks = [];
+    getChunks() {
+        return this.chunks;
+    }
+    getByteLength() {
+        return this.chunks.reduce((acc, chunk) => acc + chunk.byteLength, 0);
+    }
+    write(...buffers) {
+        this.chunks.push(...buffers);
+        return this;
+    }
+    writeEncoder(encoder) {
+        return this.write(...encoder.getChunks());
+    }
+    writeInt8(value) {
+        const buffer = Buffer.allocUnsafe(1);
+        buffer.writeInt8(value);
+        return this.write(buffer);
+    }
+    writeInt16(value) {
+        const buffer = Buffer.allocUnsafe(2);
+        buffer.writeInt16BE(value);
+        return this.write(buffer);
+    }
+    writeInt32(value) {
+        const buffer = Buffer.allocUnsafe(4);
+        buffer.writeInt32BE(value);
+        return this.write(buffer);
+    }
+    writeUInt32(value) {
+        const buffer = Buffer.allocUnsafe(4);
+        buffer.writeUInt32BE(value);
+        return this.write(buffer);
+    }
+    writeInt64(value) {
+        const buffer = Buffer.allocUnsafe(8);
+        buffer.writeBigInt64BE(value);
+        return this.write(buffer);
+    }
+    writeUVarInt(value) {
+        const byteArray = [];
+        while ((value & 0xffffffff) !== 0) {
+            byteArray.push((value & 0x7f) | 0x80);
+            value >>>= 7;
+        }
+        byteArray.push(value & 0x7f);
+        return this.write(Buffer.from(byteArray));
+    }
+    writeVarInt(value) {
+        const encodedValue = (value << 1) ^ (value >> 31);
+        return this.writeUVarInt(encodedValue);
+    }
+    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 this.write(Buffer.from(byteArray));
+    }
+    writeVarLong(value) {
+        const encodedValue = (value << BigInt(1)) ^ (value >> BigInt(63));
+        return this.writeUVarLong(encodedValue);
+    }
+    writeString(value) {
+        if (value === null) {
+            return this.writeInt16(-1);
+        }
+        const byteLength = Buffer.byteLength(value, 'utf-8');
+        const buffer = Buffer.allocUnsafe(byteLength);
+        buffer.write(value, 0, byteLength, 'utf-8');
+        return this.writeInt16(byteLength).write(buffer);
+    }
+    writeCompactString(value) {
+        if (value === null) {
+            return this.writeUVarInt(0);
+        }
+        const byteLength = Buffer.byteLength(value, 'utf-8');
+        const buffer = Buffer.allocUnsafe(byteLength);
+        buffer.write(value, 0, byteLength, 'utf-8');
+        return this.writeUVarInt(byteLength + 1).write(buffer);
+    }
+    writeVarIntBuffer(buffer) {
+        if (buffer === null) {
+            return this.writeVarInt(-1);
+        }
+        return this.writeVarInt(buffer.byteLength).write(buffer);
+    }
+    writeUUID(value) {
+        if (value === null) {
+            return this.write(Buffer.alloc(16));
+        }
+        return this.write(Buffer.from(value, 'hex'));
+    }
+    writeBoolean(value) {
+        return this.writeInt8(value ? 1 : 0);
+    }
+    writeArray(arr, callback) {
+        return this.writeInt32(arr.length).write(...arr.flatMap((item) => callback(new Encoder(), item).getChunks()));
+    }
+    writeCompactArray(arr, callback) {
+        if (arr === null) {
+            return this.writeUVarInt(0);
+        }
+        return this.writeUVarInt(arr.length + 1).write(...arr.flatMap((item) => callback(new Encoder(), item).getChunks()));
+    }
+    writeVarIntArray(arr, callback) {
+        return this.writeVarInt(arr.length).write(...arr.flatMap((item) => callback(new Encoder(), item).getChunks()));
+    }
+    writeBytes(value) {
+        return this.writeInt32(value.length).write(value);
+    }
+    writeCompactBytes(value) {
+        return this.writeUVarInt(value.length + 1).write(value);
+    }
+    value() {
+        return Buffer.concat(this.chunks);
+    }
+}
+exports.Encoder = Encoder;

package/dist/utils/error.d.ts

@@ -0,0 +1,11 @@
+export declare class KafkaTSError extends Error {
+    constructor(message: string);
+}
+export declare class KafkaTSApiError<T = any> extends KafkaTSError {
+    errorCode: number;
+    errorMessage: string | null;
+    response: T;
+    constructor(errorCode: number, errorMessage: string | null, response: T);
+}
+export declare class ConnectionError extends KafkaTSError {
+}

package/dist/utils/error.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConnectionError = exports.KafkaTSApiError = exports.KafkaTSError = void 0;
+const api_1 = require("../api");
+class KafkaTSError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = this.constructor.name;
+    }
+}
+exports.KafkaTSError = KafkaTSError;
+class KafkaTSApiError extends KafkaTSError {
+    errorCode;
+    errorMessage;
+    response;
+    constructor(errorCode, errorMessage, response) {
+        const [errorName] = Object.entries(api_1.API_ERROR).find(([, value]) => value === errorCode) ?? ['UNKNOWN'];
+        super(`${errorName}${errorMessage ? `: ${errorMessage}` : ''}`);
+        this.errorCode = errorCode;
+        this.errorMessage = errorMessage;
+        this.response = response;
+    }
+}
+exports.KafkaTSApiError = KafkaTSApiError;
+class ConnectionError extends KafkaTSError {
+}
+exports.ConnectionError = ConnectionError;

package/dist/utils/logger.d.ts

@@ -0,0 +1,9 @@
+export interface Logger {
+    debug: (message: string, metadata?: unknown) => void;
+    info: (message: string, metadata?: unknown) => void;
+    warn: (message: string, metadata?: unknown) => void;
+    error: (message: string, metadata?: unknown) => void;
+}
+export declare const jsonSerializer: (_: unknown, v: unknown) => unknown;
+export declare let log: Logger;
+export declare const setLogger: (newLogger: Logger) => void;

package/dist/utils/logger.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setLogger = exports.log = exports.jsonSerializer = void 0;
+const jsonSerializer = (_, v) => {
+    if (v instanceof Error) {
+        return { name: v.name, message: v.message, stack: v.stack, cause: v.cause };
+    }
+    if (typeof v === 'bigint') {
+        return v.toString();
+    }
+    return v;
+};
+exports.jsonSerializer = jsonSerializer;
+class JsonLogger {
+    debug(message, metadata) {
+        console.debug(JSON.stringify({ message, metadata, level: 'debug' }, exports.jsonSerializer));
+    }
+    info(message, metadata) {
+        console.info(JSON.stringify({ message, metadata, level: 'info' }, exports.jsonSerializer));
+    }
+    warn(message, metadata) {
+        console.warn(JSON.stringify({ message, metadata, level: 'warning' }, exports.jsonSerializer));
+    }
+    error(message, metadata) {
+        console.error(JSON.stringify({ message, metadata, level: 'error' }, exports.jsonSerializer));
+    }
+}
+exports.log = new JsonLogger();
+const setLogger = (newLogger) => {
+    exports.log = newLogger;
+};
+exports.setLogger = setLogger;

package/dist/utils/memo.d.ts

@@ -0,0 +1 @@
+export declare const memo: <T extends (...args: any[]) => any>(fn: T) => (...args: Parameters<T>) => ReturnType<T>;

package/dist/utils/memo.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.memo = void 0;
+const memo = (fn) => {
+    const cache = {};
+    return (...args) => {
+        const key = JSON.stringify(args);
+        if (cache[key]) {
+            return cache[key];
+        }
+        const result = fn(...args);
+        cache[key] = result;
+        return result;
+    };
+};
+exports.memo = memo;

package/dist/utils/murmur2.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="node" />
+export declare const murmur2: (data: Buffer) => number;
+export declare const toPositive: (input: number) => number;

package/dist/utils/murmur2.js

@@ -0,0 +1,40 @@
+"use strict";
+/* https://github.com/apache/kafka/blob/0.10.2/clients/src/main/java/org/apache/kafka/common/utils/Utils.java#L364 */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toPositive = exports.murmur2 = void 0;
+const murmur2 = (data) => {
+    const length = data.length;
+    const seed = 0x9747b28c;
+    const m = 0x5bd1e995;
+    const r = 24;
+    let h = seed ^ length;
+    let length4 = Math.floor(length / 4);
+    for (let i = 0; i < length4; i++) {
+        const i4 = i * 4;
+        let k = (data[i4 + 0] & 0xff) +
+            ((data[i4 + 1] & 0xff) << 8) +
+            ((data[i4 + 2] & 0xff) << 16) +
+            ((data[i4 + 3] & 0xff) << 24);
+        k *= m;
+        k ^= k >> r;
+        k *= m;
+        h *= m;
+        h ^= k;
+    }
+    switch (length % 4) {
+        case 3:
+            h = h ^ ((data[(length & ~3) + 2] & 0xff) << 16);
+        case 2:
+            h = h ^ ((data[(length & ~3) + 1] & 0xff) << 8);
+        case 1:
+            h = h ^ (data[length & ~3] & 0xff);
+            h *= m;
+    }
+    h ^= h >> 13;
+    h *= m;
+    h ^= h >> 15;
+    return h;
+};
+exports.murmur2 = murmur2;
+const toPositive = (input) => input & 0x7fffffff;
+exports.toPositive = toPositive;

package/dist/utils/retrier.d.ts

@@ -0,0 +1,10 @@
+export type Retrier = (func: () => unknown) => Promise<void>;
+export declare const createExponentialBackoffRetrier: (options: {
+    onFailure?: (error: unknown) => Promise<void>;
+    maxRetries?: number;
+    initialDelayMs?: number;
+    maxDelayMs?: number;
+    multiplier?: number;
+    retry?: number;
+}) => Retrier;
+export declare const defaultRetrier: Retrier;

package/dist/utils/retrier.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultRetrier = exports.createExponentialBackoffRetrier = void 0;
+const delay_1 = require("./delay");
+const createExponentialBackoffRetrier = (options) => async (func) => {
+    try {
+        await func();
+    }
+    catch (error) {
+        const { retry = 0, maxRetries = 3, onFailure = (error) => {
+            throw error;
+        }, initialDelayMs = 100, maxDelayMs = 3000, multiplier = 2, } = options;
+        const isMaxRetriesExceeded = retry > maxRetries;
+        if (isMaxRetriesExceeded)
+            return onFailure(error);
+        const delayMs = Math.min(maxDelayMs, initialDelayMs * multiplier ** retry);
+        await (0, delay_1.delay)(delayMs);
+        return (0, exports.createExponentialBackoffRetrier)({ ...options, retry: retry + 1 })(func);
+    }
+};
+exports.createExponentialBackoffRetrier = createExponentialBackoffRetrier;
+exports.defaultRetrier = (0, exports.createExponentialBackoffRetrier)({});

package/dist/utils/tracer.d.ts

@@ -0,0 +1,5 @@
+export interface Tracer {
+    startActiveSpan<T>(module: string, method: string, metadata: Record<string, unknown>, callback: () => T): T;
+}
+export declare const setTracer: <T>(newTracer: Tracer) => void;
+export declare const createTracer: (module: string) => (fn?: (...args: any[]) => Record<string, unknown> | undefined) => (target: any, propertyKey: string, descriptor: PropertyDescriptor) => void;

package/dist/utils/tracer.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTracer = exports.setTracer = void 0;
+const logger_1 = require("./logger");
+class DebugTracer {
+    isEnabled = process.env.DEBUG?.includes('kafka-ts');
+    startActiveSpan(module, method, metadata, callback) {
+        if (!this.isEnabled) {
+            return callback();
+        }
+        const startTime = Date.now();
+        const onEnd = (result) => {
+            logger_1.log.debug(`[${module}.${method}] ${metadata?.message ?? ''} +${Date.now() - startTime}ms`, {
+                ...metadata,
+                ...(!!result && { result }),
+            });
+            return result;
+        };
+        const result = callback();
+        if (result instanceof Promise) {
+            return result.then(onEnd);
+        }
+        onEnd(result);
+        return result;
+    }
+}
+let tracer = new DebugTracer();
+const setTracer = (newTracer) => {
+    tracer = newTracer;
+};
+exports.setTracer = setTracer;
+const createTracer = (module) => (fn) => (target, propertyKey, descriptor) => {
+    const original = descriptor.value;
+    descriptor.value = function (...args) {
+        const metadata = fn?.(...args);
+        return tracer.startActiveSpan(module, propertyKey, { ...metadata }, () => original.apply(this, args));
+    };
+};
+exports.createTracer = createTracer;

package/package.json

@@ -1,21 +1,32 @@
 {
-  "name": "kafka-ts",
-  "version": "0.0.2-beta",
-  "main": "dist/index.js",
-  "author": "Priit Käärd",
-  "license": "MIT",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/priitkaard/kafka-ts.git"
-  },
-  "scripts": {
-    "build": "tsc",
-    "test": "vitest --testTimeout 60000 --bail 1"
-  },
-  "devDependencies": {
-    "@types/node": "^20.12.12",
-    "prettier": "^3.2.5",
-    "typescript": "^5.4.5",
-    "vitest": "^1.6.0"
-  }
+    "name": "kafka-ts",
+    "version": "0.0.2",
+    "main": "dist/index.js",
+    "author": "Priit Käärd",
+    "license": "MIT",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/priitkaard/kafka-ts.git"
+    },
+    "scripts": {
+        "start": "docker-compose down && KAFKA_VERSION=3.7.1 docker-compose up -d && sleep 5 && bash ./scripts/create-scram-user.sh",
+        "version:beta": "npm version prerelease --preid=beta",
+        "version:patch": "npm version patch",
+        "format": "prettier --write .",
+        "build": "tsc",
+        "watch": "tsc -w",
+        "test": "vitest --testTimeout 60000 --bail 1"
+    },
+    "devDependencies": {
+        "@types/node": "^20.12.12",
+        "prettier": "^3.3.3",
+        "typescript": "^5.4.5",
+        "vitest": "^1.6.0"
+    },
+    "keywords": [
+        "kafka",
+        "client",
+        "producer",
+        "consumer"
+    ]
 }