apache-iggy 0.5.0-edge.1

package/dist/src/wire/message/header.utils.js

@@ -0,0 +1,248 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+import { boolToBuf, int8ToBuf, int16ToBuf, int32ToBuf, int64ToBuf, uint8ToBuf, uint16ToBuf, uint32ToBuf, uint64ToBuf, floatToBuf, doubleToBuf } from '../number.utils.js';
+import { HeaderKind, ReverseHeaderKind } from './header.type.js';
+export const serializeHeaderValue = (header) => {
+    const { kind, value } = header;
+    switch (kind) {
+        case HeaderKind.Raw: return value;
+        case HeaderKind.String: return Buffer.from(value);
+        case HeaderKind.Bool: return boolToBuf(value);
+        case HeaderKind.Int8: return int8ToBuf(value);
+        case HeaderKind.Int16: return int16ToBuf(value);
+        case HeaderKind.Int32: return int32ToBuf(value);
+        case HeaderKind.Int64: return int64ToBuf(value);
+        case HeaderKind.Int128: return value;
+        case HeaderKind.Uint8: return uint8ToBuf(value);
+        case HeaderKind.Uint16: return uint16ToBuf(value);
+        case HeaderKind.Uint32: return uint32ToBuf(value);
+        case HeaderKind.Uint64: return uint64ToBuf(value);
+        case HeaderKind.Uint128: return value;
+        case HeaderKind.Float: return floatToBuf(value);
+        case HeaderKind.Double: return doubleToBuf(value);
+    }
+};
+export const serializeHeader = (key, v) => {
+    const bKey = Buffer.from(key);
+    const b1 = uint32ToBuf(bKey.length);
+    const b2 = Buffer.alloc(5);
+    b2.writeUInt8(v.kind);
+    b2.writeUInt32LE(v.value.length, 1);
+    // @TODO debug
+    // console.log(
+    //   'SERIALIZE\n',
+    //   'KEY-LEN', b1.length, b1.toString('hex'), '=', b1.readUInt32LE(0), '\n',
+    //   'KEY', bKey.length, bKey.toString('hex'), '\n',
+    //   'KIND', b2.readUInt8(0), b2.subarray(0, 1).toString('hex'), '\n',
+    //   'V-LEN', b2.readUInt32LE(1), b2.subarray(1, 5).toString('hex'), '\n',
+    //   'V', v.value.length, v.value.toString('hex')
+    // );
+    return Buffer.concat([
+        b1,
+        bKey,
+        b2,
+        v.value
+    ]);
+};
+export const EMPTY_HEADERS = Buffer.alloc(0);
+const createHeaderValue = (header) => ({
+    kind: header.kind,
+    value: serializeHeaderValue(header)
+});
+export const serializeHeaders = (headers) => {
+    if (!headers)
+        return EMPTY_HEADERS;
+    return Buffer.concat(Object.keys(headers).map((c) => serializeHeader(c, createHeaderValue(headers[c]))));
+};
+export const mapHeaderKind = (k) => {
+    if (!ReverseHeaderKind[k])
+        throw new Error(`unknow header kind: ${k}`);
+    return ReverseHeaderKind[k];
+};
+export const deserializeHeaderValue = (kind, value) => {
+    switch (kind) {
+        case HeaderKind.Int128:
+        case HeaderKind.Uint128:
+        case HeaderKind.Raw: return value;
+        case HeaderKind.String: return value.toString();
+        case HeaderKind.Int8: return value.readInt8();
+        case HeaderKind.Int16: return value.readInt16LE();
+        case HeaderKind.Int32: return value.readInt32LE();
+        case HeaderKind.Int64: return value.readBigInt64LE();
+        case HeaderKind.Uint8: return value.readUint8();
+        case HeaderKind.Uint16: return value.readUint16LE();
+        case HeaderKind.Uint32: return value.readUInt32LE();
+        case HeaderKind.Uint64: return value.readBigUInt64LE();
+        case HeaderKind.Bool: return value.readUInt8() === 1;
+        case HeaderKind.Float: return value.readFloatLE();
+        case HeaderKind.Double: return value.readDoubleLE();
+        default: throw new Error(`deserializeHeaderValue: invalid HeaderKind ${kind}`);
+    }
+};
+export const deserializeHeader = (p, pos = 0) => {
+    const keyLength = p.readUInt32LE(pos);
+    const key = p.subarray(pos + 4, pos + 4 + keyLength).toString();
+    pos += keyLength + 4;
+    const rawKind = p.readUInt8(pos);
+    // @TODO ?
+    // const kind = mapHeaderKind(rawKind); 
+    const valueLength = p.readUInt32LE(pos + 1);
+    const value = deserializeHeaderValue(rawKind, p.subarray(pos + 5, pos + 5 + valueLength));
+    return {
+        bytesRead: 4 + 4 + 1 + keyLength + valueLength,
+        data: {
+            key,
+            kind: rawKind,
+            value
+        }
+    };
+};
+export const deserializeHeaders = (p, pos = 0) => {
+    const headers = {};
+    const len = p.length;
+    while (pos < len) {
+        const { bytesRead, data: { kind, key, value } } = deserializeHeader(p, pos);
+        headers[key] = { kind, value };
+        pos += bytesRead;
+    }
+    return headers;
+};
+/** HeaderValue Helper */
+const Raw = (value) => ({
+    kind: HeaderKind.Raw,
+    value
+});
+const String = (value) => ({
+    kind: HeaderKind.String,
+    value
+});
+const Bool = (value) => ({
+    kind: HeaderKind.Bool,
+    value
+});
+const Int8 = (value) => ({
+    kind: HeaderKind.Int8,
+    value
+});
+const Int16 = (value) => ({
+    kind: HeaderKind.Int16,
+    value
+});
+const Int32 = (value) => ({
+    kind: HeaderKind.Int32,
+    value
+});
+const Int64 = (value) => ({
+    kind: HeaderKind.Int64,
+    value
+});
+const Int128 = (value) => ({
+    kind: HeaderKind.Int128,
+    value
+});
+const Uint8 = (value) => ({
+    kind: HeaderKind.Uint8,
+    value
+});
+const Uint16 = (value) => ({
+    kind: HeaderKind.Uint16,
+    value
+});
+const Uint32 = (value) => ({
+    kind: HeaderKind.Uint32,
+    value
+});
+const Uint64 = (value) => ({
+    kind: HeaderKind.Uint64,
+    value
+});
+const Uint128 = (value) => ({
+    kind: HeaderKind.Uint128,
+    value
+});
+const Float = (value) => ({
+    kind: HeaderKind.Float,
+    value
+});
+const Double = (value) => ({
+    kind: HeaderKind.Double,
+    value
+});
+const getKind = (h) => mapHeaderKind(h.kind);
+const getValue = (h) => h.value;
+export const HeaderValue = {
+    Raw,
+    String,
+    Bool,
+    Int8,
+    Int16,
+    Int32,
+    Int64,
+    Int128,
+    Uint8,
+    Uint16,
+    Uint32,
+    Uint64,
+    Uint128,
+    Float,
+    Double,
+    getKind,
+    getValue
+};
+// export type InputHeaderValue = boolean | number | string | bigint | Buffer;
+// export type InputHeaders = Record<string, InputHeaderValue>;
+// const isFloat = (n: number) => n % 1 !== 0;
+// export const createHeaderValueFloat = (v: number): HeaderValue =>
+//   ({ kind: HeaderKind.Float, value: floatToBuf(v) });
+// export const createHeaderValueDouble = (v: number): HeaderValue =>
+//   ({ kind: HeaderKind.Double, value: doubleToBuf(v) });
+// export const createHeaderValueInt32 = (v: number): HeaderValue =>
+//   ({ kind: HeaderKind.Int32, value: int32ToBuf(v) });
+// export const createHeaderValueInt64 = (v: bigint): HeaderValue =>
+//   ({ kind: HeaderKind.Int64, value: int64ToBuf(v) });
+// export const createHeaderValueUInt32 = (v: number): HeaderValue =>
+//   ({ kind: HeaderKind.Uint32, value: uint32ToBuf(v) });
+// export const createHeaderValueUInt64 = (v: bigint): HeaderValue =>
+//   ({ kind: HeaderKind.Uint64, value: uint64ToBuf(v) });
+// export const createHeaderValueBool = (v: boolean): HeaderValue =>
+//   ({ kind: HeaderKind.Bool, value: boolToBuf(v) });
+// export const createHeaderValueBuffer = (v: Buffer): HeaderValue =>
+//   ({ kind: HeaderKind.Raw, value: v });
+// export const createHeaderValueString = (v: string): HeaderValue =>
+//   ({ kind: HeaderKind.String, value: Buffer.from(v) });
+// // guess wire type from js type ?
+// const guessHeaderValue = (v: InputHeaderValue): HeaderValue => {
+//   if (typeof v === 'number') {
+//     if (isFloat(v))
+//       return createHeaderValueFloat(v);
+//     else
+//       return createHeaderValueInt32(v); // BAD KARMA
+//   }
+//   if (typeof v === 'bigint') {
+//     return createHeaderValueInt64(v); // BAD KARMA
+//   }
+//   if (typeof v === 'boolean')
+//     return createHeaderValueBool(v);
+//   if (typeof v === 'string')
+//     return createHeaderValueString(v);
+//   if (v instanceof Buffer)
+//     return createHeaderValueBuffer(v);
+//   throw new Error(`unable to serialize headers param ${v} - ${typeof v}`)
+// }
+//# sourceMappingURL=header.utils.js.map

