@platformatic/kafka 0.1.0

package/dist/protocol/sasl/plain.d.ts

@@ -0,0 +1,3 @@
+import { type SASLAuthenticationAPI, type SaslAuthenticateResponse } from '../../apis/security/sasl-authenticate.ts';
+import { type Connection } from '../../network/connection.ts';
+export declare function authenticate(authenticateAPI: SASLAuthenticationAPI, connection: Connection, username: string, password: string): Promise<SaslAuthenticateResponse>;

package/dist/protocol/sasl/plain.js

@@ -0,0 +1,3 @@
+export function authenticate(authenticateAPI, connection, username, password) {
+    return authenticateAPI.async(connection, Buffer.from(['', username, password].join('\0')));
+}

package/dist/protocol/sasl/scram-sha.d.ts

@@ -0,0 +1,28 @@
+import { type SASLAuthenticationAPI, type SaslAuthenticateResponse } from '../../apis/security/sasl-authenticate.ts';
+import { type Connection } from '../../network/connection.ts';
+export interface ScramAlgorithmDefinition {
+    keyLength: number;
+    algorithm: string;
+    minIterations: number;
+}
+export declare const ScramAlgorithms: {
+    readonly 'SHA-256': {
+        readonly keyLength: 32;
+        readonly algorithm: "sha256";
+        readonly minIterations: 4096;
+    };
+    readonly 'SHA-512': {
+        readonly keyLength: 64;
+        readonly algorithm: "sha512";
+        readonly minIterations: 4096;
+    };
+};
+export type ScramAlgorithm = keyof typeof ScramAlgorithms;
+export declare function createNonce(): string;
+export declare function sanitizeString(str: string): string;
+export declare function parseParameters(data: Buffer): Record<string, string>;
+export declare function h(definition: ScramAlgorithmDefinition, data: string | Buffer): Buffer<ArrayBufferLike>;
+export declare function hi(definition: ScramAlgorithmDefinition, password: string, salt: Buffer, iterations: number): Buffer<ArrayBufferLike>;
+export declare function hmac(definition: ScramAlgorithmDefinition, key: Buffer, data: string | Buffer): Buffer;
+export declare function xor(a: Buffer, b: Buffer): Buffer;
+export declare function authenticate(authenticateAPI: SASLAuthenticationAPI, connection: Connection, algorithm: ScramAlgorithm, username: string, password: string): Promise<SaslAuthenticateResponse>;

package/dist/protocol/sasl/scram-sha.js

