apache-iggy 0.8.1-edge.4 → 0.9.0-edge.1

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

@@ -27,7 +27,6 @@ export declare const handleResponseTransform: () => Transform;
  * @returns True if the response indicates success with no data
  */
 export declare const deserializeVoidResponse: (r: CommandResponse) => boolean;
-export declare const deserializeStatusResponse: (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]

package/dist/client/client.utils.js

@@ -59,7 +59,6 @@ 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;
-export const deserializeStatusResponse = (r) => r.status === 0;
 /** Length of the command code in bytes */
 const COMMAND_LENGTH = 4;
 /**

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

@@ -17,9 +17,8 @@
 //
 import { describe, it } from 'node:test';
 import assert from 'node:assert/strict';
-import { handleResponse, deserializeVoidResponse, deserializeStatusResponse } from './client.utils.js';
+import { handleResponse, deserializeVoidResponse } from './client.utils.js';
 const SUCCESS = 0;
-const ERROR = 1;
 describe('handleResponse', () => {
     it('bounds data to the length field, not the full buffer', () => {
         // Server says: status=0, length=0, no payload.
@@ -40,19 +39,4 @@ describe('handleResponse', () => {
         assert.equal(deserializeVoidResponse(r), true);
     });
 });
-describe('deserializeStatusResponse', () => {
-    it('returns true when status is SUCCESS and data is empty', () => {
-        const r = { status: SUCCESS, length: 0, data: Buffer.alloc(0) };
-        assert.equal(deserializeStatusResponse(r), true);
-    });
-    it('returns true when status is SUCCESS and data is non-empty (e.g. SendMessages server payload)', () => {
-        // Key difference from deserializeVoidResponse: non-empty data is accepted.
-        const r = { status: SUCCESS, length: 4, data: Buffer.from([1, 2, 3, 4]) };
-        assert.equal(deserializeStatusResponse(r), true);
-    });
-    it('returns false when status is an error code', () => {
-        const r = { status: ERROR, length: 0, data: Buffer.alloc(0) };
-        assert.equal(deserializeStatusResponse(r), false);
-    });
-});
 //# sourceMappingURL=client.utils.test.js.map

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

@@ -22,6 +22,9 @@ 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;
@@ -40,7 +43,13 @@ describe('e2e -> message', async () => {
         partition: Partitioning.PartitionId(partitionId)
     };
     it('e2e -> message::send', async () => {
-        assert.ok(await c.message.send(msg));
+        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);
     });
     it('e2e -> message::poll/last', async () => {
         const pollReq = {
@@ -143,6 +152,20 @@ describe('e2e -> message', async () => {
         });
         assert.deepEqual(offset, { partitionId: 0, currentOffset: 5n, storedOffset: 2n });
     });
+    it('e2e -> message::send/next batch', async () => {
+        const { confirmations } = await c.message.send({
+            ...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);
+        assert.equal(confirmations[0].baseOffset, BigInt(msg.messages.length));
+    });
     it('e2e -> message::cleanup', async () => {
         assert.ok(await c.stream.delete({ streamId: streamName }));
         assert.ok(await c.session.logout());

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-export { type Id, PollingStrategy, Consumer, Partitioning, HeaderValue, HeaderKeyFactory, } from "./wire/index.js";
+export { type Id, PollingStrategy, Consumer, Partitioning, HeaderValue, HeaderKeyFactory, type SendMessagesConfirmation, type SendMessagesResponse, } from "./wire/index.js";
 export * from "./client/index.js";
 export * from "./stream/index.js";
 export { DeserializeError, ResponseError } from './wire/error.utils.js';

package/dist/tcp.sm.utils.d.ts

@@ -55,7 +55,7 @@ export declare const generateMessages: (count?: number) => ({
     }[];
     id: string;
 })[];
-export declare const sendSomeMessages: (s: ClientProvider) => (streamId: Id, topicId: Id, partition: Partitioning) => Promise<true>;
+export declare const sendSomeMessages: (s: ClientProvider) => (streamId: Id, topicId: Id, partition: Partitioning) => Promise<import("./wire/index.js").SendMessagesResponse>;
 export declare const formatPolledMessages: (msgs: Message[]) => {
     id: string | bigint;
     offset: bigint;

package/dist/wire/command-set.d.ts

@@ -75,7 +75,7 @@ declare const offsetAPI: (c: ClientProvider) => {
 type OffsetAPI = ReturnType<typeof offsetAPI>;
 declare const messageAPI: (c: ClientProvider) => {
     poll: (request: import("./message/poll-messages.command.js").PollMessages) => Promise<import("./index.js").PollMessagesResponse>;
-    send: (arg: import("./message/send-messages.command.js").SendMessages) => Promise<boolean>;
+    send: (arg: import("./message/send-messages.command.js").SendMessages) => Promise<import("./message/send-messages.command.js").SendMessagesResponse>;
     flushUnsavedBuffers: (arg: import("./message/flush-unsaved-buffers.command.js").FlushUnsavedBuffer) => Promise<boolean>;
 };
 type MessageAPI = ReturnType<typeof messageAPI>;

package/dist/wire/message/send-messages.command.d.ts

@@ -1,6 +1,7 @@
 import { type Id } from '../identifier.utils.js';
 import { type CreateMessage } from './message.utils.js';
 import type { Partitioning } from './partitioning.utils.js';
+import type { CommandResponse } from '../../client/client.type.js';
 /**
  * Parameters for the send messages command.
  */