package/dist/src/wire/message/header.utils.test.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+export {};
+//# sourceMappingURL=header.utils.test.d.ts.map

package/dist/src/wire/message/header.utils.test.js

@@ -0,0 +1,39 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import { uuidv7, uuidv4 } from 'uuidv7';
+import { serializeHeaders, deserializeHeaders, HeaderValue } from './header.utils.js';
+describe('Headers', () => {
+    const headers = {
+        'p': HeaderValue.Bool(true),
+        'x': HeaderValue.Uint32(123),
+        'y': HeaderValue.Uint64(42n),
+        'z': HeaderValue.Float(42.20000076293945),
+        'a': HeaderValue.Double(1 / 3),
+        'ID': HeaderValue.String(uuidv7()),
+        'val': HeaderValue.Raw(Buffer.from(uuidv4()))
+    };
+    it('serialize/deserialize', () => {
+        const s = serializeHeaders(headers);
+        const d = deserializeHeaders(s);
+        assert.deepEqual(headers, d);
+    });
+});
+//# sourceMappingURL=header.utils.test.js.map

package/dist/src/wire/message/iggy-header.utils.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+export type IggyMessageHeader = {
+    checksum: bigint;
+    id: string | BigInt;
+    offset: bigint;
+    timestamp: Date;
+    originTimestamp: Date;
+    userHeadersLength: number;
+    payloadLength: number;
+};
+export declare const IGGY_MESSAGE_HEADER_SIZE: number;
+export declare const serializeIggyMessageHeader: (id: Buffer, payload: Buffer, userHeaders: Buffer) => Buffer<ArrayBuffer>;
+export declare const deserialiseMessageId: (b: Buffer) => bigint;
+export declare const deserializeIggyMessageHeaders: (b: Buffer) => IggyMessageHeader;
+//# sourceMappingURL=iggy-header.utils.d.ts.map