@@ -0,0 +1,104 @@
+import { createHash, createHmac, pbkdf2Sync, randomBytes } from 'node:crypto';
+import { AuthenticationError } from "../../errors.js";
+const GS2_HEADER = 'n,,';
+const GS2_HEADER_BASE64 = Buffer.from(GS2_HEADER).toString('base64');
+const HMAC_CLIENT_KEY = 'Client Key';
+const HMAC_SERVER_KEY = 'Server Key';
+const PARAMETERS_PARSER = /([^=]+)=(.+)/;
+export const ScramAlgorithms = {
+    'SHA-256': {
+        keyLength: 32,
+        algorithm: 'sha256',
+        minIterations: 4096
+    },
+    'SHA-512': {
+        keyLength: 64,
+        algorithm: 'sha512',
+        minIterations: 4096
+    }
+};
+export function createNonce() {
+    return randomBytes(16).toString('base64url');
+}
+export function sanitizeString(str) {
+    return str.replaceAll('=', '=3D').replace(',', '=2C');
+}
+export function parseParameters(data) {
+    const original = data.toString('utf-8');
+    return {
+        __original: original,
+        ...Object.fromEntries(original.split(',').map(param => param.match(PARAMETERS_PARSER).slice(1, 3)))
+    };
+}
+// h, hi, hmac and xor, are defined in https://datatracker.ietf.org/doc/html/rfc5802#section-2.2
+export function h(definition, data) {
+    return createHash(definition.algorithm).update(data).digest();
+}
+export function hi(definition, password, salt, iterations) {
+    return pbkdf2Sync(password, salt, iterations, definition.keyLength, definition.algorithm);
+}
+export function hmac(definition, key, data) {
+    return createHmac(definition.algorithm, key).update(data).digest();
+}
+export function xor(a, b) {
+    if (a.byteLength !== b.byteLength) {
+        throw new AuthenticationError('Buffers must have the same length.');
+    }
+    const result = Buffer.allocUnsafe(a.length);
+    for (let i = 0; i < a.length; i++) {
+        result[i] = a[i] ^ b[i];
+    }
+    return result;
+}
+// Implements https://datatracker.ietf.org/doc/html/rfc5802#section-9
+export async function authenticate(authenticateAPI, connection, algorithm, username, password) {
+    const definition = ScramAlgorithms[algorithm];
+    if (!definition) {
+        throw new AuthenticationError(`Unsupported SCRAM algorithm ${algorithm}`);
+    }
+    const clientNonce = createNonce();
+    const clientFirstMessageBare = `n=${sanitizeString(username)},r=${clientNonce}`;
+    // First of all, send the first message
+    const firstResponse = await authenticateAPI.async(connection, Buffer.from(`${GS2_HEADER}${clientFirstMessageBare}`));
+    const firstData = parseParameters(firstResponse.authBytes);
+    // Extract some parameters
+    const salt = Buffer.from(firstData.s, 'base64');
+    const iterations = parseInt(firstData.i, 10);
+    const serverNonce = firstData.r;
+    const serverFirstMessage = firstData.__original;
+    // Validate response
+    if (!serverNonce.startsWith(clientNonce)) {
+        throw new AuthenticationError('Server nonce does not start with client nonce.');
+    }
+    if (definition.minIterations > iterations) {
+        throw new AuthenticationError(`Algorithm ${algorithm} requires at least ${definition.minIterations} iterations, while ${iterations} were requested.`);
+    }
+    // SaltedPassword  := Hi(Normalize(password), salt, i)
+    // ClientKey       := HMAC(SaltedPassword, "Client Key")
+    // StoredKey       := H(ClientKey)
+    // AuthMessage     := ClientFirstMessageBare + "," ServerFirstMessage + "," + ClientFinalMessageWithoutProof
+    // ClientSignature := HMAC(StoredKey, AuthMessage)
+    // ClientProof     := ClientKey XOR ClientSignature
+    // ServerKey       := HMAC(SaltedPassword, "Server Key")
+    // ServerSignature := HMAC(ServerKey, AuthMessage)
+    const saltedPassword = hi(definition, password, salt, iterations);
+    const clientKey = hmac(definition, saltedPassword, HMAC_CLIENT_KEY);
+    const storedKey = h(definition, clientKey);
+    const clientFinalMessageWithoutProof = `c=${GS2_HEADER_BASE64},r=${serverNonce}`;
+    const authMessage = `${clientFirstMessageBare},${serverFirstMessage},${clientFinalMessageWithoutProof}`;
+    const clientSignature = hmac(definition, storedKey, authMessage);
+    const clientProof = xor(clientKey, clientSignature);
+    const serverKey = hmac(definition, saltedPassword, HMAC_SERVER_KEY);
+    const serverSignature = hmac(definition, serverKey, authMessage);
+    // Send the last message to the server
+    const lastResponse = await authenticateAPI.async(connection, Buffer.from(`${clientFinalMessageWithoutProof},p=${clientProof.toString('base64')}`));
+    const lastData = parseParameters(lastResponse.authBytes);
+    if (lastData.e) {
+        throw new AuthenticationError(lastData.e);
+    }
+    else if (lastData.v !== serverSignature.toString('base64')) {
+        throw new AuthenticationError('Invalid server signature.');
+    }
+    /* c8 ignore next 2 */
+    return lastResponse;
+}

package/dist/protocol/varint.d.ts

@@ -0,0 +1,12 @@
+export declare const MOST_SIGNIFICANT_BIT_FLAG = 128;
+export declare const MOST_SIGNIFICANT_BIT_FLAG_64 = 128n;
+export declare const LEAST_SIGNIFICANT_7_BITS = 127;
+export declare const LEAST_SIGNIFICANT_7_BITS_64 = 127n;
+export declare const BITS_8PLUS_MASK: number;
+export declare const BITS_8PLUS_MASK_64: bigint;
+export declare function intZigZagEncode(value: number): number;
+export declare function intZigZagDecode(value: number): number;
+export declare function int64ZigZagEncode(value: bigint): bigint;
+export declare function int64ZigZagDecode(value: bigint): bigint;
+export declare function sizeOfUnsignedVarInt(value: number): number;
+export declare function sizeOfUnsignedVarInt64(value: bigint): number;

