apache-iggy 0.9.0-edge.1 → 0.10.0-edge.1

package/README.md

@@ -32,18 +32,17 @@ npm i --save apache-iggy
 
 ### Response frame limit
 
-**Compatibility note:** response frames larger than `maxResponseFrameSize` (default 64 MiB) are now rejected and close the connection under both framing modes. This is a behavior change for existing classic-framing clients. Raise the limit in the client configuration when polling very large batches.
+**Compatibility note:** response frames larger than `maxResponseFrameSize` (default 64 MiB) are rejected and close the connection. Raise the limit in the client configuration when polling very large batches.
 
 ### VSR framing
 
-Classic framing remains the default. Select VSR explicitly when connecting to
-an Iggy VSR server:
+The SDK speaks the VSR wire protocol exclusively and requires an Iggy VSR
+server:
 
 ```typescript
 import { SimpleClient, getRawClient } from "apache-iggy";
 
 const config = {
-  protocol: "vsr" as const,
   transport: "TCP" as const,
   options: { host: "127.0.0.1", port: 8090 },
   credentials: { username: "iggy", password: "iggy" },
@@ -52,12 +51,18 @@ const client = new SimpleClient(getRawClient(config));
 const stats = await client.system.getStats();
 ```
 
-VSR is a runtime protocol choice in Node.js, not a build feature. Codes absent
-from the SDK command table use `Operation::NonReplicated` and carry the command
-code in the request header's reserved field. The server remains authoritative
-for classifying or rejecting extension commands.
+Codes absent from the SDK command table use `Operation::NonReplicated` and
+carry the command code in the request header's reserved field. The server
+remains authoritative for classifying or rejecting extension commands.
 
-The same npm package supports both framing modes over TCP and TLS. VSR restricts `Client` to one pooled connection because authentication, request sequencing, and consumer-group assignments belong to one consensus session. Configurations requesting more than one pooled connection fail before a socket is opened.
+Sends must use explicit `Partitioning.PartitionId` partitioning: the client
+routes each request to a partition-scoped namespace, so broker-side balancing
+(`Partitioning.Balanced`) and key hashing (`Partitioning.MessageKey`) are
+rejected before the request is sent.
+<!-- TODO(hubcio): Balanced and MessageKey partitioning to be implemented;
+not decided yet whether it'll be on server side or client side. -->
+
+VSR works over TCP and TLS. It restricts `Client` to one pooled connection because authentication, request sequencing, and consumer-group assignments belong to one consensus session. Configurations requesting more than one pooled connection fail before a socket is opened.
 
 VSR authentication translates the existing password and personal-access-token
 login APIs into the register handshake required by the consensus protocol. A
@@ -68,7 +73,7 @@ new session.
 
 When the server's `[heartbeat]` eviction is enabled, configure the client's `heartbeatInterval` below the server heartbeat interval. Client heartbeats are disabled when `heartbeatInterval` is unset.
 