@@ -14,6 +15,33 @@ export type SendMessages = {
     /** Optional partitioning strategy */
     partition?: Partitioning;
 };
+/** Commit confirmation for one partition written by a send. */
+export type SendMessagesConfirmation = {
+    /** Numeric id of the stream the batch was written to */
+    streamId: number;
+    /** Numeric id of the topic the batch was written to */
+    topicId: number;
+    /** Partition the batch was written to */
+    partitionId: number;
+    /**
+     * Offset assigned to the first message of the batch in that partition.
+     *
+     * Delivery is at-least-once, so an earlier retry of the same batch may
+     * already have committed at a lower offset: this never identifies a batch
+     * uniquely. A batch is confirmed once it is committed in memory, not once it
+     * is fsynced, so a crash-restart can stamp a later batch with an offset a
+     * client has already recorded.
+     */
+    baseOffset: bigint;
+};
+/**
+ * Outcome of a successful send, one confirmation per written partition. The
+ * legacy server returns an empty list: it commits without reporting offsets.
+ */
+export type SendMessagesResponse = {
+    /** Commit confirmations, one per partition the batch was written to */
+    confirmations: SendMessagesConfirmation[];
+};
 /**
  * Send messages command definition.
  * Publishes messages to a topic.
@@ -21,10 +49,11 @@ export type SendMessages = {
 export declare const SEND_MESSAGES: {
     code: number;
     serialize: ({ streamId, topicId, messages, partition }: SendMessages) => Buffer<ArrayBuffer>;
-    deserialize: (r: import("../../index.js").CommandResponse) => boolean;
+    deserialize: (r: CommandResponse) => SendMessagesResponse;
 };
 /**
- * Executable send messages command function.
+ * Executable send messages command function. Resolves to the commit
+ * confirmations of the written partitions, empty against the legacy server.
  */
-export declare const sendMessages: (getClient: import("../../index.js").ClientProvider) => (arg: SendMessages) => Promise<boolean>;
+export declare const sendMessages: (getClient: import("../../client/client.type.js").ClientProvider) => (arg: SendMessages) => Promise<SendMessagesResponse>;
 //# sourceMappingURL=send-messages.command.d.ts.map

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

@@ -16,9 +16,46 @@
 // under the License.
 //
 import { serializeSendMessages } from './message.utils.js';
-import { deserializeStatusResponse } from '../../client/client.utils.js';
+import { DeserializeError } from '../error.utils.js';
 import { wrapCommand } from '../command.utils.js';
 import { COMMAND_CODE } from '../command.code.js';