package/dist/protocol/varint.js

@@ -0,0 +1,36 @@
+export const MOST_SIGNIFICANT_BIT_FLAG = 0x80; // 128 or 1000 0000
+export const MOST_SIGNIFICANT_BIT_FLAG_64 = 0x80n; // 128 or 1000 0000
+export const LEAST_SIGNIFICANT_7_BITS = 0x7f; // 127 or 0111 1111
+export const LEAST_SIGNIFICANT_7_BITS_64 = 0x7fn; // 127 or 0111 1111
+// This is used in varint to check if there are any other bits set after the first 7 bits,
+// which means it still needs more than a byte to represent the number in varint encoding
+export const BITS_8PLUS_MASK = 0xffffffff - 0x7f;
+export const BITS_8PLUS_MASK_64 = 0xffffffffn - 0x7fn;
+export function intZigZagEncode(value) {
+    return (value << 1) ^ (value >> 31);
+}
+export function intZigZagDecode(value) {
+    return (value >> 1) ^ -(value & 1);
+}
+export function int64ZigZagEncode(value) {
+    return (value << 1n) ^ (value >> 31n);
+}
+export function int64ZigZagDecode(value) {
+    return (value >> 1n) ^ -(value & 1n);
+}
+export function sizeOfUnsignedVarInt(value) {
+    let bytes = 1;
+    while ((value & BITS_8PLUS_MASK) !== 0) {
+        bytes++;
+        value >>>= 7;
+    }
+    return bytes;
+}
+export function sizeOfUnsignedVarInt64(value) {
+    let bytes = 1;
+    while ((value & BITS_8PLUS_MASK_64) !== 0n) {
+        bytes++;
+        value >>= 7n;
+    }
+    return bytes;
+}

package/dist/protocol/writer.d.ts

@@ -0,0 +1,48 @@
+import { type NullableString } from './definitions.ts';
+import { DynamicBuffer } from './dynamic-buffer.ts';
+export type ChildrenWriter = (w: Writer) => void;
+export type EntryWriter<InputType> = (writer: Writer, entry: InputType, index: number) => void;
+declare const instanceIdentifier: unique symbol;
+export declare class Writer {
+    #private;
+    context: Record<string, any>;
+    [instanceIdentifier]: boolean;
+    static isWriter(target: any): boolean;
+    static create(): Writer;
+    constructor(bl?: DynamicBuffer);
+    get buffer(): Buffer;
+    get buffers(): Buffer[];
+    get dynamicBuffer(): DynamicBuffer;
+    get length(): number;
+    inspect(): string;
+    append(buffer: Buffer): this;
+    prepend(buffer: Buffer): this;
+    appendFrom(buffer: Writer | DynamicBuffer): this;
+    prependFrom(buffer: Writer | DynamicBuffer): this;
+    appendUnsignedInt8(value: number, append?: boolean): this;
+    appendUnsignedInt16(value: number, append?: boolean): this;
+    appendUnsignedInt32(value: number, append?: boolean): this;
+    appendUnsignedInt64(value: bigint, append?: boolean): this;
+    appendUnsignedVarInt(value: number, append?: boolean): this;
+    appendUnsignedVarInt64(value: bigint, append?: boolean): this;
+    appendInt8(value: number, append?: boolean): this;
+    appendInt16(value: number, append?: boolean): this;
+    appendInt32(value: number, append?: boolean): this;
+    appendInt64(value: bigint, append?: boolean): this;
+    appendFloat64(value: number, append?: boolean): this;
+    appendVarInt(value: number, append?: boolean): this;
+    appendVarInt64(value: bigint, append?: boolean): this;
+    appendBoolean(value: boolean): this;
+    appendString(value: NullableString, compact?: boolean, encoding?: BufferEncoding): this;
+    appendUUID(value: NullableString): this;
+    appendBytes(value: Buffer | undefined | null, compact?: boolean): this;
+    appendVarIntBytes(value: Buffer | null | undefined): this;
+    appendArray<InputType>(value: InputType[] | null | undefined, entryWriter: EntryWriter<InputType>, compact?: boolean, appendTrailingTaggedFields?: boolean): this;
+    appendMap<Key, Value>(value: Map<Key, Value> | null | undefined, entryWriter: EntryWriter<[Key, Value]>, compact?: boolean, appendTrailingTaggedFields?: boolean): this;
+    appendVarIntArray<InputType>(value: InputType[] | null | undefined, entryWriter: EntryWriter<InputType>): this;
+    appendVarIntMap<Key, Value>(value: Map<Key, Value> | null | undefined, entryWriter: EntryWriter<[Key, Value]>): this;
+    appendTaggedFields(_?: any[]): this;
+    prependLength(): this;
+    prependVarIntLength(): this;
+}
+export {};

