apache-iggy 0.5.2 → 0.6.0-edge.2

package/dist/e2e/tcp.topic.e2e.js

@@ -21,59 +21,54 @@ import assert from 'node:assert/strict';
 import { getTestClient } from './test-client.utils.js';
 describe('e2e -> topic', async () => {
     const c = getTestClient();
-    const streamId = 111;
-    const topicId = 123;
-    await c.stream.create({ streamId, name: 'e2e-tcp-topic-stream' });
+    const streamName = 'e2e-tcp-topic-stream';
+    const topicName = 'e2e-tcp-topic-topic-123';
+    await c.stream.create({ name: streamName });
     it('e2e -> topic::create', async () => {
-        const topic = await c.topic.create({
-            streamId, topicId,
-            name: 'e2e-tcp-topic',
+        const TOPIC = await c.topic.create({
+            streamId: streamName,
+            name: topicName,
             partitionCount: 0,
             compressionAlgorithm: 1,
             messageExpiry: 0n,
             replicationFactor: 1
         });
-        assert.ok(topic);
+        assert.ok(TOPIC);
     });
     it('e2e -> topic::list', async () => {
-        const topics = await c.topic.list({ streamId });
+        const topics = await c.topic.list({ streamId: streamName });
         assert.ok(topics.length > 0);
     });
     it('e2e -> topic::get', async () => {
-        const topic = await c.topic.get({ streamId, topicId });
+        const topic = await c.topic.get({ streamId: streamName, topicId: topicName });
         assert.ok(topic);
     });
     it('e2e -> topic::createPartition', async () => {
         const cp = await c.partition.create({
-            streamId, topicId,
+            streamId: streamName,
+            topicId: topicName,
             partitionCount: 22
         });
         assert.ok(cp);
     });
     it('e2e -> topic::deletePartition', async () => {
         const dp = await c.partition.delete({
-            streamId, topicId,
+            streamId: streamName,
+            topicId: topicName,
             partitionCount: 19
         });
         assert.ok(dp);
     });
-    it('e2e -> topic::update', async () => {
-        const topic = await c.topic.get({ streamId, topicId });
-        const u2 = await c.topic.update({
-            streamId, topicId,
-            name: topic.name,
-            messageExpiry: 42n
-        });
-        assert.ok(u2);
-    });
     it('e2e -> topic::purge', async () => {
-        assert.ok(await c.topic.purge({ streamId, topicId }));
+        assert.ok(await c.topic.purge({ streamId: streamName, topicId: topicName }));
     });
     it('e2e -> topic::delete', async () => {
-        assert.ok(await c.topic.delete({ streamId, topicId, partitionsCount: 0 }));
+        assert.ok(await c.topic.delete({
+            streamId: streamName, topicId: topicName, partitionsCount: 0
+        }));
     });
     it('e2e -> topic::cleanup', async () => {
-        assert.ok(await c.stream.delete({ streamId }));
+        assert.ok(await c.stream.delete({ streamId: streamName }));
         assert.ok(await c.session.logout());
     });
     after(() => {

package/dist/e2e/tcp.user.e2e.js

@@ -55,11 +55,13 @@ describe('e2e -> user', async () => {
     });
     it('e2e -> user::get#id', async () => {
         const u1 = await c.user.get({ userId: username });
+        assert.ok(u1);
         const u2 = await c.user.get({ userId: u1.id });
         assert.deepEqual(u1, u2);
     });
     it('e2e -> user::update', async () => {
         const user = await c.user.get({ userId: username });
+        assert.ok(user);
         const u2 = await c.user.update({
             userId: user.id,
             status: 2
@@ -68,12 +70,14 @@ describe('e2e -> user', async () => {
     });
     it('e2e -> user::changePassword', async () => {
         const user = await c.user.get({ userId: username });
+        assert.ok(user);
         assert.ok(await c.user.changePassword({
             userId: user.id, currentPassword: password, newPassword: 'h4x0r42'
         }));
     });
     it('e2e -> user::updatePermissions', async () => {
         const user = await c.user.get({ userId: username });
+        assert.ok(user);
         const perms2 = { ...permissions };
         perms2.global.ReadServers = true;
         const u2 = await c.user.updatePermissions({
@@ -83,6 +87,7 @@ describe('e2e -> user', async () => {
     });
     it('e2e -> user::delete', async () => {
         const user = await c.user.get({ userId: username });
+        assert.ok(user);
         assert.ok(await c.user.delete({ userId: user.id }));
     });
     it('e2e -> user::logout', async () => {

package/dist/stream/consumer-stream.d.ts

@@ -33,8 +33,8 @@ export type SingleConsumerStreamRequest = ConsumerStreamRequest & {
     partitionId: number;
 };
 export type GroupConsumerStreamRequest = ConsumerStreamRequest & {
-    groupId: number;
+    groupName: string;
 };
 export declare const singleConsumerStream: (config: ClientConfig) => ({ streamId, topicId, partitionId, pollingStrategy, count, interval, autocommit, endOnLastOffset }: SingleConsumerStreamRequest) => Promise<Readable>;
-export declare const groupConsumerStream: (config: ClientConfig) => ({ groupId, streamId, topicId, pollingStrategy, count, interval, autocommit, endOnLastOffset }: GroupConsumerStreamRequest) => Promise<Readable>;
+export declare const groupConsumerStream: (config: ClientConfig) => ({ groupName, streamId, topicId, pollingStrategy, count, interval, autocommit, endOnLastOffset }: GroupConsumerStreamRequest) => Promise<Readable>;
 //# sourceMappingURL=consumer-stream.d.ts.map

package/dist/stream/consumer-stream.js

@@ -19,7 +19,6 @@
 import { Readable } from "node:stream";
 import { getClient } from "../client/client.js";
 import { Consumer } from "../wire/index.js";
-import { debug } from "../client/client.debug.js";
 const wait = (interval, cb) => new Promise((resolve) => {
     setTimeout(() => resolve(cb ? cb() : undefined), interval);
 });
@@ -52,23 +51,14 @@ export const singleConsumerStream = (config) => async ({ streamId, topicId, part
     const ps = Readable.from(genEagerUntilPoll(c, poll, interval, endOnLastOffset), { objectMode: true });
     return ps;
 };
-export const groupConsumerStream = (config) => async function groupConsumerStream({ groupId, streamId, topicId, pollingStrategy, count, interval = 1000, autocommit = true, endOnLastOffset = false }) {
+export const groupConsumerStream = (config) => async function groupConsumerStream({ groupName, streamId, topicId, pollingStrategy, count, interval = 1000, autocommit = true, endOnLastOffset = false }) {
     const s = await getClient(config);
-    try {
-        await s.group.get({ streamId, topicId, groupId });
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    }
-    catch (err) {
-        const ng = { streamId, topicId, groupId, name: `auto-${groupId}` };
-        debug('group does not exist, creating it', ng);
-        await s.group.create(ng);
-    }
-    await s.group.join({ streamId, topicId, groupId });
+    await s.group.ensureAndJoin(streamId, topicId, groupName);
     const poll = {
         streamId,
         topicId,
-        consumer: Consumer.Group(groupId),
-        partitionId: 0,
+        consumer: Consumer.Group(groupName),
+        partitionId: null,
         pollingStrategy,
         count,
         autocommit

package/dist/tcp.e2e.js

@@ -16,6 +16,7 @@
  * specific language governing permissions and limitations
  * under the License.
  */
+import assert from 'node:assert/strict';
 import { getRawClient } from './client/index.js';
 import { login, logout, updateStream, getStream, getStreams, updateTopic, getTopic, getTopics, createPartition, deletePartition, createTopic, deleteTopic, createStream, deleteStream, } from './wire/index.js';
 try {
@@ -66,6 +67,7 @@ try {
     // GET_TOPIC
     const t2 = await getTopic(s)({ streamId: topic1.streamId, topicId: topic1.name });
     console.log('RESPONSE_getTopic', t2);
+    assert.ok(t2);
     // UPDATE_TOPIC
     const r_updateTopic = await updateTopic(s)({
         streamId: topic1.streamId, topicId: topic1.topicId, name: topic1.name, messageExpiry: 42n

package/dist/wire/client/get-client.command.d.ts

@@ -24,7 +24,7 @@ export type GetClient = {
 export declare const GET_CLIENT: {
     code: number;
     serialize: ({ clientId }: GetClient) => Buffer;
-    deserialize: (r: CommandResponse) => Client;
+    deserialize: (r: CommandResponse) => Client | null;
 };
-export declare const getClient: (getClient: import("../../client/client.type.js").ClientProvider) => (arg: GetClient) => Promise<Client>;
+export declare const getClient: (getClient: import("../../client/client.type.js").ClientProvider) => (arg: GetClient) => Promise<Client | null>;
 //# sourceMappingURL=get-client.command.d.ts.map

package/dist/wire/client/get-client.command.js

@@ -27,7 +27,11 @@ export const GET_CLIENT = {
         b.writeUInt32LE(clientId);
         return b;
     },
-    deserialize: (r) => deserializeClient(r.data).data
+    deserialize: (r) => {
+        if (r.status === 0 && r.length === 0)
+            return null;
+        return deserializeClient(r.data).data;
+    }
 };
 export const getClient = wrapCommand(GET_CLIENT);
 //# sourceMappingURL=get-client.command.js.map

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

@@ -0,0 +1,54 @@
+/**
+ * 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 ClusterNodeRole: {
+    readonly Leader: 0;
+    readonly Follower: 1;
+};
+export type ClusterNodeRole = typeof ClusterNodeRole;
+export type ClusterNodeRoleKey = keyof ClusterNodeRole;
+export type ClusterNodeRoleValue = ValueOf<ClusterNodeRole>;
+export declare const ReverseClusterNodeRole: Record<0 | 1, "Leader" | "Follower">;
+export declare const ClusterNodeStatus: {
+    readonly Healthy: 0;
+    readonly Starting: 1;
+    readonly Stopping: 2;
+    readonly Unreachable: 3;
+    readonly Maintenance: 4;
+};
+export type ClusterNodeStatus = typeof ClusterNodeStatus;
+export type ClusterNodeStatusKey = keyof ClusterNodeStatus;
+export type ClusterNodeStatusValue = ValueOf<ClusterNodeStatus>;
+export declare const ReverseClusterNodeStatus: Record<0 | 1 | 2 | 4 | 3, "Healthy" | "Starting" | "Stopping" | "Unreachable" | "Maintenance">;
+export declare const TransportProtocol: {
+    readonly TCP: 1;
+    readonly QUIC: 2;
+    readonly HTTP: 3;
+};
+export type TransportProtocol = typeof TransportProtocol;
+export type TransportProtocolKey = keyof TransportProtocol;
+export type TransportProtocolValue = ValueOf<TransportProtocol>;
+export declare const ReverseTransportProtocol: Record<1 | 2 | 3, "TCP" | "QUIC" | "HTTP">;
+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;
+export declare const mapClusterNodeRole: (n: number) => ClusterNodeRoleKey;
+export declare const mapClusterNodeStatus: (n: number) => ClusterNodeStatusKey;
+export declare const mapTransportProtocol: (n: number) => TransportProtocolKey;
+//# sourceMappingURL=cluster.type.d.ts.map

package/dist/wire/cluster/cluster.type.js

@@ -0,0 +1,62 @@
+/**
+ * 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 { reverseRecord } from "../../type.utils.js";
+export const ClusterNodeRole = {
+    Leader: 0,
+    Follower: 1
+};
+export const ReverseClusterNodeRole = reverseRecord(ClusterNodeRole);
+export const ClusterNodeStatus = {
+    // Node is healthy and responsive
+    Healthy: 0,
+    // Node is starting up
+    Starting: 1,
+    // Node is shutting down
+    Stopping: 2,
+    // Node is unreachable
+    Unreachable: 3,
+    // Node is in maintenance mode
+    Maintenance: 4,
+};
+export const ReverseClusterNodeStatus = reverseRecord(ClusterNodeStatus);
+export const TransportProtocol = {
+    TCP: 1,
+    QUIC: 2,
+    HTTP: 3
+};
+export const ReverseTransportProtocol = reverseRecord(TransportProtocol);
+export const isClusterNodeRole = (n) => n in ReverseClusterNodeRole;
+export const isClusterNodeStatus = (n) => n in ReverseClusterNodeStatus;
+export const isTransportProtocol = (n) => n in ReverseTransportProtocol;
+export const mapClusterNodeRole = (n) => {
+    if (!isClusterNodeRole(n))
+        throw new Error('Invalid ClusterNodeRole', { cause: { role: n, ClusterNodeRole } });
+    return ReverseClusterNodeRole[n];
+};
+export const mapClusterNodeStatus = (n) => {
+    if (!isClusterNodeStatus(n))
+        throw new Error('Invalid ClusterNodeStatus', { cause: { status: n, ClusterNodeStatus } });
+    return ReverseClusterNodeStatus[n];
+};
+export const mapTransportProtocol = (n) => {
+    if (!isTransportProtocol(n))
+        throw new Error('Invalid TransportProtocol', { cause: { transport: n, TransportProtocol } });
+    return ReverseTransportProtocol[n];
+};
+//# sourceMappingURL=cluster.type.js.map

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

@@ -0,0 +1,40 @@
+/**
+ * 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 ClusterNodeRoleKey, type ClusterNodeStatusKey, type TransportProtocolKey } from './cluster.type.js';
+export type ClusterNode = {
+    id: number;
+    name: string;
+    address: string;
+    role: ClusterNodeRoleKey;
+    status: ClusterNodeStatusKey;
+};
+type DeserializedClusterNode = {
+    length: number;
+    data: ClusterNode;
+};
+export declare const deserializeNode: (b: Buffer, pos?: number) => DeserializedClusterNode;
+export type ClusterMetadata = {
+    name: string;
+    id: number;
+    transport: TransportProtocolKey;
+    nodes: ClusterNode[];
+};
+export declare const deserializeMetadata: (b: Buffer, pos?: number) => ClusterMetadata;
+export {};
+//# sourceMappingURL=cluster.utils.d.ts.map

package/dist/wire/cluster/cluster.utils.js

@@ -0,0 +1,85 @@
+/**
+ * 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 { deserializeError } from '../error.utils.js';
+import { mapClusterNodeRole, mapClusterNodeStatus, mapTransportProtocol, } from './cluster.type.js';
+const CLUSTER_NODE_MIN_BUFFER_SIZE = 16; // 4 + 1 + 4 + 1 + 4 + 1 + 1;
+export const deserializeNode = (b, pos = 0) => {
+    if (b.length - pos < CLUSTER_NODE_MIN_BUFFER_SIZE)
+        deserializeError('cluster node', pos, b.length, CLUSTER_NODE_MIN_BUFFER_SIZE);
+    const id = b.readUInt32LE(pos);
+    pos += 4;
+    const nameLen = b.readUInt32LE(pos);
+    if (b.length - pos < 4 + nameLen)
+        deserializeError('cluster node', pos, b.length, 4 + nameLen, { id, nameLen });
+    const name = b.subarray(pos + 4, pos + 4 + nameLen).toString();
+    pos += nameLen + 4;
+    const addrLen = b.readUInt32LE(pos);
+    if (b.length - pos < 4 + addrLen)
+        deserializeError('cluster node', pos, b.length, 4 + addrLen, { id, nameLen, name, addrLen });
+    const address = b.subarray(pos + 4, pos + 4 + addrLen).toString();
+    pos += addrLen + 4;
+    if (b.length - pos < 2)
+        deserializeError('cluster node', pos, b.length, 2, { id, nameLen, name, addrLen, address });
+    const role = mapClusterNodeRole(b.readUInt8(pos));
+    pos += 1;
+    const status = mapClusterNodeStatus(b.readUInt8(pos));
+    pos += 1;
+    return {
+        length: 4 + nameLen + 4 + addrLen + 4 + 1 + 1,
+        data: {
+            id,
+            name,
+            address,
+            role,
+            status
+        }
+    };
+};
+// min = 4 + 1 + 4 + 1 + 1 + 4 + CLUSTER_NODE_MIN_BUFFER_SIZE;
+const CLUSTER_METADATA_MIN_SIZE = 15 + CLUSTER_NODE_MIN_BUFFER_SIZE;
+export const deserializeMetadata = (b, pos = 0) => {
+    if (b.length - pos < CLUSTER_METADATA_MIN_SIZE)
+        deserializeError('cluster metadata', pos, b.length, CLUSTER_METADATA_MIN_SIZE);
+    const nameLen = b.readUInt32LE(pos);
+    if (b.length - pos < 4 + nameLen)
+        deserializeError('cluster metadata', pos, b.length, 4 + nameLen, { nameLen });
+    const name = b.subarray(pos + 4, pos + 4 + nameLen).toString();
+    pos += nameLen + 4;
+    if (b.length - pos < 4 + 1 + 4)
+        deserializeError('cluster metadata', pos, b.length, 4 + 1 + 4, { nameLen, name });
+    const id = b.readUInt32LE(pos);
+    pos += 4;
+    const transport = mapTransportProtocol(b.readUInt8(pos));
+    pos += 1;
+    const nodeCount = b.readUInt32LE(pos);
+    pos += 4;
+    const nodes = [];
+    for (let i = 0; i < nodeCount; i++) {
+        const { length, data } = deserializeNode(b, pos);
+        nodes.push(data);
+        pos += length;
+    }
+    return {
+        name,
+        id,
+        transport,
+        nodes
+    };
+};
+//# sourceMappingURL=cluster.utils.js.map

package/dist/wire/cluster/get-cluster-metadata.command.d.ts

@@ -0,0 +1,27 @@
+/**
+ * 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 { CommandResponse } from '../../client/index.js';
+import { type ClusterMetadata } from './cluster.utils.js';
+export declare const GET_CLUSTER_METADATA: {
+    code: number;
+    serialize: () => Buffer<ArrayBuffer>;
+    deserialize: (r: CommandResponse) => ClusterMetadata;
+};
+export declare const getClusterMetadata: (getClient: import("../../client/client.type.js").ClientProvider) => (arg: void) => Promise<ClusterMetadata>;
+//# sourceMappingURL=get-cluster-metadata.command.d.ts.map

package/dist/wire/cluster/get-cluster-metadata.command.js

@@ -0,0 +1,30 @@
+/**
+ * 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 { wrapCommand } from '../command.utils.js';
+import { COMMAND_CODE } from '../command.code.js';
+import { deserializeMetadata } from './cluster.utils.js';
+export const GET_CLUSTER_METADATA = {
+    code: COMMAND_CODE.GetClusterMetadata,
+    serialize: () => {
+        return Buffer.alloc(0);
+    },
+    deserialize: (r) => deserializeMetadata(r.data)
+};
+export const getClusterMetadata = wrapCommand(GET_CLUSTER_METADATA);
+//# sourceMappingURL=get-cluster-metadata.command.js.map

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

@@ -0,0 +1,21 @@
+/**
+ * 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 './get-cluster-metadata.command.js';
+export * from './cluster.type.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/wire/cluster/index.js

@@ -0,0 +1,21 @@
+/**
+ * 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 './get-cluster-metadata.command.js';
+export * from './cluster.type.js';
+//# sourceMappingURL=index.js.map

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

@@ -18,7 +18,7 @@
  */
 import type { ClientProvider } from '../client/client.type.js';
 declare const userAPI: (c: ClientProvider) => {
-    get: (arg: import("./user/get-user.command.js").GetUser) => Promise<import("./user/user.utils.js").User>;
+    get: (arg: import("./user/get-user.command.js").GetUser) => Promise<import("./user/user.utils.js").User | null>;
     list: (arg: void) => Promise<import("./user/user.utils.js").BaseUser[]>;
     create: (arg: import("./user/create-user.command.js").CreateUser) => Promise<import("./user/user.utils.js").User>;
     update: (arg: import("./user/update-user.command.js").UpdateUser) => Promise<boolean>;
@@ -34,7 +34,7 @@ declare const sessionAPI: (c: ClientProvider) => {
 };
 type SessionAPI = ReturnType<typeof sessionAPI>;
 declare const clientAPI: (c: ClientProvider) => {
-    get: (arg: import("./client/get-client.command.js").GetClient) => Promise<import("./client/client.utils.js").Client>;
+    get: (arg: import("./client/get-client.command.js").GetClient) => Promise<import("./client/client.utils.js").Client | null>;
     getMe: (arg: void) => Promise<import("./client/client.utils.js").Client>;
     list: (arg: void) => Promise<import("./client/client.utils.js").Client[]>;
 };
@@ -46,19 +46,20 @@ declare const tokenAPI: (c: ClientProvider) => {
 };
 type TokenAPI = ReturnType<typeof tokenAPI>;
 declare const streamAPI: (c: ClientProvider) => {
-    get: (arg: import("./stream/get-stream.command.js").GetStream) => Promise<import("./stream/stream.utils.js").Stream>;
+    get: (arg: import("./stream/get-stream.command.js").GetStream) => Promise<import("./stream/stream.utils.js").Stream | null>;
     list: (arg: void) => Promise<import("./stream/stream.utils.js").Stream[]>;
     create: (arg: import("./stream/create-stream.command.js").CreateStream) => Promise<import("./stream/stream.utils.js").Stream>;
     update: (arg: import("./stream/update-stream.command.js").UpdateStream) => Promise<boolean>;
     delete: (arg: import("./stream/delete-stream.command.js").DeleteStream) => Promise<boolean>;
     purge: (arg: import("./stream/purge-stream.command.js").PurgeStream) => Promise<boolean>;
+    ensure: (streamName: string) => Promise<import("./stream/stream.utils.js").Stream>;
 };
 type StreamAPI = ReturnType<typeof streamAPI>;
 declare const topicAPI: (c: ClientProvider) => {
     get: (arg: {
         streamId: import("./identifier.utils.js").Id;
         topicId: import("./identifier.utils.js").Id;
-    }) => Promise<import("./topic/topic.utils.js").Topic>;
+    }) => Promise<import("./topic/topic.utils.js").Topic | null>;
     list: (arg: import("./topic/get-topics.command.js").GetTopics) => Promise<import("./topic/topic.utils.js").Topic[]>;
     create: (arg: import("./topic/create-topic.command.js").CreateTopic) => Promise<import("./topic/topic.utils.js").Topic>;
     update: (arg: import("./topic/update-topic.command.js").UpdateTopic) => Promise<boolean>;
@@ -68,6 +69,7 @@ declare const topicAPI: (c: ClientProvider) => {
         partitionsCount: number;
     }) => Promise<boolean>;
     purge: (arg: import("./topic/purge-topic.command.js").PurgeTopic) => Promise<boolean>;
+    ensure: (streamId: import("./identifier.utils.js").Id, topicName: string, partitionCount?: number, compressionAlgorithm?: number) => Promise<import("./topic/topic.utils.js").Topic>;
 };
 type TopicAPI = ReturnType<typeof topicAPI>;
 declare const partitionAPI: (c: ClientProvider) => {
@@ -80,16 +82,18 @@ declare const segmentAPI: (c: ClientProvider) => {
 };
 type SegmentAPI = ReturnType<typeof segmentAPI>;
 declare const groupAPI: (c: ClientProvider) => {
-    get: (arg: import("./consumer-group/get-group.command.js").GetGroup) => Promise<import("./consumer-group/group.utils.js").ConsumerGroup>;
+    get: (arg: import("./consumer-group/get-group.command.js").GetGroup) => Promise<import("./consumer-group/group.utils.js").ConsumerGroup | null>;
     list: (arg: import("./consumer-group/get-groups.command.js").GetGroups) => Promise<import("./consumer-group/group.utils.js").ConsumerGroup[]>;
     create: (arg: import("./consumer-group/create-group.command.js").CreateGroup) => Promise<import("./consumer-group/group.utils.js").ConsumerGroup>;
     join: (arg: import("./consumer-group/join-group.command.js").JoinGroup) => Promise<boolean>;
     leave: (arg: import("./consumer-group/leave-group.command.js").LeaveGroup) => Promise<boolean>;
     delete: (arg: import("./consumer-group/delete-group.command.js").DeleteGroup) => Promise<boolean>;
+    ensure: (streamId: import("./identifier.utils.js").Id, topicId: import("./identifier.utils.js").Id, groupName: string) => Promise<import("./consumer-group/group.utils.js").ConsumerGroup>;
+    ensureAndJoin: (streamId: import("./identifier.utils.js").Id, topicId: import("./identifier.utils.js").Id, groupName: string) => Promise<import("./consumer-group/group.utils.js").ConsumerGroup>;
 };
 type GroupAPI = ReturnType<typeof groupAPI>;
 declare const offsetAPI: (c: ClientProvider) => {
-    get: (arg: import("./offset/get-offset.command.js").GetOffset) => Promise<import("./offset/offset.utils.js").OffsetResponse>;
+    get: (arg: import("./offset/get-offset.command.js").GetOffset) => Promise<import("./offset/offset.utils.js").OffsetResponse | null>;
     store: (arg: import("./offset/store-offset.command.js").StoreOffset) => Promise<boolean>;
     delete: (arg: import("./offset/get-offset.command.js").GetOffset) => Promise<boolean>;
 };
@@ -105,6 +109,10 @@ declare const systemAPI: (c: ClientProvider) => {
     getStats: (arg: void) => Promise<import("./system/get-stats.command.js").Stats>;
 };
 type SystemAPI = ReturnType<typeof systemAPI>;
+declare const clusterAPI: (c: ClientProvider) => {
+    getClusterMetadata: (arg: void) => Promise<import("./cluster/cluster.utils.js").ClusterMetadata>;
+};
+type ClusterAPI = ReturnType<typeof clusterAPI>;
 export declare abstract class AbstractAPI {
     clientProvider: ClientProvider;
     constructor(getClient: ClientProvider);
@@ -122,6 +130,7 @@ export declare abstract class CommandAPI extends AbstractAPI {
     offset: OffsetAPI;
     message: MessageAPI;
     system: SystemAPI;
+    cluster: ClusterAPI;
     constructor(c: ClientProvider);
 }
 export {};