-`sendBinaryRequest(code, payload)` has the same signature under classic and VSR framing. Known replicated commands use their registered operation, while unknown codes reach the server as non-replicated requests and are rejected by servers that do not register them. Classic request bytes remain unchanged.
+`sendBinaryRequest(code, payload)` sends an arbitrary command code. Known replicated commands use their registered operation, while unknown codes reach the server as non-replicated requests and are rejected by servers that do not register them.
 
 ```typescript
 import { ResponseError } from "apache-iggy";

package/dist/client/client.config.d.ts

@@ -1,6 +1,4 @@
-import type { ClientConfig, Protocol } from './client.type.js';
+import type { ClientConfig } from './client.type.js';
 export declare const DEFAULT_MAX_RESPONSE_FRAME_SIZE: number;
-export declare const normalizeClientConfig: (config: ClientConfig) => ClientConfig & {
-    protocol: Protocol;
-};
+export declare const normalizeClientConfig: (config: ClientConfig) => ClientConfig;
 //# sourceMappingURL=client.config.d.ts.map

package/dist/client/client.config.js

@@ -15,24 +15,18 @@
 // specific language governing permissions and limitations
 // under the License.
 export const DEFAULT_MAX_RESPONSE_FRAME_SIZE = 64 * 1024 * 1024;
-const isProtocol = (value) => value === 'classic' || value === 'vsr';
 export const normalizeClientConfig = (config) => {
-    const protocol = config.protocol ?? 'classic';
-    if (!isProtocol(protocol))
-        throw new TypeError(`unsupported wire protocol: ${String(protocol)}`);
     const maxResponseFrameSize = config.maxResponseFrameSize ?? DEFAULT_MAX_RESPONSE_FRAME_SIZE;
     if (!Number.isSafeInteger(maxResponseFrameSize) ||
         maxResponseFrameSize < 256)
         throw new TypeError('maxResponseFrameSize must be a safe integer of at least 256 bytes');
-    if (protocol === 'vsr' &&
-        ((config.poolSize?.min ?? 1) > 1 || (config.poolSize?.max ?? 1) > 1))
+    if ((config.poolSize?.min ?? 1) > 1 || (config.poolSize?.max ?? 1) > 1)
         throw new TypeError('VSR clients currently support exactly one pooled connection');
     return {
         ...config,
-        protocol,
         options: { ...config.options },
         maxResponseFrameSize,
-        ...(protocol === 'vsr' ? { poolSize: { min: 1, max: 1 } } : {})
+        poolSize: { min: 1, max: 1 }
     };
 };
 //# sourceMappingURL=client.config.js.map

package/dist/client/client.config.test.js

@@ -23,40 +23,23 @@ const config = () => ({
     credentials: { username: 'iggy', password: 'iggy' }
 });
 describe('normalizeClientConfig', () => {
-    it('defaults to classic without changing classic pool sizing', () => {
-        const normalized = normalizeClientConfig({
-            ...config(),
-            poolSize: { min: 2, max: 4 }
-        });
-        assert.equal(normalized.protocol, 'classic');
-        assert.deepEqual(normalized.poolSize, { min: 2, max: 4 });
+    it('applies the default response frame limit', () => {
+        const normalized = normalizeClientConfig(config());
         assert.equal(normalized.maxResponseFrameSize, DEFAULT_MAX_RESPONSE_FRAME_SIZE);
     });
-    it('restricts VSR to one pooled connection', () => {
-        const normalized = normalizeClientConfig({
-            ...config(),
-            protocol: 'vsr'
-        });
+    it('restricts the client to one pooled connection', () => {
+        const normalized = normalizeClientConfig(config());
         assert.deepEqual(normalized.poolSize, { min: 1, max: 1 });
         assert.throws(() => normalizeClientConfig({
             ...config(),
-            protocol: 'vsr',
             poolSize: { max: 2 }
         }), /exactly one pooled connection/);
     });
-    it('rejects invalid protocols before opening a socket', () => {
-        assert.throws(() => normalizeClientConfig({
-            ...config(),
-            protocol: 'auto'
-        }), /unsupported wire protocol/);
-    });
-    it('supports VSR over TLS', () => {
+    it('supports TLS transport', () => {
         const normalized = normalizeClientConfig({
             ...config(),
-            protocol: 'vsr',
             transport: 'TLS'
         });
-        assert.equal(normalized.protocol, 'vsr');
         assert.equal(normalized.transport, 'TLS');
         assert.deepEqual(normalized.poolSize, { min: 1, max: 1 });
     });

package/dist/client/client.connection.d.ts

@@ -79,14 +79,6 @@ export declare class IggyConnection extends EventEmitter {
      * @param data - Incoming data buffer
      */
     _onData(data: Buffer): void;
-    /**
-     * Writes a command to the socket.
-     *
-     * @param command - Command code
-     * @param payload - Command payload
-     * @returns True if the write was successful
-     */
-    writeCommand(command: number, payload: Buffer): void;
     writeFrame(frame: Buffer): void;
 }
 //# sourceMappingURL=client.connection.d.ts.map

package/dist/client/client.connection.js

@@ -18,7 +18,6 @@
 import { EventEmitter } from 'node:events';
 import { createConnection } from 'node:net';
 import { connect as TLSConnect } from 'node:tls';
-import { serializeCommand } from './client.utils.js';
 import { debug } from './client.debug.js';
 import { DEFAULT_MAX_RESPONSE_FRAME_SIZE } from './client.config.js';
 import { ProtocolFrameError, ResponseFrameDecoder } from './client.frame.js';
@@ -121,7 +120,7 @@ export class IggyConnection extends EventEmitter {
         this.reconnectCount = 0;
         this.connectPromise = undefined;
         this.reconnectPromise = undefined;
-        this.responseDecoder = new ResponseFrameDecoder(config.protocol ?? 'classic', config.maxResponseFrameSize ?? DEFAULT_MAX_RESPONSE_FRAME_SIZE);
+        this.responseDecoder = new ResponseFrameDecoder(config.maxResponseFrameSize ?? DEFAULT_MAX_RESPONSE_FRAME_SIZE);
         this.socket = this._installSocket(getTransport(config));
     }
     /**
@@ -361,8 +360,7 @@ export class IggyConnection extends EventEmitter {
         debug('ONDATA', typeof data, Buffer.isBuffer(data), data?.length, this.responseDecoder.hasBufferedData);
         try {
             for (const response of this.responseDecoder.push(data)) {
-                if (this.config.protocol === 'vsr' &&
-                    peekCommand(response) === Command2.Eviction)
+                if (peekCommand(response) === Command2.Eviction)
                     this.emit('eviction', evictionError(response));
                 else
                     this.emit('response', response);
@@ -374,17 +372,6 @@ export class IggyConnection extends EventEmitter {
             this.socket.destroy();
         }
     }
-    /**
-     * Writes a command to the socket.
-     *
-     * @param command - Command code
-     * @param payload - Command payload
-     * @returns True if the write was successful
-     */
-    writeCommand(command, payload) {
-        const cmd = serializeCommand(command, payload);
-        this.socket.write(cmd);
-    }
     writeFrame(frame) {
         this.socket.write(frame);
     }

package/dist/client/client.connection.test.js

@@ -21,6 +21,8 @@ import { createServer, } from 'node:net';
 import { describe, it } from 'node:test';
 import { ProtocolFrameError } from './client.frame.js';
 import { IggyConnection } from './client.connection.js';
+import { Command2, HEADER_SIZE, REPLY_OFFSET } from '../wire/vsr/header.js';
+const FRAME_LIMIT = 2 * HEADER_SIZE;
 const startServer = async () => {
     const server = createServer();
     server.listen(0, '127.0.0.1');
@@ -28,7 +30,6 @@ const startServer = async () => {
     return server;
 };
 const connectionConfig = (server) => ({
-    protocol: 'classic',
     transport: 'TCP',
     options: {
         host: '127.0.0.1',
@@ -36,8 +37,15 @@ const connectionConfig = (server) => ({
     },
     credentials: { username: 'iggy', password: 'iggy' },
     reconnect: { enabled: false, interval: 0, maxRetries: 0 },
-    maxResponseFrameSize: 256
+    maxResponseFrameSize: FRAME_LIMIT
 });
+const replyFrame = (body) => {
+    const frame = Buffer.alloc(HEADER_SIZE + body.length);
+    frame.writeUInt32LE(frame.length, REPLY_OFFSET.size);
+    frame.writeUInt8(Command2.Reply, REPLY_OFFSET.command);
+    body.copy(frame, HEADER_SIZE);
+    return frame;
+};
 const closeConnection = async (connection, server) => {
     connection._destroy();
     if (!connection.socket.destroyed)
@@ -59,7 +67,7 @@ describe('IggyConnection', () => {
             await closeConnection(connection, server);
         }
     });
-    it('shares connection attempts, recognizes endpoints, and writes commands', async () => {
+    it('shares connection attempts, recognizes endpoints, and writes frames', async () => {
         const server = await startServer();
         const received = new Promise((resolve) => {
             server.once('connection', (socket) => {
@@ -78,10 +86,9 @@ describe('IggyConnection', () => {
                 host: 'broker.example'
             };
             assert.equal(connection.isConnectedTo('broker.example', server.address().port), true);
-            connection.writeCommand(1, Buffer.from('payload'));
-            const command = await received;
-            assert.equal(command.readUInt32LE(4), 1);
-            assert.deepEqual(command.subarray(8), Buffer.from('payload'));
+            const frame = replyFrame(Buffer.from('payload'));
+            connection.writeFrame(frame);
+            assert.deepEqual(await received, frame);
         }
         finally {
             await closeConnection(connection, server);
@@ -92,16 +99,13 @@ describe('IggyConnection', () => {
         const connection = new IggyConnection(connectionConfig(server));
         try {
             await connection.connect();
-            const body = Buffer.from('response');
-            const frame = Buffer.alloc(8 + body.length);
-            frame.writeUInt32LE(body.length, 4);
-            body.copy(frame, 8);
+            const frame = replyFrame(Buffer.from('response'));
             const response = once(connection, 'response');
             connection._onData(frame.subarray(0, 6));
             connection._onData(frame.subarray(6));
             assert.deepEqual((await response)[0], frame);
-            const malformed = Buffer.alloc(8);
-            malformed.writeUInt32LE(256, 4);
+            const malformed = replyFrame(Buffer.alloc(0));
+            malformed.writeUInt32LE(FRAME_LIMIT + 1, REPLY_OFFSET.size);
             const error = once(connection, 'error');
             connection._onData(malformed);
             assert.ok((await error)[0] instanceof ProtocolFrameError);
@@ -178,10 +182,7 @@ describe('IggyConnection', () => {
             assert.equal(await first, connection);
             assert.equal(connection.connected, true);
             assert.equal(connections, 2);
-            const body = Buffer.from('fresh');
-            const frame = Buffer.alloc(8 + body.length);
-            frame.writeUInt32LE(body.length, 4);
-            body.copy(frame, 8);
+            const frame = replyFrame(Buffer.from('fresh'));
             const response = once(connection, 'response');
             oldSocket.emit('data', Buffer.alloc(8));
             connection._onData(frame);

package/dist/client/client.frame.d.ts

@@ -1,4 +1,3 @@
-import type { Protocol } from './client.type.js';
 export declare class ProtocolFrameError extends Error {
     constructor(message: string);
 }
@@ -6,21 +5,19 @@ export type ExtractedFrames = {
     frames: Buffer[];
     remainder: Buffer;
 };
-export declare const extractResponseFrames: (protocol: Protocol, buffer: Buffer, maximumFrameSize: number) => ExtractedFrames;
+export declare const extractResponseFrames: (buffer: Buffer, maximumFrameSize: number) => ExtractedFrames;
 /**
  * Incrementally extracts response frames without repeatedly copying an
  * incomplete frame as new socket chunks arrive.
  */
 export declare class ResponseFrameDecoder {
-    private readonly protocol;
     private readonly maximumFrameSize;
-    private readonly headerSize;
     private chunks;
     private chunkIndex;
     private chunkOffset;
     private bufferedLength;
     private expectedFrameSize?;
-    constructor(protocol: Protocol, maximumFrameSize: number);
+    constructor(maximumFrameSize: number);
     get hasBufferedData(): boolean;
     clear(): void;
     push(data: Buffer): Buffer[];

package/dist/client/client.frame.js

@@ -14,34 +14,28 @@
 // KIND, either express or implied.  See the License for the
 // specific language governing permissions and limitations
 // under the License.
-import { HEADER_SIZE as VSR_HEADER_SIZE, readSize as readVsrSize } from '../wire/vsr/header.js';
-const CLASSIC_HEADER_SIZE = 8;
+import { HEADER_SIZE, readSize } from '../wire/vsr/header.js';
 export class ProtocolFrameError extends Error {
     constructor(message) {
         super(message);
         this.name = 'ProtocolFrameError';
     }
 }
-const headerSizeFor = (protocol) => protocol === 'vsr' ? VSR_HEADER_SIZE : CLASSIC_HEADER_SIZE;
-const declaredFrameSize = (protocol, header, maximumFrameSize) => {
-    const headerSize = headerSizeFor(protocol);
-    const declaredSize = protocol === 'vsr'
-        ? readVsrSize(header)
-        : CLASSIC_HEADER_SIZE + header.readUInt32LE(4);
-    if (declaredSize < headerSize)
-        throw new ProtocolFrameError(`declared ${protocol} frame size ${declaredSize} is below header size`);
+const declaredFrameSize = (header, maximumFrameSize) => {
+    const declaredSize = readSize(header);
+    if (declaredSize < HEADER_SIZE)
+        throw new ProtocolFrameError(`declared frame size ${declaredSize} is below header size`);
     if (declaredSize > maximumFrameSize)
-        throw new ProtocolFrameError(`declared ${protocol} frame size ${declaredSize} exceeds ` +
+        throw new ProtocolFrameError(`declared frame size ${declaredSize} exceeds ` +
             `the ${maximumFrameSize} byte limit`);
     return declaredSize;
 };
-export const extractResponseFrames = (protocol, buffer, maximumFrameSize) => {
-    const headerSize = headerSizeFor(protocol);
+export const extractResponseFrames = (buffer, maximumFrameSize) => {
     const frames = [];
     let offset = 0;
-    while (buffer.length - offset >= headerSize) {
+    while (buffer.length - offset >= HEADER_SIZE) {
         const available = buffer.length - offset;
-        const declaredSize = declaredFrameSize(protocol, buffer.subarray(offset, offset + headerSize), maximumFrameSize);
+        const declaredSize = declaredFrameSize(buffer.subarray(offset, offset + HEADER_SIZE), maximumFrameSize);
         if (available < declaredSize)
             break;
         frames.push(buffer.subarray(offset, offset + declaredSize));
@@ -59,18 +53,14 @@ export const extractResponseFrames = (protocol, buffer, maximumFrameSize) => {
  * incomplete frame as new socket chunks arrive.
  */
 export class ResponseFrameDecoder {
-    protocol;
     maximumFrameSize;
-    headerSize;
     chunks;
     chunkIndex;
     chunkOffset;
     bufferedLength;
     expectedFrameSize;
-    constructor(protocol, maximumFrameSize) {
-        this.protocol = protocol;
+    constructor(maximumFrameSize) {
         this.maximumFrameSize = maximumFrameSize;
-        this.headerSize = headerSizeFor(protocol);
         this.chunks = [];
         this.chunkIndex = 0;
         this.chunkOffset = 0;
@@ -95,9 +85,9 @@ export class ResponseFrameDecoder {
         const frames = [];
         while (true) {
             if (this.expectedFrameSize === undefined) {
-                if (this.bufferedLength < this.headerSize)
+                if (this.bufferedLength < HEADER_SIZE)
                     break;
-                this.expectedFrameSize = declaredFrameSize(this.protocol, this.peek(this.headerSize), this.maximumFrameSize);
+                this.expectedFrameSize = declaredFrameSize(this.peek(HEADER_SIZE), this.maximumFrameSize);
             }
             if (this.bufferedLength < this.expectedFrameSize)
                 break;

package/dist/client/client.frame.test.js

@@ -19,12 +19,6 @@ import { describe, it } from 'node:test';
 import { extractResponseFrames, ProtocolFrameError, ResponseFrameDecoder } from './client.frame.js';
 import { Command2, HEADER_SIZE, REPLY_OFFSET } from '../wire/vsr/header.js';
 const LIMIT = 1024;
-const classicFrame = (body) => {
-    const frame = Buffer.alloc(8 + body.length);
-    frame.writeUInt32LE(body.length, 4);
-    body.copy(frame, 8);
-    return frame;
-};
 const vsrFrame = (body) => {
     const frame = Buffer.alloc(HEADER_SIZE + body.length);
     frame.writeUInt32LE(frame.length, REPLY_OFFSET.size);
@@ -33,59 +27,50 @@ const vsrFrame = (body) => {
     return frame;
 };
 describe('extractResponseFrames', () => {
-    for (const protocol of ['classic', 'vsr']) {
-        const makeFrame = protocol === 'classic' ? classicFrame : vsrFrame;
-        it(`buffers ${protocol} headers split at every boundary`, () => {
-            const frame = makeFrame(Buffer.from('payload'));
-            const headerSize = protocol === 'classic' ? 8 : HEADER_SIZE;
-            for (let split = 0; split < headerSize; split += 1) {
-                const first = extractResponseFrames(protocol, frame.subarray(0, split), LIMIT);
-                assert.equal(first.frames.length, 0);
-                const second = extractResponseFrames(protocol, Buffer.concat([first.remainder, frame.subarray(split)]), LIMIT);
-                assert.deepEqual(second.frames, [frame]);
-                assert.equal(second.remainder.length, 0);
-            }
-        });
-        it(`buffers a fragmented ${protocol} body`, () => {
-            const frame = makeFrame(Buffer.from('payload'));
-            const split = frame.length - 2;
-            const first = extractResponseFrames(protocol, frame.subarray(0, split), LIMIT);
+    it('buffers headers split at every boundary', () => {
+        const frame = vsrFrame(Buffer.from('payload'));
+        for (let split = 0; split < HEADER_SIZE; split += 1) {
+            const first = extractResponseFrames(frame.subarray(0, split), LIMIT);
             assert.equal(first.frames.length, 0);
-            const second = extractResponseFrames(protocol, Buffer.concat([first.remainder, frame.subarray(split)]), LIMIT);
+            const second = extractResponseFrames(Buffer.concat([first.remainder, frame.subarray(split)]), LIMIT);
             assert.deepEqual(second.frames, [frame]);
-        });
-        it(`extracts coalesced ${protocol} frames and a partial tail`, () => {
-            const first = makeFrame(Buffer.from('one'));
-            const second = makeFrame(Buffer.from('two'));
-            const third = makeFrame(Buffer.from('three'));
-            const input = Buffer.concat([first, second, third.subarray(0, 3)]);
-            const extracted = extractResponseFrames(protocol, input, LIMIT);
-            assert.deepEqual(extracted.frames, [first, second]);
-            assert.deepEqual(extracted.remainder, third.subarray(0, 3));
-            assert.equal(extracted.remainder.buffer, input.buffer);
-        });
-    }
-    it('rejects a VSR size below the header', () => {
+            assert.equal(second.remainder.length, 0);
+        }
+    });
+    it('buffers a fragmented body', () => {
+        const frame = vsrFrame(Buffer.from('payload'));
+        const split = frame.length - 2;
+        const first = extractResponseFrames(frame.subarray(0, split), LIMIT);
+        assert.equal(first.frames.length, 0);
+        const second = extractResponseFrames(Buffer.concat([first.remainder, frame.subarray(split)]), LIMIT);
+        assert.deepEqual(second.frames, [frame]);
+    });
+    it('extracts coalesced frames and a partial tail', () => {
+        const first = vsrFrame(Buffer.from('one'));
+        const second = vsrFrame(Buffer.from('two'));
+        const third = vsrFrame(Buffer.from('three'));
+        const input = Buffer.concat([first, second, third.subarray(0, 3)]);
+        const extracted = extractResponseFrames(input, LIMIT);
+        assert.deepEqual(extracted.frames, [first, second]);
+        assert.deepEqual(extracted.remainder, third.subarray(0, 3));
+        assert.equal(extracted.remainder.buffer, input.buffer);
+    });
+    it('rejects a size below the header', () => {
         const frame = vsrFrame(Buffer.alloc(0));
         frame.writeUInt32LE(0, REPLY_OFFSET.size);
-        assert.throws(() => extractResponseFrames('vsr', frame, LIMIT), ProtocolFrameError);
+        assert.throws(() => extractResponseFrames(frame, LIMIT), ProtocolFrameError);
     });
-    it('rejects an oversized VSR frame before buffering its body', () => {
+    it('rejects an oversized frame before buffering its body', () => {
         const header = vsrFrame(Buffer.alloc(0));
         header.writeUInt32LE(LIMIT + 1, REPLY_OFFSET.size);
-        assert.throws(() => extractResponseFrames('vsr', header, LIMIT), ProtocolFrameError);
-    });
-    it('rejects an oversized classic frame before buffering its body', () => {
-        const header = classicFrame(Buffer.alloc(0));
-        header.writeUInt32LE(LIMIT, 4);
-        assert.throws(() => extractResponseFrames('classic', header, LIMIT), ProtocolFrameError);
+        assert.throws(() => extractResponseFrames(header, LIMIT), ProtocolFrameError);
     });
 });
 describe('ResponseFrameDecoder', () => {
     it('decodes bytewise input without losing coalesced frames', () => {
-        const decoder = new ResponseFrameDecoder('classic', LIMIT);
-        const first = classicFrame(Buffer.from('first'));
-        const second = classicFrame(Buffer.from('second'));
+        const decoder = new ResponseFrameDecoder(LIMIT);
+        const first = vsrFrame(Buffer.from('first'));
+        const second = vsrFrame(Buffer.from('second'));
         const input = Buffer.concat([first, second]);
         const frames = [];
         for (const byte of input)
@@ -94,16 +79,16 @@ describe('ResponseFrameDecoder', () => {
         assert.equal(decoder.hasBufferedData, false);
     });
     it('clears a partial frame', () => {
-        const decoder = new ResponseFrameDecoder('vsr', LIMIT);
-        decoder.push(vsrFrame(Buffer.from('body')).subarray(0, 100));
+        const decoder = new ResponseFrameDecoder(LIMIT);
+        decoder.push(vsrFrame(Buffer.from('body')).subarray(0, HEADER_SIZE - 2));
         assert.equal(decoder.hasBufferedData, true);
         decoder.clear();
         assert.equal(decoder.hasBufferedData, false);
     });
     it('rejects an oversized frame as soon as its header is complete', () => {
-        const decoder = new ResponseFrameDecoder('classic', LIMIT);
-        const header = Buffer.alloc(8);
-        header.writeUInt32LE(LIMIT, 4);
+        const decoder = new ResponseFrameDecoder(LIMIT);
+        const header = vsrFrame(Buffer.alloc(0));
+        header.writeUInt32LE(LIMIT + 1, REPLY_OFFSET.size);
         assert.throws(() => decoder.push(header), ProtocolFrameError);
     });
 });

package/dist/client/client.socket.d.ts

@@ -1,5 +1,5 @@
 import { EventEmitter } from 'node:events';
-import type { ClientConfig, ClientCredentials, CommandResponse, PasswordCredentials, Protocol, RawClient, SendCommandOptions, TokenCredentials } from '../client/client.type.js';
+import type { ClientConfig, ClientCredentials, CommandResponse, PasswordCredentials, RawClient, SendCommandOptions, TokenCredentials } from '../client/client.type.js';
 export declare class VsrResponseTimeoutError extends Error {
     constructor(timeout: number);
 }
@@ -8,8 +8,6 @@ export declare class VsrResponseTimeoutError extends Error {
  * Implements command queuing, authentication, and heartbeat functionality.
  */
 export declare class CommandResponseStream extends EventEmitter {
-    /** Server wire protocol used by this connection */
-    readonly protocol: Protocol;
     /** Client configuration */
     private options;
     /** Underlying connection to the server */
@@ -69,7 +67,6 @@ export declare class CommandResponseStream extends EventEmitter {
      */
     _processNext(command: number, payload: Buffer, handleResp?: boolean): Promise<CommandResponse>;
     private _processVsrLogin;
-    private _processClassic;
     private _processVsr;
     private _exchange;
     private isUnloggedCommand;

package/dist/client/client.socket.js

@@ -16,7 +16,6 @@
 // under the License.
 //
 import { EventEmitter } from 'node:events';
-import { handleResponse } from './client.utils.js';
 import { ResponseError, responseError } from '../wire/error.utils.js';
 import { debug } from './client.debug.js';
 import { IggyConnection } from './client.connection.js';
@@ -49,8 +48,6 @@ export class VsrResponseTimeoutError extends Error {
  * Implements command queuing, authentication, and heartbeat functionality.
  */
 export class CommandResponseStream extends EventEmitter {
-    /** Server wire protocol used by this connection */
-    protocol;
     /** Client configuration */
     options;
     /** Underlying connection to the server */
@@ -82,7 +79,6 @@ export class CommandResponseStream extends EventEmitter {
         super();
         const normalizedConfig = normalizeClientConfig(options);
         this.options = normalizedConfig;
-        this.protocol = normalizedConfig.protocol;
         this.connection = new IggyConnection(normalizedConfig);
         this.busy = false;
         this.isAuthenticated = false;
@@ -126,7 +122,7 @@ export class CommandResponseStream extends EventEmitter {
             const { handleResponse = true, last = true } = options;
             if (!this.connection.connected)
                 await this.connection.connect();
-            if (this.options.protocol === 'vsr' && isLoginCommand(command))
+            if (isLoginCommand(command))
                 await this._ensureVsrLeader();
             if (!this.isAuthenticated && !this.isUnloggedCommand(command))
                 await this.authenticate(this.options.credentials);
@@ -191,8 +187,6 @@ export class CommandResponseStream extends EventEmitter {
      * @returns Promise resolving to the command response
      */
     _processNext(command, payload, handleResp = true) {
-        if (this.options.protocol !== 'vsr')
-            return this._processClassic(command, payload, handleResp);
         if (isLoginCommand(command) && this.isAuthenticated)
             return this._processVsrLogin(command, payload, handleResp);
         return this._processVsr(command, payload, handleResp);
@@ -201,15 +195,6 @@ export class CommandResponseStream extends EventEmitter {
         await this._processVsr(LOGOUT.code, LOGOUT.serialize(), true);
         return this._processVsr(command, payload, handleResp);
     }
-    async _processClassic(command, payload, handleResp) {
-        const response = await this._exchange(() => this.connection.writeCommand(command, payload));
-        if (!handleResp)
-            return response;
-        const parsed = handleResponse(response);
-        if (parsed.status !== 0)
-            throw responseError(command, parsed.status);
-        return parsed;
-    }
     async _processVsr(command, payload, handleResp) {
         let requestWritten = false;
         try {
@@ -326,8 +311,7 @@ export class CommandResponseStream extends EventEmitter {
     }
     isUnloggedCommand(command) {
         return UNLOGGED_COMMAND_CODE.includes(command) ||
-            (this.options.protocol === 'vsr' &&
-                command === COMMAND_CODE.GetClusterMetadata);
+            command === COMMAND_CODE.GetClusterMetadata;
     }
     async _ensureVsrLeader() {
         for (let attempt = 0; attempt < 3; attempt += 1) {

package/dist/client/client.socket.test.js

@@ -161,7 +161,6 @@ const singleNodeHandler = (port) => (frame, socket) => {
     socket.write(replyFrame(operation));
 };
 const vsrConfig = (port) => ({
-    protocol: 'vsr',
     transport: 'TCP',
     options: { host: '127.0.0.1', port },
     credentials: { username: 'iggy', password: 'iggy' },

package/dist/client/client.type.d.ts

@@ -35,8 +35,6 @@ export type SendCommandOptions = {
  * Provides direct access to command sending and event handling.
  */
 export type RawClient = {
-    /** Server wire protocol used by this connection */
-    readonly protocol: Protocol;
     /** Sends a command to the server and returns the response */
     sendCommand: (code: number, payload: Buffer, options?: SendCommandOptions) => Promise<CommandResponse>;
     /** Whether the client has been authenticated */
@@ -83,8 +81,6 @@ export type ReconnectOption = {
  * Union type for transport-specific connection options.
  */
 export type TransportOption = TcpOption | TlsOption;
-/** Server wire protocol. */
-export type Protocol = 'classic' | 'vsr';
 /**
  * Token-based authentication credentials.
  */
@@ -119,8 +115,6 @@ export type PoolSizeOption = {
  * Complete client configuration for connecting to the Iggy server.
  */
 export type ClientConfig = {
-    /** Server wire protocol (default: classic) */
-    protocol?: Protocol;
     /** Transport protocol to use (TCP or TLS) */
     transport: TransportType;
     /** Transport-specific connection options */

package/dist/client/client.utils.d.ts

@@ -1,24 +1,4 @@
-import { Transform } from 'node:stream';
 import type { CommandResponse } from './client.type.js';
-/**
- * Parses a raw response buffer into a structured CommandResponse.
- * Extracts status code, length, and payload data from the buffer.
- *
- * @param r - Raw response buffer from the server
- * @returns Parsed command response with status, length, and data
- */
-export declare const handleResponse: (r: Buffer) => {
-    status: number;
-    length: number;
-    data: Buffer<ArrayBufferLike>;
-};
-/**
- * Creates a Transform stream that parses response buffers.
- * Transforms raw server responses into just the data payload.
- *
- * @returns Transform stream for processing server responses
- */
-export declare const handleResponseTransform: () => Transform;
 /**
  * Deserializes a void response from the server.
  * Returns true if the command succeeded with no data.
@@ -27,13 +7,4 @@ export declare const handleResponseTransform: () => Transform;
  * @returns True if the response indicates success with no data
  */
 export declare const deserializeVoidResponse: (r: CommandResponse) => boolean;
-/**
- * Serializes a command and its payload into a buffer for sending to the server.
- * Creates the wire format: [payload_size (4 bytes)][command (4 bytes)][payload]
- *
- * @param command - Command code to send
- * @param payload - Command payload buffer
- * @returns Buffer ready to be sent to the server
- */
-export declare const serializeCommand: (command: number, payload: Buffer) => Buffer<ArrayBuffer>;
 //# sourceMappingURL=client.utils.d.ts.map

package/dist/client/client.utils.js

@@ -15,42 +15,6 @@
 // specific language governing permissions and limitations
 // under the License.
 //
-import { Transform } from 'node:stream';
-import { translateCommandCode } from '../wire/command.code.js';
-import { debug } from './client.debug.js';
-/**
- * Parses a raw response buffer into a structured CommandResponse.
- * Extracts status code, length, and payload data from the buffer.
- *
- * @param r - Raw response buffer from the server
- * @returns Parsed command response with status, length, and data
- */
-export const handleResponse = (r) => {
-    const status = r.readUint32LE(0);
-    const length = r.readUint32LE(4);
-    debug('<== handleResponse', { status, length });
-    return {
-        status, length, data: r.subarray(8, 8 + length)
-    };
-};
-/**
- * Creates a Transform stream that parses response buffers.
- * Transforms raw server responses into just the data payload.
- *
- * @returns Transform stream for processing server responses
- */
-export const handleResponseTransform = () => new Transform({
-    transform(chunk, encoding, cb) {
-        try {
-            const r = handleResponse(chunk);
-            debug('response::', r);
-            return cb(null, r.data);
-        }
-        catch (err) {
-            return cb(new Error('handleResponseTransform error', { cause: err }), null);
-        }
-    }
-});
 /**
  * Deserializes a void response from the server.
  * Returns true if the command succeeded with no data.
@@ -59,24 +23,4 @@ export const handleResponseTransform = () => new Transform({
  * @returns True if the response indicates success with no data
  */
 export const deserializeVoidResponse = (r) => r.status === 0 && r.data.length === 0;
-/** Length of the command code in bytes */
-const COMMAND_LENGTH = 4;
-/**
- * Serializes a command and its payload into a buffer for sending to the server.
- * Creates the wire format: [payload_size (4 bytes)][command (4 bytes)][payload]
- *
- * @param command - Command code to send
- * @param payload - Command payload buffer
- * @returns Buffer ready to be sent to the server
- */
-export const serializeCommand = (command, payload) => {
-    const payloadSize = payload.length + COMMAND_LENGTH;
-    const data = Buffer.allocUnsafe(8 + payload.length);
-    data.writeUint32LE(payloadSize, 0);
-    data.writeUint32LE(command, 4);
-    data.fill(payload, 8);
-    debug('==> CMD', command, translateCommandCode(command), 'LENGTH', payloadSize);
-    debug('FullMessage#Base64', data.toString('base64'));
-    return data;
-};
 //# sourceMappingURL=client.utils.js.map

package/dist/client/client.utils.test.js

@@ -17,26 +17,15 @@
 //
 import { describe, it } from 'node:test';
 import assert from 'node:assert/strict';
-import { handleResponse, deserializeVoidResponse } from './client.utils.js';
-const SUCCESS = 0;
-describe('handleResponse', () => {
-    it('bounds data to the length field, not the full buffer', () => {
-        // Server says: status=0, length=0, no payload.
-        // But the raw buffer has 4 trailing bytes (e.g. start of next response).
-        const buf = Buffer.alloc(12);
-        buf.writeUInt32LE(SUCCESS, 0); // status
-        buf.writeUInt32LE(0, 4); // length = 0 (void response)
-        buf.writeUInt32LE(42, 8); // trailing bytes — NOT part of this response
-        const r = handleResponse(buf);
-        assert.equal(r.data.length, 0);
-    });
-    it('deserializeVoidResponse returns true for a valid void response with trailing buffer bytes', () => {
-        const buf = Buffer.alloc(12);
-        buf.writeUInt32LE(SUCCESS, 0);
-        buf.writeUInt32LE(0, 4); // length = 0
-        buf.writeUInt32LE(42, 8); // trailing bytes
-        const r = handleResponse(buf);
-        assert.equal(deserializeVoidResponse(r), true);
+import { deserializeVoidResponse } from './client.utils.js';
+describe('deserializeVoidResponse', () => {
+    it('returns true only for a success status with an empty payload', () => {
+        const success = { status: 0, length: 0, data: Buffer.alloc(0) };
+        assert.equal(deserializeVoidResponse(success), true);
+        const failed = { status: 1, length: 0, data: Buffer.alloc(0) };
+        assert.equal(deserializeVoidResponse(failed), false);
+        const withData = { status: 0, length: 4, data: Buffer.alloc(4) };
+        assert.equal(deserializeVoidResponse(withData), false);
     });
 });
 //# sourceMappingURL=client.utils.test.js.map

package/dist/e2e/tcp.cluster.e2e.js

@@ -18,13 +18,14 @@
 import { after, describe, it } from "node:test";
 import assert from "node:assert/strict";
 import { getTestClient } from "./test-client.utils.js";
-// cluster mode still in dev atm
-// response is mocked from /core/server/config.toml
+// The suite runs against a single-node server (cluster mode off), which
+// reports itself as the sole healthy leader with endpoints derived from
+// its default config.
 const expectedMeta = {
-    name: "iggy-cluster",
+    name: "single-node",
     nodes: [
         {
-            name: "iggy-node-1",
+            name: "iggy-node",
             ip: "127.0.0.1",
             endpoints: {
                 tcp: 8090,
@@ -35,18 +36,6 @@ const expectedMeta = {
             role: "Leader",
             status: "Healthy",
         },
-        {
-            name: "iggy-node-2",
-            ip: "127.0.0.1",
-            endpoints: {
-                tcp: 8091,
-                quic: 8081,
-                http: 3001,
-                websocket: 8093,
-            },
-            role: "Follower",
-            status: "Healthy",
-        },
     ],
 };
 describe("e2e -> system", async () => {

package/dist/e2e/tcp.consumer-group.e2e.js

@@ -23,9 +23,7 @@ import { generateMessages } from '../tcp.sm.utils.js';
 import { getIggyAddress } from '../tcp.sm.utils.js';
 describe('e2e -> consumer-group', async () => {
     const [host, port] = getIggyAddress();
-    const vsr = process.env.IGGY_TEST_PROTOCOL === 'vsr';
     const c = new SingleClient({
-        protocol: vsr ? 'vsr' : 'classic',
         transport: 'TCP',
         options: { host, port },
         credentials: { username: 'iggy', password: 'iggy' }
@@ -74,9 +72,7 @@ describe('e2e -> consumer-group', async () => {
                 streamId: streamName,
                 topicId: topicName,
                 messages: generateMessages(mn),
-                partition: vsr
-                    ? Partitioning.PartitionId((i / mn) % 3)
-                    : Partitioning.MessageKey(`key-${i % 300}`)
+                partition: Partitioning.PartitionId((i / mn) % 3)
             }));
         }
         payloadLength = ct;

package/dist/e2e/tcp.consumer-stream.e2e.js

@@ -24,9 +24,7 @@ import { sendSomeMessages, getIggyAddress } from '../tcp.sm.utils.js';
 describe('e2e -> consumer-stream', async () => {
     const [host, port] = getIggyAddress();
     const credentials = { username: 'iggy', password: 'iggy' };
-    const vsr = process.env.IGGY_TEST_PROTOCOL === 'vsr';
     const opt = {
-        protocol: (vsr ? 'vsr' : 'classic'),
         transport: 'TCP',
         options: { host, port },
         credentials
@@ -45,9 +43,7 @@ describe('e2e -> consumer-stream', async () => {
     const ct = 1000;
     it('e2e -> consumer-stream::send-messages', async () => {
         for (let i = 0; i < ct; i += 100) {
-            await sendSomeMessages(c.clientProvider)(streamName, topicName, vsr
-                ? Partitioning.PartitionId((i / 100) % 3)
-                : Partitioning.MessageKey(`k-${i % 300}`));
+            await sendSomeMessages(c.clientProvider)(streamName, topicName, Partitioning.PartitionId((i / 100) % 3));
         }
     });
     it('e2e -> consumer-stream::poll-stream', async () => {

package/dist/e2e/tcp.send-message.e2e.js

@@ -22,9 +22,6 @@ import { generateMessages } from '../tcp.sm.utils.js';
 import { getTestClient } from './test-client.utils.js';
 describe('e2e -> message', async () => {
     const c = getTestClient();
-    // Only the VSR lane reaches a server that reports offsets. The classic lane
-    // runs against the legacy server, which commits without confirming.
-    const vsr = process.env.IGGY_TEST_PROTOCOL === 'vsr';
     const streamName = 'e2e-stream-934';
     const topicName = 'e2e-topic-832';
     const partitionId = 0;
@@ -44,10 +41,6 @@ describe('e2e -> message', async () => {
     };
     it('e2e -> message::send', async () => {
         const { confirmations } = await c.message.send(msg);
-        if (!vsr) {
-            assert.equal(confirmations.length, 0);
-            return;
-        }
         assert.equal(confirmations.length, 1);
         assert.equal(confirmations[0].partitionId, partitionId);
     });
@@ -157,10 +150,6 @@ describe('e2e -> message', async () => {
             ...msg,
             messages: generateMessages(3)
         });
-        if (!vsr) {
-            assert.equal(confirmations.length, 0);
-            return;
-        }
         // Landing behind the already committed batch is the part no placeholder
         // confirmation could reproduce.
         assert.equal(confirmations.length, 1);

package/dist/e2e/test-client.utils.js

@@ -19,9 +19,7 @@ import { Client } from '../client/client.js';
 import { getIggyAddress } from '../tcp.sm.utils.js';
 const credentials = { username: 'iggy', password: 'iggy' };
 const [host, port] = getIggyAddress();
-const protocol = process.env.IGGY_TEST_PROTOCOL === 'vsr' ? 'vsr' : 'classic';
 export const getTestClient = () => new Client({
-    protocol,
     transport: 'TCP',
     options: { host, port },
     credentials

package/dist/e2e/tls.system.e2e.js

@@ -21,11 +21,13 @@
 // To run them locally:
 //
 //   1. Start the server with TLS:
+//      TODO(hubcio): change to iggy-server once legacy server is removed
+//      (core/server has VSR support)
 //        IGGY_ROOT_USERNAME=iggy IGGY_ROOT_PASSWORD=iggy \
 //        IGGY_TCP_TLS_ENABLED=true \
 //        IGGY_TCP_TLS_CERT_FILE=core/certs/iggy_cert.pem \
 //        IGGY_TCP_TLS_KEY_FILE=core/certs/iggy_key.pem \
-//        cargo r --bin iggy-server
+//        cargo r --bin iggy-server-ng --features vsr
 //
 //   2. Run the tests:
 //        cd foreign/node
@@ -46,13 +48,9 @@ const caCertPath = process.env.E2E_ROOT_CA_CERT
 const getTlsClient = () => {
     const [, port] = getIggyAddress();
     const caCert = readFileSync(caCertPath);
-    const protocol = process.env.IGGY_TEST_PROTOCOL === 'vsr'
-        ? 'vsr'
-        : 'classic';
     // The server certificate SAN is DNS:localhost, so we connect via 'localhost'
     // for proper hostname verification (consistent with Python and C# TLS tests).
     return new Client({
-        protocol,
         transport: 'TLS',
         options: {
             port,

package/dist/wire/cluster/cluster.type.d.ts

@@ -17,7 +17,7 @@ export declare const ClusterNodeStatus: {
 export type ClusterNodeStatus = typeof ClusterNodeStatus;
 export type ClusterNodeStatusKey = keyof ClusterNodeStatus;
 export type ClusterNodeStatusValue = ValueOf<ClusterNodeStatus>;
-export declare const ReverseClusterNodeStatus: Record<0 | 2 | 1 | 4 | 3, "Healthy" | "Starting" | "Stopping" | "Unreachable" | "Maintenance">;
+export declare const ReverseClusterNodeStatus: Record<0 | 2 | 1 | 3 | 4, "Healthy" | "Starting" | "Stopping" | "Unreachable" | "Maintenance">;
 export declare const TransportProtocol: {
     readonly TCP: 1;
     readonly QUIC: 2;
@@ -27,7 +27,7 @@ export declare const TransportProtocol: {
 export type TransportProtocol = typeof TransportProtocol;
 export type TransportProtocolKey = keyof TransportProtocol;
 export type TransportProtocolValue = ValueOf<TransportProtocol>;
-export declare const ReverseTransportProtocol: Record<2 | 1 | 4 | 3, "TCP" | "QUIC" | "HTTP" | "WebSocket">;
+export declare const ReverseTransportProtocol: Record<2 | 1 | 3 | 4, "TCP" | "QUIC" | "HTTP" | "WebSocket">;
 export declare const isClusterNodeRole: (n: number) => n is ClusterNodeRoleValue;
 export declare const isClusterNodeStatus: (n: number) => n is ClusterNodeStatusValue;
 export declare const isTransportProtocol: (n: number) => n is TransportProtocolValue;

package/dist/wire/command-set.test.js

@@ -20,7 +20,6 @@ import assert from 'node:assert/strict';
 import { SimpleClient } from '../client/client.js';
 import { COMMAND_CODE } from './command.code.js';
 const mockRawClient = () => ({
-    protocol: 'classic',
     sendCommand: async () => {
         throw new Error('sendCommand should not be called by the session-control guard');
     },

package/dist/wire/message/header.type.d.ts

@@ -27,7 +27,7 @@ export type HeaderKindId = keyof HeaderKind;
 /** Numeric values of header kinds */
 export type HeaderKindValue = ValueOf<HeaderKind>;
 /** Reverse mapping from numeric value to header kind name */
-export declare const ReverseHeaderKind: Record<2 | 1 | 10 | 11 | 12 | 4 | 8 | 3 | 5 | 13 | 6 | 7 | 9 | 14 | 15, "Raw" | "String" | "Bool" | "Int8" | "Int16" | "Int32" | "Int64" | "Int128" | "Uint8" | "Uint16" | "Uint32" | "Uint64" | "Uint128" | "Float" | "Double">;
+export declare const ReverseHeaderKind: Record<2 | 1 | 10 | 11 | 12 | 5 | 8 | 13 | 3 | 4 | 6 | 7 | 9 | 14 | 15, "Raw" | "String" | "Bool" | "Int8" | "Int16" | "Int32" | "Int64" | "Int128" | "Uint8" | "Uint16" | "Uint32" | "Uint64" | "Uint128" | "Float" | "Double">;
 /** Returns expected byte size for a header kind, or -1 for variable-size kinds */
 export declare const expectedSize: (kind: number) => number;
 /** Raw binary header value */

package/dist/wire/message/poll-messages.command.js

@@ -160,8 +160,7 @@ export const pollMessages = (getClient) => async (request) => {
     const client = await getClient();
     const release = client.hold?.();
     try {
-        if (client.protocol === 'vsr' &&
-            request.consumer.kind === ConsumerKind.Group &&
+        if (request.consumer.kind === ConsumerKind.Group &&
             request.partitionId === null) {
             const state = getGroupState(client);
             while (true) {

package/dist/wire/vsr/namespace.js

@@ -111,6 +111,8 @@ const namespaceFromIds = (stream, topic, partitionId) => {
  * `SendMessages`: `[metadata_len u32][stream ident][topic ident]
  * [partitioning kind u8, len u8, value]...`. Only explicit `PartitionId`
  * partitioning is routable under VSR; the broker never picks a partition.
+ * TODO(hubcio): Balanced and MessageKey partitioning to be implemented;
+ * not decided yet whether it'll be on server side or client side.
  */
 const namespaceFromSendMessages = (payload) => {
     if (payload.length < 4)

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "apache-iggy",
   "type": "module",
-  "version": "0.9.0-edge.1",
+  "version": "0.10.0-edge.1",
   "description": "Official Apache Iggy NodeJS SDK",
   "keywords": [
     "iggy",
@@ -37,7 +37,6 @@
   "scripts": {
     "test:unit": "node --import @swc-node/register/esm-register --test --experimental-test-coverage './src/**/*.test.ts'",
     "test:e2e": "node --import @swc-node/register/esm-register --test --experimental-test-coverage --test-force-exit './src/e2e/*.e2e.ts'",
-    "test:e2e:vsr": "IGGY_TEST_PROTOCOL=vsr node --import @swc-node/register/esm-register --test --experimental-test-coverage --test-force-exit './src/e2e/tcp.*.e2e.ts'",
     "test:bdd": "cucumber-js --exit",
     "test": "npm run test:unit && npm run test:bdd && npm run test:e2e",
     "clean": "rm -Rf dist/",
@@ -61,7 +60,7 @@
     "@cucumber/cucumber": "13.2.0",
     "@swc-node/register": "1.12.1",
     "@types/debug": "4.1.13",
-    "@types/node": "26.1.1",
+    "@types/node": "26.1.2",
     "c8": "^12.0.0",
     "husky": "9.1.7",
     "typescript": "6.0.3",