package/dist/protocol/writer.js

@@ -0,0 +1,223 @@
+import { humanize } from "../utils.js";
+import { EMPTY_UUID } from "./definitions.js";
+import { DynamicBuffer } from "./dynamic-buffer.js";
+const instanceIdentifier = Symbol('plt.kafka.writer.instanceIdentifier');
+export class Writer {
+    context;
+    #buffer;
+    [instanceIdentifier];
+    static isWriter(target) {
+        return target?.[instanceIdentifier] === true;
+    }
+    static create() {
+        return new Writer(new DynamicBuffer());
+    }
+    constructor(bl) {
+        this.#buffer = bl;
+        this.context = {};
+        this[instanceIdentifier] = true;
+    }
+    get buffer() {
+        return this.#buffer.buffer;
+    }
+    get buffers() {
+        return this.#buffer.buffers;
+    }
+    get dynamicBuffer() {
+        return this.#buffer;
+    }
+    get length() {
+        return this.#buffer.length;
+    }
+    inspect() {
+        return this.buffers.map((buffer, i) => humanize(`Buffer ${i}`, buffer)).join('\n');
+    }
+    append(buffer) {
+        this.#buffer.append(buffer);
+        return this;
+    }
+    prepend(buffer) {
+        this.#buffer.prepend(buffer);
+        return this;
+    }
+    appendFrom(buffer) {
+        this.#buffer.appendFrom(buffer?.dynamicBuffer ?? buffer);
+        return this;
+    }
+    prependFrom(buffer) {
+        this.#buffer.prependFrom(buffer?.dynamicBuffer ?? buffer);
+        return this;
+    }
+    appendUnsignedInt8(value, append = true) {
+        this.#buffer.writeUInt8(value, append);
+        return this;
+    }
+    appendUnsignedInt16(value, append = true) {
+        this.#buffer.writeUInt16BE(value, append);
+        return this;
+    }
+    appendUnsignedInt32(value, append = true) {
+        this.#buffer.writeUInt32BE(value, append);
+        return this;
+    }
+    appendUnsignedInt64(value, append = true) {
+        this.#buffer.writeBigUInt64BE(value, append);
+        return this;
+    }
+    appendUnsignedVarInt(value, append = true) {
+        this.#buffer.writeUnsignedVarInt(value, append);
+        return this;
+    }
+    appendUnsignedVarInt64(value, append = true) {
+        this.#buffer.writeUnsignedVarInt64(value, append);
+        return this;
+    }
+    appendInt8(value, append = true) {
+        this.#buffer.writeInt8(value, append);
+        return this;
+    }
+    appendInt16(value, append = true) {
+        this.#buffer.writeInt16BE(value, append);
+        return this;
+    }
+    appendInt32(value, append = true) {
+        this.#buffer.writeInt32BE(value, append);
+        return this;
+    }
+    appendInt64(value, append = true) {
+        this.#buffer.writeBigInt64BE(value, append);
+        return this;
+    }
+    // In Kafka float is actually a double
+    appendFloat64(value, append = true) {
+        this.#buffer.writeDoubleBE(value, append);
+        return this;
+    }
+    appendVarInt(value, append = true) {
+        this.#buffer.writeVarInt(value, append);
+        return this;
+    }
+    appendVarInt64(value, append = true) {
+        this.#buffer.writeVarInt64(value, append);
+        return this;
+    }
+    appendBoolean(value) {
+        return this.appendUnsignedInt8(value ? 1 : 0);
+    }
+    appendString(value, compact = true, encoding = 'utf-8') {
+        if (value == null) {
+            return compact ? this.appendUnsignedVarInt(0) : this.appendInt16(-1);
+        }
+        const buffer = Buffer.from(value, encoding);
+        if (compact) {
+            this.appendUnsignedVarInt(buffer.length + 1);
+        }
+        else {
+            this.appendInt16(buffer.length);
+        }
+        if (buffer.length) {
+            this.#buffer.append(buffer);
+        }
+        return this;
+    }
+    appendUUID(value) {
+        if (value == null) {
+            return this.append(EMPTY_UUID);
+        }
+        const buffer = Buffer.from(value.replaceAll('-', ''), 'hex');
+        this.#buffer.append(buffer);
+        return this;
+    }
+    appendBytes(value, compact = true) {
+        if (value == null) {
+            return compact ? this.appendUnsignedVarInt(0) : this.appendInt32(-1);
+        }
+        if (compact) {
+            this.appendUnsignedVarInt(value.length + 1);
+        }
+        else {
+            this.appendInt32(value.length);
+        }
+        this.#buffer.append(value);
+        return this;
+    }
+    // Note that this does not follow the wire protocol specification and thus the length is not +1ed
+    appendVarIntBytes(value) {
+        if (value == null) {
+            return this.appendVarInt(0);
+        }
+        this.appendVarInt(value.length);
+        this.#buffer.append(value);
+        return this;
+    }
+    appendArray(value, entryWriter, compact = true, appendTrailingTaggedFields = true) {
+        if (value == null) {
+            return compact ? this.appendUnsignedVarInt(0) : this.appendInt32(0);
+        }
+        const length = value.length;
+        if (compact) {
+            this.appendUnsignedVarInt(length + 1);
+        }
+        else {
+            this.appendInt32(length);
+        }
+        for (let i = 0; i < length; i++) {
+            entryWriter(this, value[i], i);
+            if (appendTrailingTaggedFields) {
+                this.appendTaggedFields();
+            }
+        }
+        return this;
+    }
+    appendMap(value, entryWriter, compact = true, appendTrailingTaggedFields = true) {
+        if (value == null) {
+            return compact ? this.appendUnsignedVarInt(0) : this.appendInt32(0);
+        }
+        const length = value.size;
+        if (compact) {
+            this.appendUnsignedVarInt(length + 1);
+        }
+        else {
+            this.appendInt32(length);
+        }
+        let i = 0;
+        for (const entry of value) {
+            entryWriter(this, entry, i++);
+            if (appendTrailingTaggedFields) {
+                this.appendTaggedFields();
+            }
+        }
+        return this;
+    }
+    appendVarIntArray(value, entryWriter) {
+        if (value == null) {
+            return this.appendVarInt(0);
+        }
+        this.appendVarInt(value.length);
+        for (let i = 0; i < value.length; i++) {
+            entryWriter(this, value[i], i);
+        }
+        return this;
+    }
+    appendVarIntMap(value, entryWriter) {
+        if (value == null) {
+            return this.appendVarInt(0);
+        }
+        this.appendVarInt(value.size);
+        let i = 0;
+        for (const entry of value) {
+            entryWriter(this, entry, i++);
+        }
+        return this;
+    }
+    // TODO(ShogunPanda): Tagged fields are not supported yet
+    appendTaggedFields(_ = []) {
+        return this.appendInt8(0);
+    }
+    prependLength() {
+        return this.appendInt32(this.length, false);
+    }
+    prependVarIntLength() {
+        return this.appendVarInt(this.length, false);
+    }
+}