package/dist/src/wire/message/iggy-header.utils.js

@@ -0,0 +1,50 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+import { toDate } from "../serialize.utils.js";
+import { u128LEBufToBigint } from "../number.utils.js";
+// u64 + u128 + u64 + u64 + u64 + u32 + u32
+export const IGGY_MESSAGE_HEADER_SIZE = 8 + 16 + 8 + 8 + 8 + 4 + 4;
+export const serializeIggyMessageHeader = (id, payload, userHeaders) => {
+    const b = Buffer.allocUnsafe(IGGY_MESSAGE_HEADER_SIZE);
+    b.writeBigUInt64LE(0n, 0); // checksum u64
+    b.fill(id, 8, 24); // id u128
+    b.writeBigUInt64LE(0n, 24); // offset u64
+    b.writeBigUInt64LE(0n, 32); // timestamp u64
+    b.writeBigUint64LE(BigInt(new Date().getTime()), 40); // originTimestamp u64
+    b.writeUInt32LE(userHeaders.length, 48); // userHeaders len u32
+    b.writeUInt32LE(payload.length, 52); // payload len u32
+    return b;
+};
+export const deserialiseMessageId = (b) => u128LEBufToBigint(b);
+export const deserializeIggyMessageHeaders = (b) => {
+    if (b.length !== IGGY_MESSAGE_HEADER_SIZE)
+        throw new Error(`deserialize message headers error, length = ${b.length} ` +
+            `expected ${IGGY_MESSAGE_HEADER_SIZE}`);
+    const headers = {
+        checksum: b.readBigUInt64LE(0),
+        id: deserialiseMessageId(b.subarray(8, 24)),
+        offset: b.readBigUInt64LE(24),
+        timestamp: toDate(b.readBigUInt64LE(32)),
+        originTimestamp: toDate(b.readBigUInt64LE(40)),
+        userHeadersLength: b.readUInt32LE(48),
+        payloadLength: b.readUInt32LE(52)
+    };
+    return headers;
+};
+//# sourceMappingURL=iggy-header.utils.js.map