+/** Size of the confirmation count prefixing the list. */
+const CONFIRMATIONS_COUNT_SIZE = 4;
+/**
+ * Size of one confirmation entry:
+ * `stream_id(4) + topic_id(4) + partition_id(4) + base_offset(8)`.
+ */
+const CONFIRMATION_SIZE = 20;
+/**
+ * Decodes the reply body of a send: `[confirmations_count:4]` then that many
+ * `[stream_id:4 topic_id:4 partition_id:4 base_offset:8]` entries.
+ *
+ * The legacy server reports a commit by sending no body at all, so absence
+ * decodes to no confirmations instead of surfacing as a decode failure.
+ */
+const deserializeSendMessages = (data) => {
+    if (data.length === 0)
+        return { confirmations: [] };
+    if (data.length < CONFIRMATIONS_COUNT_SIZE)
+        throw new DeserializeError('send messages confirmation count is truncated');
+    const count = data.readUInt32LE(0);
+    const expected = CONFIRMATIONS_COUNT_SIZE + count * CONFIRMATION_SIZE;
+    if (expected > data.length)
+        throw new DeserializeError('send messages confirmation list is truncated');
+    if (expected !== data.length)
+        throw new DeserializeError('send messages confirmations have trailing bytes');
+    const confirmations = new Array(count);
+    for (let index = 0; index < count; index += 1) {
+        const at = CONFIRMATIONS_COUNT_SIZE + index * CONFIRMATION_SIZE;
+        confirmations[index] = {
+            streamId: data.readUInt32LE(at),
+            topicId: data.readUInt32LE(at + 4),
+            partitionId: data.readUInt32LE(at + 8),
+            baseOffset: data.readBigUInt64LE(at + 12)
+        };
+    }
+    return { confirmations };
+};
 /**
  * Send messages command definition.
  * Publishes messages to a topic.
@@ -28,10 +65,11 @@ export const SEND_MESSAGES = {
     serialize: ({ streamId, topicId, messages, partition }) => {
         return serializeSendMessages(streamId, topicId, messages, partition);
     },
-    deserialize: deserializeStatusResponse
+    deserialize: (r) => deserializeSendMessages(r.data)
 };
 /**
- * Executable send messages command function.
+ * Executable send messages command function. Resolves to the commit
+ * confirmations of the written partitions, empty against the legacy server.
  */
 export const sendMessages = wrapCommand(SEND_MESSAGES);
 //# sourceMappingURL=send-messages.command.js.map

package/dist/wire/message/send-messages.command.test.js

@@ -18,10 +18,34 @@
 import { describe, it } from "node:test";
 import assert from "node:assert/strict";
 import { uuidv7, uuidv4 } from "uuidv7";
-import { SEND_MESSAGES } from "./send-messages.command.js";
+import { SEND_MESSAGES, } from "./send-messages.command.js";
 import { HeaderValue, HeaderKeyFactory } from "./header.utils.js";
+import { DeserializeError } from "../error.utils.js";
 const SUCCESS = 0;
