kafka-ts 0.0.1-beta

package/src/utils/encoder.ts

@@ -0,0 +1,141 @@
+export class Encoder {
+    private buffer: Buffer;
+
+    constructor({ buffer = Buffer.alloc(0) }: { buffer?: Buffer } = {}) {
+        this.buffer = buffer;
+    }
+
+    public write(rightBuffer: Buffer) {
+        this.buffer = Buffer.concat([this.buffer, rightBuffer]);
+        return this;
+    }
+
+    public writeInt8(value: number) {
+        const buffer = Buffer.alloc(1);
+        buffer.writeInt8(value);
+        return this.write(buffer);
+    }
+
+    public writeInt16(value: number) {
+        const buffer = Buffer.alloc(2);
+        buffer.writeInt16BE(value);
+        return this.write(buffer);
+    }
+
+    public writeInt32(value: number) {
+        const buffer = Buffer.alloc(4);
+        buffer.writeInt32BE(value);
+        return this.write(buffer);
+    }
+
+    public writeUInt32(value: number) {
+        const buffer = Buffer.alloc(4);
+        buffer.writeUInt32BE(value);
+        return this.write(buffer);
+    }
+
+    public writeInt64(value: bigint) {
+        const buffer = Buffer.alloc(8);
+        buffer.writeBigInt64BE(value);
+        return this.write(buffer);
+    }
+
+    public writeUVarInt(value: number) {
+        const byteArray = [];
+        while ((value & 0xffffffff) !== 0) {
+            byteArray.push((value & 0x7f) | 0x80);
+            value >>>= 7;
+        }
+        byteArray.push(value & 0x7f);
+        return this.write(Buffer.from(byteArray));
+    }
+
+    public writeVarInt(value: number) {
+        const encodedValue = (value << 1) ^ (value >> 31);
+        return this.writeUVarInt(encodedValue);
+    }
+
+    public writeUVarLong(value: bigint) {
+        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));
+    }
+
+    public writeVarLong(value: bigint) {
+        const encodedValue = (value << BigInt(1)) ^ (value >> BigInt(63));
+        return this.writeUVarLong(encodedValue);
+    }
+
+    public writeString(value: string | null) {
+        if (value === null) {
+            return this.writeInt16(-1);
+        }
+        const byteLength = Buffer.byteLength(value, "utf-8");
+        const buffer = Buffer.alloc(byteLength);
+        buffer.write(value, 0, byteLength, "utf-8");
+        return this.writeInt16(byteLength).write(buffer);
+    }
+
+    public writeCompactString(value: string | null) {
+        if (value === null) {
+            return this.writeUVarInt(0);
+        }
+
+        const byteLength = Buffer.byteLength(value, "utf-8");
+        const buffer = Buffer.alloc(byteLength);
+        buffer.write(value, 0, byteLength, "utf-8");
+        return this.writeUVarInt(byteLength + 1).write(buffer);
+    }
+
+    public writeVarIntString(value: string | null) {
+        if (value === null) {
+            return this.writeVarInt(-1);
+        }
+        return this.writeVarInt(Buffer.byteLength(value, "utf-8")).write(Buffer.from(value, "utf-8"));
+    }
+
+    public writeUUID(value: string | null) {
+        if (value === null) {
+            return this.write(Buffer.alloc(16));
+        }
+        return this.write(Buffer.from(value, "hex"));
+    }
+
+    public writeBoolean(value: boolean) {
+        return this.writeInt8(value ? 1 : 0);
+    }
+
+    public writeArray<T>(arr: T[], callback: (encoder: Encoder, item: T) => Encoder) {
+        const buffers = arr.map((item) => callback(new Encoder(), item).value());
+        return this.writeInt32(arr.length).write(Buffer.concat(buffers));
+    }
+
+    public writeCompactArray<T>(arr: T[] | null, callback: (encoder: Encoder, item: T) => Encoder) {
+        if (arr === null) {
+            return this.writeUVarInt(0);
+        }
+        const buffers = arr.map((item) => callback(new Encoder(), item).value());
+        return this.writeUVarInt(buffers.length + 1).write(Buffer.concat(buffers));
+    }
+
+    public writeVarIntArray<T>(arr: T[], callback: (encoder: Encoder, item: T) => Encoder) {
+        const buffers = arr.map((item) => callback(new Encoder(), item).value());
+        return this.writeVarInt(buffers.length).write(Buffer.concat(buffers));
+    }
+
+    public writeBytes(value: Buffer) {
+        return this.writeInt32(value.length).write(value);
+    }
+
+    public writeCompactBytes(value: Buffer) {
+        return this.writeUVarInt(value.length + 1).write(value);
+    }
+
+    public value() {
+        return this.buffer;
+    }
+}