package/dist/utils.d.ts

@@ -0,0 +1,20 @@
+import { Ajv } from 'ajv';
+import debug from 'debug';
+import { type DynamicBuffer } from './protocol/dynamic-buffer.ts';
+export type DebugDumpLogger = (...args: any[]) => void;
+export { setTimeout as sleep } from 'node:timers/promises';
+export declare const ajv: Ajv;
+export declare const loggers: Record<string, debug.Debugger>;
+export declare class NumericMap extends Map<string, number> {
+    getWithDefault(key: string, fallback: number): number;
+    preIncrement(key: string, value: number, fallback: number): number;
+    postIncrement(key: string, value: number, fallback: number): number;
+}
+export declare function niceJoin(array: string[], lastSeparator?: string, separator?: string): string;
+export declare function listErrorMessage(type: string[]): string;
+export declare function enumErrorMessage(type: Record<string, unknown>, keysOnly?: boolean): string;
+export declare function groupByProperty<Key, Value>(entries: Value[], property: keyof Value): [Key, Value[]][];
+export declare function humanize(label: string, buffer: Buffer | DynamicBuffer): string;
+export declare function setDebugDumpLogger(logger: DebugDumpLogger): void;
+export declare function debugDump(...values: unknown[]): void;
+export declare function executeWithTimeout<T = unknown>(promise: Promise<T>, timeout: number, timeoutValue?: string): Promise<T | string>;