package/dist/src/wire/message/index.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+export * from './poll-messages.command.js';
+export * from './send-messages.command.js';
+export * from './message.utils.js';
+export * from "./poll.utils.js";
+export { Partitioning } from './partitioning.utils.js';
+export { HeaderValue } from './header.utils.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/wire/message/index.js

@@ -0,0 +1,25 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+export * from './poll-messages.command.js';
+export * from './send-messages.command.js';
+export * from './message.utils.js';
+export * from "./poll.utils.js";
+export { Partitioning } from './partitioning.utils.js';
+export { HeaderValue } from './header.utils.js';
+//# sourceMappingURL=index.js.map

package/dist/src/wire/message/message.utils.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+import { type Headers } from './header.utils.js';
+import { type Id } from '../identifier.utils.js';
+import { type Partitioning } from './partitioning.utils.js';
+export type MessageIdKind = number | bigint | string;
+export type CreateMessage = {
+    id?: MessageIdKind;
+    headers?: Headers;
+    payload: string | Buffer;
+};
+export declare const isValidMessageId: (x?: unknown) => x is MessageIdKind;
+export declare const serializeMessageId: (id?: unknown) => Buffer<ArrayBufferLike>;
+export declare const serializeMessage: (msg: CreateMessage) => Buffer<ArrayBuffer>;
+export declare const serializeMessages: (messages: CreateMessage[]) => Buffer<ArrayBuffer>[];
+export declare const createMessagesIndex: (messages: Buffer[]) => Buffer<ArrayBuffer>;
+export declare const serializeSendMessages: (streamId: Id, topicId: Id, messages: CreateMessage[], partitioning?: Partitioning) => Buffer<ArrayBuffer>;
+export declare const serializeFlushUnsavedBuffers: (streamId: Id, topicId: Id, partitionId: number, fsync?: boolean) => Buffer<ArrayBuffer>;
+//# sourceMappingURL=message.utils.d.ts.map

package/dist/src/wire/message/message.utils.js