-const ERROR = 1;
+const CONFIRMATION_SIZE = 20;
+const confirmation = (partitionId) => ({
+    streamId: 1,
+    topicId: 2,
+    partitionId,
+    baseOffset: 42n,
+});
+const serializeConfirmations = (confirmations) => {
+    const b = Buffer.allocUnsafe(4 + confirmations.length * CONFIRMATION_SIZE);
+    b.writeUInt32LE(confirmations.length, 0);
+    confirmations.forEach((c, index) => {
+        const at = 4 + index * CONFIRMATION_SIZE;
+        b.writeUInt32LE(c.streamId, at);
+        b.writeUInt32LE(c.topicId, at + 4);
+        b.writeUInt32LE(c.partitionId, at + 8);
+        b.writeBigUInt64LE(c.baseOffset, at + 12);
+    });
+    return b;
+};
+const response = (data) => ({
+    status: SUCCESS,
+    length: data.length,
+    data,
+});
 describe("SendMessages", () => {
     describe("serialize", () => {
         const t1 = {
@@ -150,19 +174,54 @@ describe("SendMessages", () => {
         });
     });
     describe('deserialize', () => {
-        it('returns true when status is SUCCESS with empty data', () => {
-            const r = { status: SUCCESS, length: 0, data: Buffer.alloc(0) };
-            assert.equal(SEND_MESSAGES.deserialize(r), true);
-        });
-        it('returns true when status is SUCCESS with non-empty server payload', () => {
-            // SendMessages server response includes data (e.g. partition/offset info).
-            // The deserializer must accept non-empty data unlike deserializeVoidResponse.
-            const r = { status: SUCCESS, length: 4, data: Buffer.from([1, 2, 3, 4]) };
-            assert.equal(SEND_MESSAGES.deserialize(r), true);
-        });
-        it('returns false when status is an error code', () => {
-            const r = { status: ERROR, length: 0, data: Buffer.alloc(0) };
-            assert.equal(SEND_MESSAGES.deserialize(r), false);
+        it('reads one confirmation', () => {
+            const confirmations = [confirmation(3)];
+            const r = response(serializeConfirmations(confirmations));
+            assert.deepEqual(SEND_MESSAGES.deserialize(r), { confirmations });
+        });
+        it('reads every confirmation of a multi-partition send', () => {
+            const confirmations = [confirmation(0), confirmation(1), confirmation(2)];
+            const r = response(serializeConfirmations(confirmations));
+            assert.deepEqual(SEND_MESSAGES.deserialize(r), { confirmations });
+        });
+        it('reads the wire layout of a confirmation', () => {
+            const r = response(Buffer.from([
+                0x01, 0x00, 0x00, 0x00, // count
+                0x01, 0x00, 0x00, 0x00, // streamId
+                0x02, 0x00, 0x00, 0x00, // topicId
+                0x03, 0x00, 0x00, 0x00, // partitionId
+                0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // baseOffset
+            ]));
+            assert.deepEqual(SEND_MESSAGES.deserialize(r), {
+                confirmations: [
+                    { streamId: 1, topicId: 2, partitionId: 3, baseOffset: 4n }
+                ]
+            });
+        });
+        it('reads a committed send that reports no offsets as an empty list', () => {
+            const r = response(serializeConfirmations([]));
+            assert.deepEqual(SEND_MESSAGES.deserialize(r), { confirmations: [] });
+        });
+        it('reads the bodiless legacy server reply as an empty list', () => {
+            const r = response(Buffer.alloc(0));
+            assert.deepEqual(SEND_MESSAGES.deserialize(r), { confirmations: [] });
+        });
+        it('throws on a truncated body', () => {
+            const data = serializeConfirmations([confirmation(0), confirmation(1)]);
+            for (let i = 1; i < data.length; i += 1)
+                assert.throws(() => SEND_MESSAGES.deserialize(response(data.subarray(0, i))), DeserializeError, `expected error for truncation at byte ${i}`);
+        });
+        it('throws on trailing bytes', () => {
+            const data = Buffer.concat([
+                serializeConfirmations([confirmation(1)]),
+                Buffer.from([0xFF])
+            ]);
+            assert.throws(() => SEND_MESSAGES.deserialize(response(data)), DeserializeError);
+        });
+        it('throws on a count no body could hold', () => {
+            const data = Buffer.alloc(4);
+            data.writeUInt32LE(0xFFFF_FFFF, 0);
+            assert.throws(() => SEND_MESSAGES.deserialize(response(data)), DeserializeError);
         });
     });
 });

package/dist/wire/vsr/register.d.ts

@@ -1,6 +1,6 @@
 /**
  * Packed protocol semver of the wire contract this port implements,
- * `pack(0, 10, 3)` per `core/binary_protocol/src/version.rs`. Bump together
+ * `pack(0, 11, 0)` per `core/binary_protocol/src/version.rs`. Bump together
  * with the Rust `IGGY_PROTOCOL_VERSION` on any wire-incompatible change.
  */
 export declare const IGGY_PROTOCOL_VERSION: number;

package/dist/wire/vsr/register.js

@@ -25,10 +25,10 @@
 import { DeserializeError } from '../error.utils.js';
 /**
  * Packed protocol semver of the wire contract this port implements,
- * `pack(0, 10, 3)` per `core/binary_protocol/src/version.rs`. Bump together
+ * `pack(0, 11, 0)` per `core/binary_protocol/src/version.rs`. Bump together
  * with the Rust `IGGY_PROTOCOL_VERSION` on any wire-incompatible change.
  */
-export const IGGY_PROTOCOL_VERSION = (0 << 20) | (10 << 10) | 3;
+export const IGGY_PROTOCOL_VERSION = (0 << 20) | (11 << 10) | 0;
 const SDK_NAME = 'node-sdk';
 const wireName = (value) => {
     const bytes = Buffer.from(value, 'utf8');

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "apache-iggy",
   "type": "module",
-  "version": "0.8.1-edge.4",
+  "version": "0.9.0-edge.1",
   "description": "Official Apache Iggy NodeJS SDK",
   "keywords": [
     "iggy",