apache-iggy 0.10.0 → 0.10.1-edge.2

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

@@ -1,6 +1,7 @@
 import type { Readable } from 'stream';
 import { type TcpNetConnectOpts } from 'node:net';
 import { type ConnectionOptions } from 'node:tls';
+import type { PartitionContext } from '../wire/vsr/header.js';
 /**
  * TCP socket connection options.
  * Alias for Node.js TcpNetConnectOpts, what net.createConnection accepts.
@@ -29,23 +30,33 @@ export type CommandResponse = {
     data: Buffer;
 };
 export type SendCommandOptions = {
+    /** Cancels this call without closing its shared replica link. */
+    signal?: AbortSignal;
     /** Whether the response uses the standard command response decoder */
     handleResponse?: boolean;
-    /** Whether to append rather than prepend the command to the queue */
+    /** @deprecated Multiplexed calls ignore this queue-order hint. */
     last?: boolean;
-    /**
-     * Whether a not-admitted refusal re-checks the leader and re-issues the
-     * command. False for the roster read a re-check itself runs: answering a
-     * leader check with another leader check would recurse.
-     */
+    /** @deprecated The shared session owner manages replica routing. */
     followsLeaderMoves?: boolean;
     /**
      * When the whole request gives up, as an epoch timestamp in milliseconds.
-     * Set when a command already carries a budget -- one re-issued after a
-     * leader move keeps the budget it was first submitted with, rather than
-     * opening a second one on top of it. Defaults to a fresh response timeout.
+     * Includes admission, discovery, link waits and retries. Defaults to 30 seconds.
      */
     deadline?: number;
+    /**
+     * Partition context of a poll, an offset store or delete, or a send to an
+     * explicit partition, taken from an earlier reply. It replaces the context
+     * the client would capture, stays on every retry, and is never refreshed
+     * after a history refusal (87): work from one partition incarnation must
+     * not land in another.
+     */
+    context?: PartitionContext;
+    /**
+     * The `RawClient.lineage` that a call of several commands started with. A
+     * command of an older lineage fails with status 40 and sends nothing, so no
+     * part of the call runs under a session the caller opened after it started.
+     */
+    lineage?: number;
 };
 /**
  * Low-level client interface for communicating with the Iggy server.
@@ -56,11 +67,35 @@ export type RawClient = {
     sendCommand: (code: number, payload: Buffer, options?: SendCommandOptions) => Promise<CommandResponse>;
     /** Whether the client has been authenticated */
     isAuthenticated: boolean;
-    /** Authenticates the client with the server */
+    /** Raised by each sign-in and logout of the caller. */
+    readonly lineage?: number;
+    /** Uses caller credentials; any failed attempt withdraws automatic sign-in. */
     authenticate: (c: ClientCredentials) => Promise<boolean>;
+    /** Typed login delegates validation to the session owner when supported. */
+    _authWithPassword?: (c: PasswordCredentials) => Promise<{
+        userId: number;
+    }>;
+    _authWithToken?: (c: TokenCredentials) => Promise<{
+        userId: number;
+    }>;
+    /**
+     * Resolves the original frozen operation; never sends it under a fresh identity.
+     * The client keeps the proved outcomes of its last `maxPendingOperations`
+     * replays, also across a session reset, so a later resolve of the same
+     * operation returns the same outcome without a request.
+     * `OperationNotRetainedError` means that a session reset or an abandon came
+     * before a replay proved the outcome, or that the proved outcome aged out.
+     */
+    resolveOperation?: (operationId: bigint, options?: SendCommandOptions) => Promise<void>;
+    /**
+     * Releases a retained lane without asserting that the operation did not commit.
+     * A replay that is already running keeps the lane until it ends, and the
+     * client keeps the outcome that it proves.
+     */
+    abandonOperation?: (operationId: bigint) => void;
     /** Destroys the client connection */
     destroy: () => void;
-    /** Holds a pooled client across multiple command submissions */
+    /** Tracks one facade operation across multiple command submissions. */
     hold?: () => () => void;
     /** Registers an event listener */
     on: (ev: string, cb: (e?: unknown) => void) => void;