@@ -0,0 +1,112 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+import Debug from 'debug';
+import { uint32ToBuf, u128ToBuf, uint8ToBuf } from '../number.utils.js';
+import { serializeHeaders } from './header.utils.js';
+import { serializeIdentifier } from '../identifier.utils.js';
+import { serializePartitioning } from './partitioning.utils.js';
+import { parse as parseUUID } from '../uuid.utils.js';
+import { serializeIggyMessageHeader } from './iggy-header.utils.js';
+const debug = Debug('iggy:client');
+/** index size per messages in bit */
+const INDEX_SIZE = 16;
+export const isValidMessageId = (x) => x === undefined ||
+    'string' === typeof x ||
+    'bigint' === typeof x ||
+    'number' === typeof x;
+export const serializeMessageId = (id) => {
+    if (!isValidMessageId(id))
+        throw new Error(`invalid message id: '${id}' (use uuid string | number | bigint >= 0)`);
+    if (id === undefined)
+        return Buffer.alloc(16, 0); // 0u128
+    if ('bigint' === typeof id || 'number' === typeof id) {
+        if (id < 0)
+            throw new Error(`invalid message id: '${id}' (numeric id must be >= 0)`);
+        const idValue = 'number' === typeof id ? BigInt(id) : id;
+        return u128ToBuf(idValue);
+    }
+    try {
+        const uuid = parseUUID(id);
+        return Buffer.from(uuid.toHex(), 'hex');
+    }
+    catch (err) {
+        throw new Error(`invalid message id: '${id}' (use uuid string | number | bigint >= 0)`, { cause: err });
+    }
+};
+export const serializeMessage = (msg) => {
+    const { id, headers, payload } = msg;
+    const bId = serializeMessageId(id);
+    const bUserHeaders = serializeHeaders(headers);
+    const bPayload = 'string' === typeof payload ? Buffer.from(payload) : payload;
+    const bIggyMessageHeader = serializeIggyMessageHeader(bId, bPayload, bUserHeaders);
+    const r = Buffer.concat([
+        bIggyMessageHeader,
+        bPayload,
+        bUserHeaders
+    ]);
+    debug('id', bId.length, bId.toString('hex'), 'iggyHeaders', bIggyMessageHeader.length, bIggyMessageHeader.toString('hex'), 'userHeaders', bUserHeaders.length, bUserHeaders.toString('hex'), 'payload', bPayload.length, bPayload.toString('hex'), 'full len', r.length //, r.toString('hex')
+    );
+    return r;
+};
+export const serializeMessages = (messages) => messages.map(c => serializeMessage(c));
+export const createMessagesIndex = (messages) => {
+    const bIndex = Buffer.allocUnsafe(messages.length * INDEX_SIZE);
+    let currentIndex = 0;
+    let msgsSize = 0;
+    messages.forEach(msg => {
+        msgsSize += msg.length;
+        bIndex.writeBigUInt64LE(0n, currentIndex);
+        bIndex.writeUInt32LE(msgsSize, currentIndex + 4);
+        bIndex.writeBigUInt64LE(0n, currentIndex + 8);
+        currentIndex += INDEX_SIZE;
+    });
+    return bIndex;
+};
+export const serializeSendMessages = (streamId, topicId, messages, partitioning) => {
+    const streamIdentifier = serializeIdentifier(streamId);
+    const topicIdentifier = serializeIdentifier(topicId);
+    const bPartitioning = serializePartitioning(partitioning);
+    const bMessagesCount = uint32ToBuf(messages.length);
+    const bMetadataLen = uint32ToBuf(streamIdentifier.length + topicIdentifier.length +
+        bPartitioning.length + bMessagesCount.length);
+    const bMessagesArray = serializeMessages(messages);
+    const bMessageIndex = createMessagesIndex(bMessagesArray);
+    return Buffer.concat([
+        bMetadataLen,
+        streamIdentifier,
+        topicIdentifier,
+        bPartitioning,
+        bMessagesCount,
+        bMessageIndex,
+        ...bMessagesArray
+    ]);
+};
+export const serializeFlushUnsavedBuffers = (streamId, topicId, partitionId, fsync = false) => {
+    const streamIdentifier = serializeIdentifier(streamId);
+    const topicIdentifier = serializeIdentifier(topicId);
+    const bPartitionId = uint32ToBuf(partitionId);
+    const bFSync = uint8ToBuf(fsync ? 1 : 0);
+    return Buffer.concat([
+        streamIdentifier,
+        topicIdentifier,
+        bPartitionId,
+        bFSync
+    ]);
+};
+//# sourceMappingURL=message.utils.js.map

package/dist/src/wire/message/partitioning.utils.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+import type { ValueOf } from '../../type.utils.js';
+export declare const PartitionKind: {
+    readonly Balanced: 1;
+    readonly PartitionId: 2;
+    readonly MessageKey: 3;
+};
+export type PartitionKind = typeof PartitionKind;
+export type PartitionKindId = keyof PartitionKind;
+export type PartitionKindValue = ValueOf<PartitionKind>;
+export type Balanced = {
+    kind: PartitionKind['Balanced'];
+    value: null;
+};
+export type PartitionId = {
+    kind: PartitionKind['PartitionId'];
+    value: number;
+};
+export type MessageKeyValue = string | number | bigint | Buffer;
+export type MessageKey = {
+    kind: PartitionKind['MessageKey'];
+    value: MessageKeyValue;
+};
+export type Partitioning = Balanced | PartitionId | MessageKey;
+export declare const Partitioning: {
+    Balanced: Balanced;
+    PartitionId: (id: number) => PartitionId;
+    MessageKey: (key: MessageKeyValue) => MessageKey;
+};
+export declare const serializeMessageKey: (v: MessageKeyValue) => Buffer<ArrayBuffer>;
+export declare const serializePartitioningValue: (part: Partitioning) => Buffer;
+export declare const default_partionning: Balanced;
+export declare const serializePartitioning: (p?: Partitioning) => Buffer<ArrayBuffer>;
+//# sourceMappingURL=partitioning.utils.d.ts.map