@platformatic/kafka 1.12.0 → 1.14.0

package/dist/apis/enumerations.d.ts

@@ -1,5 +1,12 @@
-export declare const SASLMechanisms: readonly ["PLAIN", "SCRAM-SHA-256", "SCRAM-SHA-512", "OAUTHBEARER"];
-export type SASLMechanism = (typeof SASLMechanisms)[number];
+export declare const SASLMechanisms: {
+    readonly PLAIN: "PLAIN";
+    readonly SCRAM_SHA_256: "SCRAM-SHA-256";
+    readonly SCRAM_SHA_512: "SCRAM-SHA-512";
+    readonly OAUTHBEARER: "OAUTHBEARER";
+};
+export declare const allowedSASLMechanisms: SASLMechanismValue[];
+export type SASLMechanism = keyof typeof SASLMechanisms;
+export type SASLMechanismValue = (typeof SASLMechanisms)[keyof typeof SASLMechanisms];
 export declare const FindCoordinatorKeyTypes: {
     readonly GROUP: 0;
     readonly TRANSACTION: 1;
@@ -11,11 +18,13 @@ export declare const ProduceAcks: {
     readonly NO_RESPONSE: 0;
     readonly LEADER: 1;
 };
+export declare const allowedProduceAcks: number[];
 export type ProduceAck = keyof typeof ProduceAcks;
 export declare const FetchIsolationLevels: {
     READ_UNCOMMITTED: number;
     READ_COMMITTED: number;
 };
+export declare const allowedFetchIsolationLevels: number[];
 export type FetchIsolationLevel = keyof typeof FetchIsolationLevels;
 export declare const ListOffsetTimestamps: {
     LATEST: bigint;

package/dist/apis/enumerations.js

@@ -1,5 +1,11 @@
 // SASL Authentication
-export const SASLMechanisms = ['PLAIN', 'SCRAM-SHA-256', 'SCRAM-SHA-512', 'OAUTHBEARER'];
+export const SASLMechanisms = {
+    PLAIN: 'PLAIN',
+    SCRAM_SHA_256: 'SCRAM-SHA-256',
+    SCRAM_SHA_512: 'SCRAM-SHA-512',
+    OAUTHBEARER: 'OAUTHBEARER'
+};
+export const allowedSASLMechanisms = Object.values(SASLMechanisms);
 // Metadata API
 // ./metadata/find-coordinator.ts
 export const FindCoordinatorKeyTypes = { GROUP: 0, TRANSACTION: 1, SHARE: 2 };
@@ -9,9 +15,11 @@ export const ProduceAcks = {
     NO_RESPONSE: 0,
     LEADER: 1
 };
+export const allowedProduceAcks = Object.values(ProduceAcks);
 // Consumer API
 // ./consumer/fetch.ts
 export const FetchIsolationLevels = { READ_UNCOMMITTED: 0, READ_COMMITTED: 1 };
+export const allowedFetchIsolationLevels = Object.values(FetchIsolationLevels);
 export const ListOffsetTimestamps = { LATEST: -1n, EARLIEST: -2n };
 // Admin API
 // ./admin/*-acls.ts - See: https://cwiki.apache.org/confluence/display/KAFKA/KIP-140%3A+Add+administrative+RPCs+for+adding%2C+deleting%2C+and+listing+ACLs

package/dist/clients/base/options.d.ts

@@ -88,7 +88,7 @@ export declare const baseOptionsSchema: {
             properties: {
                 mechanism: {
                     type: string;
-                    enum: readonly ["PLAIN", "SCRAM-SHA-256", "SCRAM-SHA-512", "OAUTHBEARER"];
+                    enum: import("../../apis/enumerations.ts").SASLMechanismValue[];
                 };
                 username: {
                     oneOf: ({
@@ -117,6 +117,9 @@ export declare const baseOptionsSchema: {
                         type?: undefined;
                     })[];
                 };
+                authBytesValidator: {
+                    function: boolean;
+                };
             };
             required: string[];
             additionalProperties: boolean;

package/dist/clients/base/options.js

@@ -1,4 +1,4 @@
-import { SASLMechanisms } from "../../apis/enumerations.js";
+import { allowedSASLMechanisms } from "../../apis/enumerations.js";
 import { ajv } from "../../utils.js";
 import { version } from "../../version.js";
 // Note: clientSoftwareName can only contain alphanumeric characters, hyphens and dots
@@ -36,10 +36,11 @@ export const baseOptionsSchema = {
         sasl: {
             type: 'object',
             properties: {
-                mechanism: { type: 'string', enum: SASLMechanisms },
+                mechanism: { type: 'string', enum: allowedSASLMechanisms },
                 username: { oneOf: [{ type: 'string' }, { function: true }] },
                 password: { oneOf: [{ type: 'string' }, { function: true }] },
-                token: { oneOf: [{ type: 'string' }, { function: true }] }
+                token: { oneOf: [{ type: 'string' }, { function: true }] },
+                authBytesValidator: { function: true }
             },
             required: ['mechanism'],
             additionalProperties: false

package/dist/clients/consumer/messages-stream.js

@@ -39,7 +39,9 @@ export class MessagesStream extends Readable {
     #metricsConsumedMessages;
     #corruptedMessageHandler;
     constructor(consumer, options) {
-        const { autocommit, mode, fallbackMode, maxFetches, offsets, deserializers, onCorruptedMessage, ...otherOptions } = options;
+        const { autocommit, mode, fallbackMode, maxFetches, offsets, deserializers, onCorruptedMessage, 
+        // The options below are only destructured to avoid being part of structuredClone below
+        partitionAssigner: _partitionAssigner, ...otherOptions } = options;
         if (offsets && mode !== MessagesStreamModes.MANUAL) {
             throw new UserError('Cannot specify offsets when the stream mode is not MANUAL.');
         }

package/dist/clients/consumer/options.d.ts

@@ -93,7 +93,7 @@ export declare const consumeOptionsProperties: {
     };
     isolationLevel: {
         type: string;
-        enum: string[];
+        enum: number[];
     };
     deserializers: {
         type: string;
@@ -196,7 +196,7 @@ export declare const consumeOptionsSchema: {
         };
         isolationLevel: {
             type: string;
-            enum: string[];
+            enum: number[];
         };
         deserializers: {
             type: string;
@@ -275,11 +275,11 @@ export declare const consumeOptionsSchema: {
         };
         mode: {
             type: string;
-            enum: ("latest" | "earliest" | "committed" | "manual")[];
+            enum: import("./types.ts").MessagesStreamModeValue[];
         };
         fallbackMode: {
             type: string;
-            enum: ("latest" | "earliest" | "fail")[];
+            enum: import("./types.ts").MessagesStreamFallbackModeValue[];
         };
         maxFetches: {
             type: string;
@@ -340,7 +340,7 @@ export declare const consumerOptionsSchema: {
         };
         isolationLevel: {
             type: string;
-            enum: string[];
+            enum: number[];
         };
         deserializers: {
             type: string;
@@ -444,7 +444,7 @@ export declare const fetchOptionsSchema: {
         };
         isolationLevel: {
             type: string;
-            enum: string[];
+            enum: number[];
         };
         deserializers: {
             type: string;
@@ -639,7 +639,7 @@ export declare const listOffsetsOptionsSchema: {
         };
         isolationLevel: {
             type: string;
-            enum: string[];
+            enum: number[];
         };
         timestamp: {
             bigint: boolean;

package/dist/clients/consumer/options.js

@@ -1,8 +1,8 @@
-import { FetchIsolationLevels } from "../../apis/enumerations.js";
+import { allowedFetchIsolationLevels } from "../../apis/enumerations.js";
 import { ajv } from "../../utils.js";
 import { idProperty, topicWithPartitionAndOffsetProperties } from "../base/options.js";
 import { serdeProperties } from "../serde.js";
-import { MessagesStreamFallbackModes, MessagesStreamModes } from "./types.js";
+import { allowedMessagesStreamFallbackModes, allowedMessagesStreamModes } from "./types.js";
 export const groupOptionsProperties = {
     sessionTimeout: { type: 'number', minimum: 0 },
     rebalanceTimeout: { type: 'number', minimum: 0 },
@@ -56,7 +56,7 @@ export const consumeOptionsProperties = {
     minBytes: { type: 'number', minimum: 0 },
     maxBytes: { type: 'number', minimum: 0 },
     maxWaitTime: { type: 'number', minimum: 0 },
-    isolationLevel: { type: 'string', enum: Object.keys(FetchIsolationLevels) },
+    isolationLevel: { type: 'string', enum: allowedFetchIsolationLevels },
     deserializers: serdeProperties,
     highWaterMark: { type: 'number', minimum: 1 }
 };
@@ -69,8 +69,8 @@ export const consumeOptionsSchema = {
     type: 'object',
     properties: {
         topics: { type: 'array', items: idProperty },
-        mode: { type: 'string', enum: Object.values(MessagesStreamModes) },
-        fallbackMode: { type: 'string', enum: Object.values(MessagesStreamFallbackModes) },
+        mode: { type: 'string', enum: allowedMessagesStreamModes },
+        fallbackMode: { type: 'string', enum: allowedMessagesStreamFallbackModes },
         maxFetches: { type: 'number', minimum: 0, default: 0 },
         offsets: {
             type: 'array',
@@ -187,7 +187,7 @@ export const listOffsetsOptionsSchema = {
                 items: { type: 'number', minimum: 0 }
             }
         },
-        isolationLevel: { type: 'string', enum: Object.keys(FetchIsolationLevels) },
+        isolationLevel: { type: 'string', enum: allowedFetchIsolationLevels },
         timestamp: { bigint: true }
     },
     required: ['topics'],

package/dist/clients/consumer/types.d.ts

@@ -33,6 +33,7 @@ export declare const MessagesStreamModes: {
     readonly COMMITTED: "committed";
     readonly MANUAL: "manual";
 };
+export declare const allowedMessagesStreamModes: MessagesStreamModeValue[];
 export type MessagesStreamMode = keyof typeof MessagesStreamModes;
 export type MessagesStreamModeValue = (typeof MessagesStreamModes)[keyof typeof MessagesStreamModes];
 export declare const MessagesStreamFallbackModes: {
@@ -40,6 +41,7 @@ export declare const MessagesStreamFallbackModes: {
     readonly EARLIEST: "earliest";
     readonly FAIL: "fail";
 };
+export declare const allowedMessagesStreamFallbackModes: MessagesStreamFallbackModeValue[];
 export type MessagesStreamFallbackMode = keyof typeof MessagesStreamFallbackModes;
 export type MessagesStreamFallbackModeValue = (typeof MessagesStreamFallbackModes)[keyof typeof MessagesStreamFallbackModes];
 export interface GroupOptions {

package/dist/clients/consumer/types.js

@@ -4,8 +4,10 @@ export const MessagesStreamModes = {
     COMMITTED: 'committed',
     MANUAL: 'manual'
 };
+export const allowedMessagesStreamModes = Object.values(MessagesStreamModes);
 export const MessagesStreamFallbackModes = {
     LATEST: 'latest',
     EARLIEST: 'earliest',
     FAIL: 'fail'
 };
+export const allowedMessagesStreamFallbackModes = Object.values(MessagesStreamFallbackModes);

package/dist/clients/producer/options.d.ts

@@ -11,14 +11,14 @@ export declare const produceOptionsProperties: {
     acks: {
         type: string;
         enumeration: {
-            allowed: (0 | 1 | -1)[];
+            allowed: number[];
             errorMessage: string;
         };
     };
     compression: {
         type: string;
         enumeration: {
-            allowed: string[];
+            allowed: import("../../protocol/compression.ts").CompressionAlgorithmValue[];
             errorMessage: string;
         };
     };
@@ -47,14 +47,14 @@ export declare const produceOptionsSchema: {
         acks: {
             type: string;
             enumeration: {
-                allowed: (0 | 1 | -1)[];
+                allowed: number[];
                 errorMessage: string;
             };
         };
         compression: {
             type: string;
             enumeration: {
-                allowed: string[];
+                allowed: import("../../protocol/compression.ts").CompressionAlgorithmValue[];
                 errorMessage: string;
             };
         };
@@ -87,14 +87,14 @@ export declare const sendOptionsSchema: {
         acks: {
             type: string;
             enumeration: {
-                allowed: (0 | 1 | -1)[];
+                allowed: number[];
                 errorMessage: string;
             };
         };
         compression: {
             type: string;
             enumeration: {
-                allowed: string[];
+                allowed: import("../../protocol/compression.ts").CompressionAlgorithmValue[];
                 errorMessage: string;
             };
         };

package/dist/clients/producer/options.js

@@ -1,5 +1,5 @@
-import { ProduceAcks } from "../../apis/enumerations.js";
-import { compressionsAlgorithms } from "../../protocol/compression.js";
+import { allowedProduceAcks, ProduceAcks } from "../../apis/enumerations.js";
+import { allowedCompressionsAlgorithms, compressionsAlgorithms } from "../../protocol/compression.js";
 import { messageSchema } from "../../protocol/records.js";
 import { ajv, enumErrorMessage } from "../../utils.js";
 import { serdeProperties } from "../serde.js";
@@ -10,15 +10,15 @@ export const produceOptionsProperties = {
     acks: {
         type: 'number',
         enumeration: {
-            allowed: Object.values(ProduceAcks),
+            allowed: allowedProduceAcks,
             errorMessage: enumErrorMessage(ProduceAcks)
         }
     },
     compression: {
         type: 'string',
         enumeration: {
-            allowed: Object.keys(compressionsAlgorithms),
-            errorMessage: enumErrorMessage(compressionsAlgorithms, true)
+            allowed: allowedCompressionsAlgorithms,
+            errorMessage: enumErrorMessage(compressionsAlgorithms)
         }
     },
     partitioner: { function: true },

package/dist/clients/producer/types.d.ts

@@ -1,4 +1,4 @@
-import { type CompressionAlgorithms } from '../../protocol/compression.ts';
+import { type CompressionAlgorithmValue } from '../../protocol/compression.ts';
 import { type MessageToProduce } from '../../protocol/records.ts';
 import { type BaseOptions, type TopicWithPartitionAndOffset } from '../base/types.ts';
 import { type Serializers } from '../serde.ts';
@@ -16,7 +16,7 @@ export interface ProduceOptions<Key, Value, HeaderKey, HeaderValue> {
     producerEpoch?: number;
     idempotent?: boolean;
     acks?: number;
-    compression?: CompressionAlgorithms;
+    compression?: CompressionAlgorithmValue;
     partitioner?: Partitioner<Key, Value, HeaderKey, HeaderValue>;
     autocreateTopics?: boolean;
     repeatOnStaleMetadata?: boolean;

package/dist/network/connection.d.ts

@@ -3,7 +3,7 @@ import { type Socket } from 'node:net';
 import { type ConnectionOptions as TLSConnectionOptions } from 'node:tls';
 import { type CallbackWithPromise } from '../apis/callbacks.ts';
 import { type Callback, type ResponseParser } from '../apis/definitions.ts';
-import { type SASLMechanism } from '../apis/enumerations.ts';
+import { type SASLMechanismValue } from '../apis/enumerations.ts';
 import { Writer } from '../protocol/writer.ts';
 export type SASLCredentialProvider = () => string | Promise<string>;
 export interface Broker {
@@ -11,10 +11,11 @@ export interface Broker {
     port: number;
 }
 export interface SASLOptions {
-    mechanism: SASLMechanism;
+    mechanism: SASLMechanismValue;
     username?: string | SASLCredentialProvider;
     password?: string | SASLCredentialProvider;
     token?: string | SASLCredentialProvider;
+    authBytesValidator?: (authBytes: Buffer, callback: CallbackWithPromise<Buffer>) => void;
 }
 export interface ConnectionOptions {
     connectTimeout?: number;

package/dist/network/connection.js

@@ -3,7 +3,7 @@ import EventEmitter from 'node:events';
 import { createConnection } from 'node:net';
 import { connect as createTLSConnection } from 'node:tls';
 import { createPromisifiedCallback, kCallbackPromise } from "../apis/callbacks.js";
-import { SASLMechanisms } from "../apis/enumerations.js";
+import { allowedSASLMechanisms, SASLMechanisms } from "../apis/enumerations.js";
 import { saslAuthenticateV2, saslHandshakeV1 } from "../apis/index.js";
 import { connectionsApiChannel, connectionsConnectsChannel, createDiagnosticContext, notifyCreation } from "../diagnostic.js";
 import { AuthenticationError, NetworkError, TimeoutError, UnexpectedCorrelationIdError, UserError } from "../errors.js";
@@ -237,7 +237,7 @@ export class Connection extends EventEmitter {
             this.#status = ConnectionStatuses.AUTHENTICATING;
         }
         const { mechanism, username, password, token } = this.#options.sasl;
-        if (!SASLMechanisms.includes(mechanism)) {
+        if (!allowedSASLMechanisms.includes(mechanism)) {
             this.#onConnectionError(host, port, diagnosticContext, new UserError(`SASL mechanism ${mechanism} not supported.`));
             return;
         }
@@ -248,10 +248,10 @@ export class Connection extends EventEmitter {
             }
             this.emit('sasl:handshake', response.mechanisms);
             const callback = this.#onSaslAuthenticate.bind(this, host, port, diagnosticContext);
-            if (mechanism === 'PLAIN') {
+            if (mechanism === SASLMechanisms.PLAIN) {
                 saslPlain.authenticate(saslAuthenticateV2.api, this, username, password, callback);
             }
-            else if (mechanism === 'OAUTHBEARER') {
+            else if (mechanism === SASLMechanisms.OAUTHBEARER) {
                 saslOAuthBearer.authenticate(saslAuthenticateV2.api, this, token, callback);
             }
             else {
@@ -336,7 +336,19 @@ export class Connection extends EventEmitter {
             this.#onConnectionError(host, port, diagnosticContext, error);
             return;
         }
-        if (response.sessionLifetimeMs > 0) {
+        if (this.#options.sasl.authBytesValidator) {
+            this.#options.sasl.authBytesValidator(response.authBytes, this.#onSaslAuthenticationValidation.bind(this, host, port, diagnosticContext, response.sessionLifetimeMs));
+        }
+        else {
+            this.#onSaslAuthenticationValidation(host, port, diagnosticContext, response.sessionLifetimeMs, null, response.authBytes);
+        }
+    }
+    #onSaslAuthenticationValidation(host, port, diagnosticContext, sessionLifetimeMs, error, authBytes) {
+        if (error) {
+            this.#onConnectionError(host, port, diagnosticContext, new AuthenticationError('SASL authentication failed.', { cause: error }));
+            return;
+        }
+        if (sessionLifetimeMs > 0) {
             this.#reauthenticationTimeout = setTimeout(() => {
                 const diagnosticContext = createDiagnosticContext({
                     connection: this,
@@ -345,13 +357,13 @@ export class Connection extends EventEmitter {
                     port
                 });
                 this.#authenticate(host, port, diagnosticContext);
-            }, Number(response.sessionLifetimeMs) * 0.8);
+            }, Number(sessionLifetimeMs) * 0.8);
         }
         if (this.#status === ConnectionStatuses.CONNECTED) {
-            this.emit('sasl:authentication:extended', response.authBytes);
+            this.emit('sasl:authentication:extended', authBytes);
         }
         else {
-            this.emit('sasl:authentication', response.authBytes);
+            this.emit('sasl:authentication', authBytes);
             this.#onConnectionSucceed(diagnosticContext);
         }
     }

package/dist/protocol/compression.d.ts

@@ -1,12 +1,22 @@
 import { DynamicBuffer } from './dynamic-buffer.ts';
 export type SyncCompressionPhase = (data: Buffer | DynamicBuffer) => Buffer;
 export type CompressionOperation = (data: Buffer) => Buffer;
-export interface CompressionAlgorithm {
+export interface CompressionAlgorithmSpecification {
     compressSync: SyncCompressionPhase;
     decompressSync: SyncCompressionPhase;
     bitmask: number;
     available?: boolean;
 }
+export declare const CompressionAlgorithms: {
+    readonly NONE: "none";
+    readonly GZIP: "gzip";
+    readonly SNAPPY: "snappy";
+    readonly LZ4: "lz4";
+    readonly ZSTD: "zstd";
+};
+export declare const allowedCompressionsAlgorithms: CompressionAlgorithmValue[];
+export type CompressionAlgorithm = keyof typeof CompressionAlgorithms;
+export type CompressionAlgorithmValue = (typeof CompressionAlgorithms)[keyof typeof CompressionAlgorithms];
 export declare const compressionsAlgorithms: {
     readonly none: {
         readonly compressSync: (data: Buffer | DynamicBuffer) => Buffer;
@@ -67,4 +77,3 @@ export declare const compressionsAlgorithmsByBitmask: {
         readonly available: boolean;
     };
 };
-export type CompressionAlgorithms = keyof typeof compressionsAlgorithms;

package/dist/protocol/compression.js

@@ -4,6 +4,14 @@ import { UnsupportedCompressionError } from "../errors.js";
 import { DynamicBuffer } from "./dynamic-buffer.js";
 const require = createRequire(import.meta.url);
 const { zstdCompressSync, zstdDecompressSync, gzipSync, gunzipSync } = zlib;
+export const CompressionAlgorithms = {
+    NONE: 'none',
+    GZIP: 'gzip',
+    SNAPPY: 'snappy',
+    LZ4: 'lz4',
+    ZSTD: 'zstd'
+};
+export const allowedCompressionsAlgorithms = Object.values(CompressionAlgorithms);
 function ensureBuffer(data) {
     return DynamicBuffer.isDynamicBuffer(data) ? data.slice() : data;
 }

package/dist/protocol/records.d.ts

@@ -1,5 +1,5 @@
 import { type NumericMap } from '../utils.ts';
-import { type CompressionAlgorithms } from './compression.ts';
+import { type CompressionAlgorithmValue } from './compression.ts';
 import { type NullableString } from './definitions.ts';
 import { Reader } from './reader.ts';
 import { Writer } from './writer.ts';
@@ -28,7 +28,7 @@ export interface MessageRecord {
 }
 export interface CreateRecordsBatchOptions {
     transactionalId?: NullableString;
-    compression: CompressionAlgorithms;
+    compression: CompressionAlgorithmValue;
     firstSequence?: number;
     producerId: bigint;
     producerEpoch: number;

package/dist/protocol/records.js

@@ -140,6 +140,9 @@ export function readRecordsBatch(reader) {
             throw new UnsupportedCompressionError(`Unsupported compression algorithm with bitmask ${compression}`);
         }
         const buffer = algorithm.decompressSync(reader.buffer.slice(reader.position, reader.buffer.length));
+        // Move the original reader to the end
+        reader.skip(reader.buffer.length - reader.position);
+        // Replace the reader with the decompressed buffer
         reader = Reader.from(buffer);
     }
     for (let i = 0; i < recordsLength; i++) {

package/dist/protocol/sasl/oauth-bearer.d.ts

@@ -1,5 +1,6 @@
 import { type CallbackWithPromise } from '../../apis/callbacks.ts';
 import { type SASLAuthenticationAPI, type SaslAuthenticateResponse } from '../../apis/security/sasl-authenticate-v2.ts';
 import { type Connection, type SASLCredentialProvider } from '../../network/connection.ts';
+export declare function jwtValidateAuthenticationBytes(authBytes: Buffer, callback: CallbackWithPromise<Buffer>): void;
 export declare function authenticate(authenticateAPI: SASLAuthenticationAPI, connection: Connection, tokenOrProvider: string | SASLCredentialProvider, callback: CallbackWithPromise<SaslAuthenticateResponse>): void;
 export declare function authenticate(authenticateAPI: SASLAuthenticationAPI, connection: Connection, tokenOrProvider: string | SASLCredentialProvider): Promise<SaslAuthenticateResponse>;

package/dist/protocol/sasl/oauth-bearer.js

@@ -1,5 +1,23 @@
 import { createPromisifiedCallback, kCallbackPromise } from "../../apis/callbacks.js";
+import { AuthenticationError } from "../../errors.js";
 import { getCredential } from "./credential-provider.js";
+export function jwtValidateAuthenticationBytes(authBytes, callback) {
+    let authData = {};
+    try {
+        if (authBytes.length > 0) {
+            authData = JSON.parse(authBytes.toString('utf-8'));
+        }
+        /* c8 ignore next 8  - Hard to test */
+    }
+    catch (e) {
+        callback(new AuthenticationError('Invalid authBytes in SASL/OAUTHBEARER response', { authBytes }), undefined);
+        return;
+    }
+    if (authData.status === 'invalid_token') {
+        callback(new AuthenticationError('Invalid SASL/OAUTHBEARER token.', { authData }), undefined);
+    }
+    callback(null, authBytes);
+}
 export function authenticate(authenticateAPI, connection, tokenOrProvider, callback) {
     if (!callback) {
         callback = createPromisifiedCallback();

package/dist/version.js

@@ -1,2 +1,2 @@
 export const name = "@platformatic/kafka";
-export const version = "1.12.0";
+export const version = "1.14.0";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@platformatic/kafka",
-  "version": "1.12.0",
+  "version": "1.14.0",
   "description": "Modern and performant client for Apache Kafka",
   "homepage": "https://github.com/platformatic/kafka",
   "author": "Platformatic Inc. <oss@platformatic.dev> (https://platformatic.dev)",
@@ -69,12 +69,12 @@
     "lint": "eslint --cache",
     "typecheck": "tsc -p . --noEmit",
     "format": "prettier -w benchmarks playground src test",
-    "test": "c8 -c test/config/c8-local.json node --env-file=test/config/env --no-warnings --test --test-timeout=300000 'test/**/*.test.ts'",
-    "test:ci": "c8 -c test/config/c8-ci.json node --env-file=test/config/env --no-warnings --test --test-timeout=300000 'test/**/*.test.ts'",
+    "test": "c8 -c test/config/c8-local.json node --env-file=test/config/env --no-warnings --test --test-timeout=600000 'test/**/*.test.ts'",
+    "test:ci": "c8 -c test/config/c8-ci.json node --env-file=test/config/env --no-warnings --test --test-timeout=600000 'test/**/*.test.ts'",
     "test:docker:up": "node scripts/docker.ts up -d --wait",
     "test:docker:down": "node scripts/docker.ts down",
     "ci": "npm run build && npm run lint && npm run test:ci",
-    "ci:v20": "npm run lint && rm -rf dist && tsc -p tsconfig.json && node dist/scripts/postbuild.js && cd dist && c8 -c ../test/config/c8-ci.json node --env-file=../test/config/env --no-warnings --test --test-timeout=300000",
+    "ci:v20": "npm run lint && rm -rf dist && tsc -p tsconfig.json && node dist/scripts/postbuild.js && cd dist && c8 -c ../test/config/c8-ci.json node --env-file=../test/config/env --no-warnings --test --test-timeout=600000",
     "generate:apis": "node scripts/generate-apis.ts",
     "generate:errors": "node scripts/generate-errors.ts",
     "create:api": "node scripts/create-api.ts"