@@ -71,7 +106,7 @@ export type RawClient = {
 };
 /**
  * Function type that provides a RawClient instance.
- * Used for dependency injection and connection pooling.
+ * Used for dependency injection.
  */
 export type ClientProvider = () => Promise<RawClient>;
 /**
@@ -90,14 +125,15 @@ export type ReconnectOption = {
     /** Whether automatic reconnection is enabled */
     enabled: boolean;
     /**
-     * Milliseconds to wait between passes. The first pass runs at once when more
-     * than one endpoint is known.
+     * Initial reconnect delay in milliseconds. Each replica uses exponential
+     * backoff capped at 10 seconds with jitter.
      */
     interval: number;
     /**
-     * Maximum number of passes over the known endpoints. One pass dials the
-     * endpoint the client is on, the endpoint it was configured with, and every
-     * node the roster named, so this counts passes rather than dials.
+     * Maximum retries per replica after the first attempt. Bootstrap retries
+     * sweep the configured seed and remembered endpoints. The budget limits one
+     * reconnect burst: while the client stays signed in, each heartbeat restarts
+     * a replica link that used its budget, with a fresh budget.
      */
     maxRetries: number;
 };
@@ -127,12 +163,12 @@ export type PasswordCredentials = {
  */
 export type ClientCredentials = TokenCredentials | PasswordCredentials;
 /**
- * Connection pool size configuration.
+ * Legacy logical-client count. Replica links are managed independently.
  */
 export type PoolSizeOption = {
-    /** Minimum number of connections in the pool */
+    /** Minimum logical clients; normalized to one */
     min?: number;
-    /** Maximum number of connections in the pool */
+    /** Maximum logical clients; only one is supported */
     max?: number;
 };
 /**
@@ -150,13 +186,20 @@ export type ClientConfig = {
     options: TransportOption;
     /** Authentication credentials */
     credentials: ClientCredentials;
-    /** Connection pool size configuration */
+    /** Legacy logical-client count; does not limit replica links. */
     poolSize?: PoolSizeOption;
     /** Automatic reconnection configuration */
     reconnect?: ReconnectOption;
-    /** Interval for sending heartbeat pings, in milliseconds */
+    /**
+     * Interval for sending heartbeat pings, in milliseconds. Each heartbeat also
+     * restarts replica links that used their reconnect budget. 0 disables both.
+     */
     heartbeatInterval?: number;
     /** Maximum accepted response frame size in bytes */
     maxResponseFrameSize?: number;
+    /** Maximum active plus retained mutations across this client. Default: 256. */
+    maxPendingOperations?: number;
+    /** Frozen mutation headers and bodies, including retained and writer-owned bytes. Default: 64 MiB. */
+    maxPendingOperationBytes?: number;
 };
 //# sourceMappingURL=client.type.d.ts.map

package/dist/client/index.d.ts

@@ -1,5 +1,6 @@
 export { Client, SimpleClient, SingleClient } from './client.js';
 export * from './client.config.js';
+export { ConnectionClosedError } from './client.connection.js';
 export { parseConnectionString } from './client.connection-string.js';
 export * from './client.utils.js';
 export * from './client.socket.js';

package/dist/client/index.js

@@ -16,6 +16,7 @@
 // under the License.
 export { Client, SimpleClient, SingleClient } from './client.js';
 export * from './client.config.js';
+export { ConnectionClosedError } from './client.connection.js';
 export { parseConnectionString } from './client.connection-string.js';
 export * from './client.utils.js';
 export * from './client.socket.js';

package/dist/client.e2e.js