package/dist/utils.js

@@ -0,0 +1,127 @@
+import { Unpromise } from '@watchable/unpromise';
+import { Ajv } from 'ajv';
+import ajvErrors from 'ajv-errors';
+import { setTimeout as sleep } from 'node:timers/promises';
+import { inspect } from 'node:util';
+import debug from 'debug';
+export { setTimeout as sleep } from 'node:timers/promises';
+export const ajv = new Ajv({ allErrors: true, coerceTypes: false, strict: true });
+export const loggers = {
+    protocol: debug('plt:kafka:protocol'),
+    client: debug('plt:kafka:client'),
+    producer: debug('plt:kafka:producer'),
+    consumer: debug('plt:kafka:consumer'),
+    'consumer:heartbeat': debug('plt:kafka:consumer:heartbeat'),
+    admin: debug('plt:kafka:admin')
+};
+// @ts-ignore
+ajvErrors(ajv);
+let debugDumpLogger = console.error;
+ajv.addKeyword({
+    keyword: 'bigint',
+    validate(_, x) {
+        return typeof x === 'bigint';
+    },
+    error: {
+        message: 'must be bigint'
+    }
+});
+ajv.addKeyword({
+    keyword: 'map',
+    validate(_, x) {
+        return x instanceof Map;
+    },
+    error: {
+        message: 'must be Map'
+    }
+});
+ajv.addKeyword({
+    keyword: 'function',
+    validate(_, x) {
+        return typeof x === 'function';
+    },
+    error: {
+        message: 'must be function'
+    }
+});
+ajv.addKeyword({
+    keyword: 'buffer',
+    validate(_, x) {
+        return Buffer.isBuffer(x);
+    },
+    error: {
+        message: 'must be Buffer'
+    }
+});
+export class NumericMap extends Map {
+    getWithDefault(key, fallback) {
+        return this.get(key) ?? fallback;
+    }
+    preIncrement(key, value, fallback) {
+        let existing = this.getWithDefault(key, fallback);
+        existing += value;
+        this.set(key, existing);
+        return existing;
+    }
+    postIncrement(key, value, fallback) {
+        const existing = this.getWithDefault(key, fallback);
+        this.set(key, existing + value);
+        return existing;
+    }
+}
+export function niceJoin(array, lastSeparator = ' and ', separator = ', ') {
+    switch (array.length) {
+        case 0:
+            return '';
+        case 1:
+            return array[0];
+        case 2:
+            return array.join(lastSeparator);
+        default:
+            return array.slice(0, -1).join(separator) + lastSeparator + array.at(-1);
+    }
+}
+export function listErrorMessage(type) {
+    return `should be one of ${niceJoin(type, ' or ')}`;
+}
+export function enumErrorMessage(type, keysOnly = false) {
+    if (keysOnly) {
+        return `should be one of ${niceJoin(Object.keys(type), ' or ')}`;
+    }
+    return `should be one of ${niceJoin(Object.entries(type).map(([k, v]) => `${v} (${k})`), ' or ')}`;
+}
+export function groupByProperty(entries, property) {
+    const grouped = new Map();
+    const result = [];
+    for (const entry of entries) {
+        const value = entry[property];
+        let values = grouped.get(value);
+        if (!values) {
+            values = [];
+            grouped.set(value, values);
+            result.push([value, values]);
+        }
+        values.push(entry);
+    }
+    return result;
+}
+export function humanize(label, buffer) {
+    const formatted = buffer
+        .toString('hex')
+        .replaceAll(/(.{4})/g, '$1 ')
+        .trim();
+    return `${label} (${buffer.length} bytes): ${formatted}`;
+}
+export function setDebugDumpLogger(logger) {
+    debugDumpLogger = logger;
+}
+export function debugDump(...values) {
+    debugDumpLogger(new Date().toISOString(), ...values.map(v => (typeof v === 'string' ? v : inspect(v, false, 10))));
+}
+export async function executeWithTimeout(promise, timeout, timeoutValue = 'timeout') {
+    const ac = new AbortController();
+    return Unpromise.race([promise, sleep(timeout, timeoutValue, { signal: ac.signal, ref: false })]).then((value) => {
+        ac.abort();
+        return value;
+    });
+}