package/src/utils/error.ts

@@ -0,0 +1,21 @@
+import { API_ERROR } from "../api";
+
+export class KafkaTSError extends Error {
+    constructor(message: string) {
+        super(message);
+        this.name = this.constructor.name;
+    }
+}
+
+export class KafkaTSApiError<T = any> extends KafkaTSError {
+    constructor(
+        public errorCode: number,
+        public errorMessage: string | null,
+        public response: T,
+    ) {
+        const [errorName] = Object.entries(API_ERROR).find(([, value]) => value === errorCode) ?? ["UNKNOWN"];
+        super(`${errorName}${errorMessage ? `: ${errorMessage}` : ""}`);
+    }
+}
+
+export class ConnectionError extends KafkaTSError {}

package/src/utils/memo.ts

@@ -0,0 +1,12 @@
+export const memo = <T extends (...args: any[]) => any>(fn: T) => {
+    const cache: Record<string, ReturnType<T>> = {};
+    return (...args: Parameters<T>): ReturnType<T> => {
+        const key = JSON.stringify(args);
+        if (cache[key]) {
+            return cache[key];
+        }
+        const result = fn(...args);
+        cache[key] = result;
+        return result;
+    };
+};

package/src/utils/retrier.ts

@@ -0,0 +1,39 @@
+import { delay } from "./delay";
+
+export type Retrier = (func: () => unknown) => Promise<void>;
+
+export const createExponentialBackoffRetrier =
+    (options: {
+        onFailure?: (error: unknown) => Promise<void>;
+        maxRetries?: number;
+        initialDelayMs?: number;
+        maxDelayMs?: number;
+        multiplier?: number;
+        retry?: number;
+    }): Retrier =>
+    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 delay(delayMs);
+
+            return createExponentialBackoffRetrier({ ...options, retry: retry + 1 })(func);
+        }
+    };
+
+export const defaultRetrier = createExponentialBackoffRetrier({});

package/src/utils/tracer.ts

@@ -0,0 +1,28 @@
+import { serializer } from "./debug";
+
+export const trace =
+    (fn?: (...args: any[]) => Record<string, unknown> | undefined) =>
+    (target: any, propertyKey: string, descriptor: PropertyDescriptor) => {
+        if (!process.env.DEBUG?.includes("kafkats")) return;
+
+        const original = descriptor.value;
+        descriptor.value = function (...args: any[]) {
+            const startTime = Date.now();
+            const metadata = fn?.(...args);
+
+            const onEnd = <T>(result: T): T => {
+                console.log(
+                    `[${propertyKey}] +${Date.now() - startTime}ms ${JSON.stringify({ ...metadata, result }, serializer)}`,
+                );
+                return result;
+            };
+
+            const result = original.apply(this, args);
+            if (result instanceof Promise) {
+                return result.then(onEnd);
+            } else {
+                onEnd(result);
+                return result;
+            }
+        };
+    };

package/tsconfig.json

@@ -0,0 +1,17 @@
+{
+  "compilerOptions": {
+    "lib": ["es2023"],
+    "target": "es2022",
+    "module": "node16",
+    "strict": true,
+    "forceConsistentCasingInFileNames": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "moduleResolution": "node16",
+    "outDir": "dist",
+    "declaration": true,
+    "emitDecoratorMetadata": true,
+    "experimentalDecorators": true
+  },
+  "include": ["src/**/*"],
+}