@@ -18,7 +18,6 @@ import assert from 'node:assert/strict';
 import { Client } from './client/client.js';
 try {
     const credentials = { username: 'iggy', password: 'iggy' };
-    // pooled client
     const c = new Client({
         transport: 'TCP',
         options: { port: 8090, host: '127.0.0.1' },
@@ -28,8 +27,7 @@ try {
     console.log('R2', await c.user.list());
     console.log('R3', await c.client.list());
     console.log('R4', await c.system.getStats());
-    // serial call should keep socket pool to 1
-    assert.equal(c._pool.size, 1);
+    const raw = await c.clientProvider();
     const resp = await Promise.all([
         c.user.list(),
         c.stream.list(),
@@ -42,8 +40,8 @@ try {
         c.system.getStats(),
     ]);
     console.log('parallel call resp', resp);
-    // serial call should raise socket pool to MAX_POOL
-    assert.equal(c._pool.size, 4);
+    assert.equal(await c.clientProvider(), raw);
+    await c.destroy();
 }
 catch (err) {
     console.error('FAILED', err);

package/dist/e2e/resource-options.e2e.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=resource-options.e2e.d.ts.map

package/dist/{wire/stream/purge-stream.command.js → e2e/resource-options.e2e.js}

@@ -14,23 +14,15 @@
 // 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 { deserializeVoidResponse } from '../../client/client.utils.js';
-import { serializeIdentifier } from '../identifier.utils.js';
-/**
- * Purge stream command definition.
- * Deletes all messages from a stream while keeping the stream itself.
- */
-export const PURGE_STREAM = {
-    code: COMMAND_CODE.PurgeStream,
-    serialize: ({ streamId }) => {
-        return serializeIdentifier(streamId);
-    },
-    deserialize: deserializeVoidResponse
-};
-/**
- * Executable purge stream command function.
- */
-export const purgeStream = wrapCommand(PURGE_STREAM);
-//# sourceMappingURL=purge-stream.command.js.map
+// These tests need a server started with encryption enabled and a config key
+// (IGGY_ENCRYPTION_ENABLED=true, IGGY_ENCRYPTION_KEY), so a stream created
+// without a key reports a server-generated one.
+import { Client } from '../client/client.js';
+import { getIggyAddress } from '../tcp.sm.utils.js';
+import { EncryptionKeySource } from '../wire/index.js';
+import { describeResourceOptions } from './resource-options.suite.js';
+const [host, port] = getIggyAddress();
+describeResourceOptions('e2e -> resource options', 'e2e-ro', (credentials) => new Client({
+    transport: 'TCP', options: { host, port }, credentials
+}), EncryptionKeySource.Server);
+//# sourceMappingURL=resource-options.e2e.js.map

package/dist/e2e/resource-options.suite.d.ts

@@ -0,0 +1,15 @@
+import type { Client } from '../client/client.js';
+import { EncryptionKeySource } from '../wire/index.js';
+type Credentials = {
+    username: string;
+    password: string;
+};
+/**
+ * Registers the resource options cases for one transport. `connect` builds a
+ * client of that transport signed in with the given credentials.
+ * `keylessSource` is what a stream created without a key reports: `server`
+ * when the server runs with encryption enabled, `none` otherwise.
+ */
+export declare const describeResourceOptions: (label: string, prefix: string, connect: (credentials: Credentials) => Client, keylessSource: EncryptionKeySource, skip?: string | false) => Promise<void>;
+export {};
+//# sourceMappingURL=resource-options.suite.d.ts.map

package/dist/e2e/resource-options.suite.js

@@ -0,0 +1,272 @@
+// 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 { randomBytes } from 'node:crypto';
+import { after, describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import { HeaderValue } from '../wire/message/header.utils.js';
+import { ResponseError } from '../wire/error.utils.js';
+import { Consumer, EncryptionKeySource, OptionsScope, PartitionResizePolicy, Partitioning, PollingStrategy, StreamEncryptionKey, UserStatus, encryptionKeyFingerprint } from '../wire/index.js';
+const NEVER_RETURNED = ['encryption_key', 'encryption_key_wrapped', 'critical_keys'];
+const FINGERPRINT = /^[0-9a-f]{16}$/;
+const UNLIMITED = 18446744073709551615n;
+const UNSUPPORTED_OPTION_KEY = 4041;
+const OPTION_NOT_UPDATABLE = 4103;
+const assertProjection = (stream, source, fingerprint) => {
+    assert.equal(stream.encryptionKeySource, source);
+    if (source === EncryptionKeySource.None) {
+        assert.equal(stream.encryptionKeyFingerprint, null);
+        assert.deepEqual(stream.encryptionKekFingerprints, []);
+        return;
+    }
+    assert.match(stream.encryptionKeyFingerprint ?? '', FINGERPRINT);
+    if (fingerprint !== undefined)
+        assert.equal(stream.encryptionKeyFingerprint, fingerprint);
+    assert.ok(stream.encryptionKekFingerprints.length >= 1);
+    for (const kek of stream.encryptionKekFingerprints)
+        assert.match(kek, FINGERPRINT);
+};
+const assertNoKeyMaterial = (stream, key) => {
+    for (const block of [stream.options, stream.derivedOptions]) {
+        for (const name of NEVER_RETURNED)
+            assert.equal(name in block, false, `${name} was returned`);
+        if (key)
+            for (const value of Object.values(block))
+                assert.ok(!(Buffer.isBuffer(value) && value.equals(key)) && value !== key.toString('base64'), 'a returned option holds the key');
+    }
+};
+/**
+ * Registers the resource options cases for one transport. `connect` builds a
+ * client of that transport signed in with the given credentials.
+ * `keylessSource` is what a stream created without a key reports: `server`
+ * when the server runs with encryption enabled, `none` otherwise.
+ */
+export const describeResourceOptions = (label, prefix, connect, keylessSource, skip = false) => describe(label, { skip }, async () => {
+    const c = connect({ username: 'iggy', password: 'iggy' });
+    it('given stream key when creating should read matching projection', async () => {
+        const key = randomBytes(32);
+        const name = `${prefix}-keyed`;
+        const created = await c.stream.create({ name, encryptionKey: StreamEncryptionKey.from(key) });
+        try {
+            assertProjection(created, EncryptionKeySource.Stream, encryptionKeyFingerprint(key));
+            assertNoKeyMaterial(created, key);
+            const fetched = await c.stream.get({ streamId: name });
+            assert.ok(fetched);
+            assertProjection(fetched, EncryptionKeySource.Stream, encryptionKeyFingerprint(key));
+            assert.deepEqual(fetched.encryptionKekFingerprints, created.encryptionKekFingerprints);
+            assertNoKeyMaterial(fetched, key);
+            const listed = (await c.stream.list()).find((stream) => stream.id === created.id);
+            assert.ok(listed);
+            assertProjection(listed, EncryptionKeySource.Stream, encryptionKeyFingerprint(key));
+            assertNoKeyMaterial(listed, key);
+            const base64 = `${prefix}-keyed-base64`;
+            const fromText = await c.stream.create({
+                name: base64, encryptionKey: StreamEncryptionKey.from(key.toString('base64'))
+            });
+            assert.equal(fromText.encryptionKeyFingerprint, encryptionKeyFingerprint(key));
+            await c.stream.delete({ streamId: fromText.id });
+        }
+        finally {
+            await c.stream.delete({ streamId: created.id });
+        }
+    });
+    it(`given keyless stream when reading should report key source ${keylessSource}`, async () => {
+        const created = await c.stream.create({ name: `${prefix}-keyless` });
+        try {
+            assertProjection(created, keylessSource);
+            const fetched = await c.stream.get({ streamId: created.id });
+            assert.ok(fetched);
+            assertProjection(fetched, keylessSource, created.encryptionKeyFingerprint ?? undefined);
+            assertNoKeyMaterial(fetched);
+        }
+        finally {
+            await c.stream.delete({ streamId: created.id });
+        }
+    });
+    it('given stream rename when updating should preserve encryption projection', async () => {
+        const key = randomBytes(32);
+        const created = await c.stream.create({
+            name: `${prefix}-rename`, encryptionKey: StreamEncryptionKey.from(key)
+        });
+        try {
+            await c.topic.create({ streamId: created.id, name: 'events', partitionCount: 1 });
+            await c.message.send({
+                streamId: created.id, topicId: 'events', partition: Partitioning.PartitionId(0),
+                messages: [{ payload: 'before-rename', headers: [] }]
+            });
+            assert.ok(await c.stream.update({ streamId: created.id, name: `${prefix}-renamed` }));
+            await assert.rejects(c.stream.update({ streamId: created.id, reset: ['encryption_key'] }), (error) => error instanceof ResponseError &&
+                error.errorCode === OPTION_NOT_UPDATABLE && !error.fromServer);
+            const renamed = await c.stream.get({ streamId: created.id });
+            assert.ok(renamed);
+            assert.equal(renamed.id, created.id);
+            assert.equal(renamed.name, `${prefix}-renamed`);
+            assertProjection(renamed, EncryptionKeySource.Stream, encryptionKeyFingerprint(key));
+            assert.deepEqual(renamed.encryptionKekFingerprints, created.encryptionKekFingerprints);
+            const polled = await c.message.poll({
+                streamId: created.id, topicId: 'events', consumer: Consumer.Single, partitionId: 0,
+                pollingStrategy: PollingStrategy.First, count: 10, autocommit: false
+            });
+            assert.deepEqual(polled.messages.map((message) => message.payload.toString()), ['before-rename']);
+        }
+        finally {
+            await c.stream.delete({ streamId: created.id });
+        }
+    });
+    it('given topic reset when updating should preserve unmentioned values', async () => {
+        const stream = await c.stream.create({ name: `${prefix}-topic-reset` });
+        try {
+            const topic = await c.topic.create({
+                streamId: stream.id, name: 'settings', partitionCount: 1,
+                compressionAlgorithm: 2, messageExpiry: 3600000000n, maxTopicSize: 1073741824n
+            });
+            assert.ok(await c.topic.update({
+                streamId: stream.id, topicId: topic.id,
+                messageExpiry: 7200000000n, reset: ['max_topic_size']
+            }));
+            const updated = await c.topic.get({ streamId: stream.id, topicId: topic.id });
+            assert.ok(updated);
+            assert.equal(updated.name, 'settings');
+            assert.equal(updated.options.compression_algorithm, 'gzip');
+            assert.equal(updated.compressionAlgorithm, 2);
+            assert.equal(updated.options.message_expiry, 7200000000n);
+            assert.equal(updated.messageExpiry, 7200000000n);
+            assert.equal('max_topic_size' in updated.options, false);
+            assert.equal(updated.derivedOptions.max_topic_size, UNLIMITED);
+            assert.equal(updated.maxTopicSize, UNLIMITED);
+            assert.deepEqual(updated.derivedOptions, {
+                ...topic.derivedOptions, max_topic_size: UNLIMITED
+            });
+        }
+        finally {
+            await c.stream.delete({ streamId: stream.id });
+        }
+    });
+    it('given user options when creating and updating should preserve user behavior', async () => {
+        const password = 'e2e-ro-password';
+        const first = await c.user.create({
+            username: `${prefix}-user`, password, status: UserStatus.Active, options: []
+        });
+        const second = await c.user.create({
+            username: `${prefix}-user-taken`, password, status: UserStatus.Active
+        });
+        try {
+            assert.deepEqual(first.options, {});
+            assert.deepEqual(first.derivedOptions, {});
+            assert.ok(await c.user.update({
+                userId: first.id, username: `${prefix}-user-renamed`, status: UserStatus.Inactive
+            }));
+            const updated = await c.user.get({ userId: first.id });
+            assert.ok(updated);
+            assert.equal(updated.userName, `${prefix}-user-renamed`);
+            assert.equal(updated.status, 'Inactive');
+            assert.deepEqual(updated.options, {});
+            await assert.rejects(c.user.update({ userId: first.id, username: `${prefix}-user-taken`, status: UserStatus.Active }), (error) => error instanceof ResponseError && error.fromServer);
+            const unchanged = await c.user.get({ userId: first.id });
+            assert.ok(unchanged);
+            assert.equal(unchanged.userName, `${prefix}-user-renamed`);
+            assert.equal(unchanged.status, 'Inactive');
+        }
+        finally {
+            await c.user.delete({ userId: first.id });
+            await c.user.delete({ userId: second.id });
+        }
+    });
+    it('given logged in user rename when reconnecting should keep new username', async () => {
+        const password = 'e2e-ro-self-password';
+        const user = await c.user.create({
+            username: `${prefix}-self`, password, status: UserStatus.Active,
+            permissions: {
+                global: {
+                    ManageServers: false, ReadServers: false, ManageUsers: true, ReadUsers: true,
+                    ManageStreams: true, ReadStreams: true, ManageTopics: true, ReadTopics: true,
+                    PollMessages: false, SendMessages: false
+                },
+                streams: []
+            }
+        });
+        const taken = await c.user.create({
+            username: `${prefix}-self-taken`, password, status: UserStatus.Active
+        });
+        const self = connect({ username: `${prefix}-self`, password });
+        const signedInAs = async (username) => {
+            await self.session.logout();
+            await self.session.login({ username, password });
+            const me = await self.client.getMe();
+            return (await c.user.get({ userId: me.userId }))?.userName;
+        };
+        try {
+            assert.equal((await self.client.getMe()).userId, user.id);
+            await assert.rejects(self.user.update({ userId: user.id, username: `${prefix}-self-taken` }), (error) => error instanceof ResponseError && error.fromServer);
+            assert.equal(await signedInAs(`${prefix}-self`), `${prefix}-self`);
+            const stream = await self.stream.create({ name: `${prefix}-self-stream` });
+            await self.stream.update({ streamId: stream.id, name: `${prefix}-self` });
+            const topic = await self.topic.create({ streamId: stream.id, name: 'events', partitionCount: 1 });
+            await self.topic.update({ streamId: stream.id, topicId: topic.id, name: `${prefix}-self-topic` });
+            await self.stream.delete({ streamId: stream.id });
+            assert.equal(await signedInAs(`${prefix}-self`), `${prefix}-self`);
+            assert.ok(await self.user.update({ userId: user.id, username: `${prefix}-self-renamed` }));
+            assert.equal(await signedInAs(`${prefix}-self-renamed`), `${prefix}-self-renamed`);
+        }
+        finally {
+            await self.destroy();
+            await c.user.delete({ userId: user.id });
+            await c.user.delete({ userId: taken.id });
+        }
+    });
+    it('given raw create-only key or unknown raw reset when updating should let the server refuse', async () => {
+        const stream = await c.stream.create({ name: `${prefix}-raw` });
+        try {
+            const topic = await c.topic.create({
+                streamId: stream.id, name: 'fixed', partitionCount: 1,
+                partitionResizePolicy: PartitionResizePolicy.Fixed
+            });
+            assert.equal(topic.options.partition_resize_policy, PartitionResizePolicy.Fixed);
+            const fromServer = (code) => (error) => error instanceof ResponseError && error.errorCode === code && error.fromServer;
+            await assert.rejects(c.topic.update({
+                streamId: stream.id, topicId: topic.id,
+                options: [{ key: 'compression_algorithm', value: HeaderValue.String('gzip') }]
+            }), fromServer(OPTION_NOT_UPDATABLE));
+            await assert.rejects(c.topic.update({ streamId: stream.id, topicId: topic.id, rawReset: ['future_option'] }), fromServer(UNSUPPORTED_OPTION_KEY));
+            const unchanged = await c.topic.get({ streamId: stream.id, topicId: topic.id });
+            assert.equal(unchanged?.compressionAlgorithm, topic.compressionAlgorithm);
+        }
+        finally {
+            await c.stream.delete({ streamId: stream.id });
+        }
+    });
+    it('given stream scope when describing options should report sensitivity and mutability', async () => {
+        const specs = await c.system.describeOptions({ scope: OptionsScope.Stream });
+        const byKey = new Map(specs.map((spec) => [spec.key, spec]));
+        assert.deepEqual([...byKey.keys()], [
+            'name', 'encryption_key', 'encryption_key_source',
+            'encryption_key_fingerprint', 'encryption_kek_fingerprint'
+        ]);
+        assert.equal(byKey.get('name')?.updatable, true);
+        assert.equal(byKey.get('name')?.secret, false);
+        assert.equal(byKey.get('encryption_key')?.updatable, false);
+        assert.equal(byKey.get('encryption_key')?.secret, true);
+        assert.equal(byKey.get('encryption_key')?.critical, true);
+        assert.equal(byKey.get('encryption_key_fingerprint')?.readOnly, true);
+    });
+    it(`${label}::cleanup`, async () => {
+        assert.ok(await c.session.logout());
+    });
+    after(() => {
+        c.destroy();
+    });
+});
+//# sourceMappingURL=resource-options.suite.js.map

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

@@ -24,6 +24,7 @@ const expectedMeta = {
     name: "single-node",
     nodes: [
         {
+            replicaId: 0,
             name: "iggy-node",
             ip: "127.0.0.1",
             endpoints: {

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

@@ -80,6 +80,10 @@ describe('e2e -> consumer-stream', async () => {
             });
         });
         after(async () => {
+            // The member that did not get the last batch can still be polling,
+            // and a poll that fails after the delete has no error listener.
+            s.destroy();
+            s2.destroy();
             assert.ok(await c.stream.delete({ streamId: streamName }));
             assert.ok(await c.session.logout());
             await c.destroy();

package/dist/e2e/tcp.parallel.e2e.js

@@ -20,30 +20,29 @@ import { getTestClient } from './test-client.utils.js';
 describe('e2e -> parallel', async () => {
     const c = getTestClient();
     const baseGetMe = await c.client.getMe();
-    const credentials = { username: 'iggy', password: 'iggy' };
     it('e2e -> parallel::mix calls', async () => {
         const resp = await Promise.all([
             c.client.getMe(),
             c.system.getStats(),
             c.system.ping(),
-            c.session.login(credentials),
             c.client.getMe(),
             c.system.getStats(),
             c.system.ping(),
-            c.session.login(credentials),
             c.client.getMe(),
             c.system.getStats(),
             c.system.ping(),
-            c.session.login(credentials),
         ]);
-        assert.ok(resp.length === 12);
+        assert.equal(resp.length, 9);
         assert.deepEqual(resp[0], baseGetMe);
         assert.deepEqual(Object.keys(resp[1]), [
             'processId', 'cpuUsage', 'totalCpuUsage', 'memoryUsage', 'totalMemory',
             'availableMemory', 'runTime', 'startTime', 'readBytes', 'writtenBytes',
             'messagesSizeBytes', 'streamsCount', 'topicsCount', 'partitionsCount',
             'segmentsCount', 'messagesCount', 'clientsCount', 'consumersGroupsCount',
-            'hostname', 'osName', 'osVersion', 'kernelVersion'
+            'hostname', 'osName', 'osVersion', 'kernelVersion',
+            'iggyServerVersion', 'iggyServerSemver', 'cacheMetrics',
+            'threadsCount', 'freeDiskSpace', 'totalDiskSpace',
+            'openFilesCount', 'openFilesLimit'
         ]);
         resp.forEach(r => assert.ok(r));
     });

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

@@ -40,9 +40,6 @@ describe('e2e -> stream', async () => {
         });
         assert.ok(stream);
     });
-    it('e2e -> stream::purge', async () => {
-        assert.ok(await c.stream.purge({ streamId: name2 }));
-    });
     it('e2e -> stream::delete', async () => {
         assert.ok(await c.stream.delete({ streamId: name2 }));
     });

package/dist/e2e/tcp.system.e2e.js

@@ -31,9 +31,18 @@ describe('e2e -> system', async () => {
             'availableMemory', 'runTime', 'startTime', 'readBytes', 'writtenBytes',
             'messagesSizeBytes', 'streamsCount', 'topicsCount', 'partitionsCount',
             'segmentsCount', 'messagesCount', 'clientsCount', 'consumersGroupsCount',
-            'hostname', 'osName', 'osVersion', 'kernelVersion'
+            'hostname', 'osName', 'osVersion', 'kernelVersion',
+            'iggyServerVersion', 'iggyServerSemver', 'cacheMetrics',
+            'threadsCount', 'freeDiskSpace', 'totalDiskSpace',
+            'openFilesCount', 'openFilesLimit'
         ]);
     });
+    it('e2e -> system::snapshot', async () => {
+        const data = await c.system.snapshot();
+        assert.ok(data.length > 0);
+        assert.equal(data[0], 0x50);
+        assert.equal(data[1], 0x4B);
+    });
     it('e2e -> system::logout', async () => {
         assert.ok(await c.session.logout());
     });

package/dist/e2e/tcp.token.e2e.js

@@ -20,13 +20,19 @@ import { getTestClient } from './test-client.utils.js';
 describe('e2e -> token', async () => {
     const c = getTestClient();
     const tokenName = 'yolo-token-test';
+    const lifetimeMs = 30 * 60 * 1000;
+    let createdAt = 0;
     it('e2e -> token::create', async () => {
-        const tk = await c.token.create({ name: tokenName, expiry: 1800n });
+        createdAt = Date.now();
+        const tk = await c.token.create({ name: tokenName, expiry: BigInt(lifetimeMs) * 1000n });
         assert.ok(tk.token.length > 1);
     });
     it('e2e -> token::list', async () => {
         const tks = await c.token.list();
-        assert.ok(tks.length > 0);
+        const listed = tks.find((tk) => tk.name === tokenName);
+        assert.ok(listed?.expiry, 'the token lists its expiry');
+        const remainingMs = listed.expiry.getTime() - createdAt;
+        assert.ok(Math.abs(remainingMs - lifetimeMs) < 5000, `expiry ${remainingMs} ms after create, want ${lifetimeMs}`);
     });
     it('e2e -> token::delete', async () => {
         assert.ok(await c.token.delete({ name: tokenName }));