apache-iggy 0.10.0 → 0.10.1-edge.2

package/dist/client/client.d.ts

@@ -1,43 +1,12 @@
-import { type Pool } from 'generic-pool';
-import type { RawClient, ClientConfig, ClientConfigOrString } from "./client.type.js";
+import type { RawClient, ClientConfig, ClientConfigOrString } from './client.type.js';
 import { CommandAPI } from '../wire/command-set.js';
-/**
- * Iggy client with connection pooling support.
- * Manages a pool of connections for efficient resource utilization.
- */
+/** Every facade call shares one session and its independently multiplexed replica links. */
 export declare class Client extends CommandAPI {
-    /** Client configuration */
-    _config: ClientConfig;
-    /** Connection pool instance */
-    _pool: Pool<RawClient>;
-    /**
-     * Creates a new pooled client.
-     *
-    * @param config - Client configuration or connection string
-    */
+    readonly _config: ClientConfig;
     constructor(config: ClientConfigOrString);
-    /**
-     * Destroys the client and drains all connections from the pool.
-     */
     destroy(): Promise<void>;
 }
-/**
- * Iggy client that uses a single persistent connection.
- * Suitable for applications that don't need connection pooling.
- */
-export declare class SingleClient extends CommandAPI {
-    /** Client configuration */
-    _config: ClientConfig;
-    /**
-     * Creates a new single-connection client.
-     *
-    * @param config - Client configuration or connection string
-    */
-    constructor(config: ClientConfigOrString);
-    /**
-     * Destroys the client connection.
-     */
-    destroy(): Promise<void>;
+export declare class SingleClient extends Client {
 }
 /**
  * Simple Iggy client wrapper around an existing RawClient.

package/dist/client/client.js

@@ -14,116 +14,23 @@
 // KIND, either express or implied.  See the License for the
 // specific language governing permissions and limitations
 // under the License.
-import { createPool } from 'generic-pool';
-import { getRawClient } from '../client/client.socket.js';
+import { getRawClient } from './client.socket.js';
 import { CommandAPI } from '../wire/command-set.js';
-import { debug } from './client.debug.js';
 import { normalizeClientConfig } from './client.config.js';
-/**
- * Creates a client provider that uses connection pooling.
- * Automatically acquires and releases clients from the pool.
- *
- * @param config - Client configuration including pool size options
- * @returns Client provider and its connection pool
- */
-const createPooledClientProvider = (config) => {
-    // Constructed eagerly rather than inside the factory: generic-pool never
-    // rejects waiting acquires when a create fails, and keeps re-dispatching
-    // the doomed factory, which hangs every command. Normalization already
-    // pins this pool to exactly one pooled connection, so there is nothing
-    // lazy to preserve.
-    const client = getRawClient(config);
-    const minPoolSize = config.poolSize?.min || 1;
-    const maxPoolSize = config.poolSize?.max || 4;
-    const pool = createPool({
-        create: async function () {
-            return client;
-        },
-        destroy: async function () {
-            return client.destroy();
-        }
-    }, {
-        min: minPoolSize,
-        max: maxPoolSize
-    });
-    const clientProvider = async () => {
-        const pooled = await pool.acquire();
-        debug('client acquired from pool. pool size is', pool.size);
-        pooled.once('finishQueue', () => {
-            pool.release(pooled);
-            debug('client released to pool. pool size is', pool.size);
-        });
-        return pooled;
-    };
-    return { clientProvider, pool };
-};
-/**
- * Iggy client with connection pooling support.
- * Manages a pool of connections for efficient resource utilization.
- */
+/** Every facade call shares one session and its independently multiplexed replica links. */
 export class Client extends CommandAPI {
-    /** Client configuration */
     _config;
-    /** Connection pool instance */
-    _pool;
-    /**
-     * Creates a new pooled client.
-     *
-    * @param config - Client configuration or connection string
-    */
     constructor(config) {
-        const normalizedConfig = normalizeClientConfig(config);
-        const { clientProvider, pool } = createPooledClientProvider(normalizedConfig);
-        super(clientProvider);
-        this._config = normalizedConfig;
-        this._pool = pool;
+        const normalized = normalizeClientConfig(config);
+        const client = getRawClient(normalized);
+        super(async () => client);
+        this._config = normalized;
     }
-    /**
-     * Destroys the client and drains all connections from the pool.
-     */
     async destroy() {
-        debug('destroying client pool. pool size is', this._pool.size);
-        await this._pool.drain();
-        await this._pool.clear();
-        debug('destroyed client pool. pool size is', this._pool.size);
+        (await this.clientProvider()).destroy();
     }
 }
-/**
- * Creates a client provider that reuses a single connection.
- *
- * @param config - Client configuration
- * @returns Client provider function that always returns the same client
- */
-const createSingleClientProvider = (config) => {
-    const client = getRawClient(config);
-    return async function clientProvider() {
-        return client;
-    };
-};
-/**
- * Iggy client that uses a single persistent connection.
- * Suitable for applications that don't need connection pooling.
- */
-export class SingleClient extends CommandAPI {
-    /** Client configuration */
-    _config;
-    /**
-     * Creates a new single-connection client.
-     *
-    * @param config - Client configuration or connection string
-    */
-    constructor(config) {
-        const normalizedConfig = normalizeClientConfig(config);
-        super(createSingleClientProvider(normalizedConfig));
-        this._config = normalizedConfig;
-    }
-    /**
-     * Destroys the client connection.
-     */
-    async destroy() {
-        const client = await this.clientProvider();
-        client.destroy();
-    }
+export class SingleClient extends Client {
 }
 /**
  * Simple Iggy client wrapper around an existing RawClient.

package/dist/client/client.operation.d.ts

@@ -0,0 +1,120 @@
+import { type PartitionContext } from '../wire/vsr/header.js';
+import type { VsrSession } from '../wire/vsr/index.js';
+export declare const OPERATION_TIMEOUT_MS = 30000;
+export declare class OperationUncertainError extends Error {
+    readonly operationId: bigint | undefined;
+    constructor(operationId: bigint | undefined, cause: unknown);
+}
+export declare class LaneBlockedError extends Error {
+    readonly operationId: bigint;
+    constructor(operationId: bigint);
+}
+/**
+ * The client has neither the operation nor a proved outcome for it, so the
+ * outcome can still be unknown. A session reset or an abandon came before a
+ * replay proved the outcome, or the proved outcome aged out.
+ */
+export declare class OperationNotRetainedError extends Error {
+    readonly operationId: bigint;
+    constructor(operationId: bigint);
+}
+export declare class VsrResponseTimeoutError extends Error {
+    constructor(timeout: number);
+}
+/**
+ * Every replica link used its retry budget, or no endpoint accepted a dial.
+ * The client connects again on its own: each heartbeat restarts a link with a
+ * fresh budget, and the next call dials again.
+ */
+export declare class NotConnectedError extends Error {
+    constructor(cause?: unknown);
+}
+export declare const waitWithin: <T>(pending: Promise<T>, deadline: number, signal?: AbortSignal) => Promise<T>;
+export declare const pause: (milliseconds: number, signal?: AbortSignal, background?: boolean) => Promise<void>;
+export declare class ChangeSignal {
+    private resolve;
+    promise: Promise<void>;
+    private next;
+    pulse(): void;
+}
+export declare class PermitPool {
+    private readonly capacity;
+    private active;
+    private readonly waiting;
+    constructor(capacity: number);
+    acquire(deadline: number, signal: AbortSignal): Promise<() => void>;
+    private release;
+}
+/** Writer aliases pin physical bytes after logical completion or abandonment. */
+export declare class FrozenFrame {
+    private bytes;
+    private readonly released;
+    private references;
+    private ownerReleased;
+    constructor(bytes: Buffer | undefined, released: () => void);
+    get buffer(): Buffer;
+    retain(): void;
+    release(): void;
+    releaseOwner(): void;
+}
+export type ClientOperation = {
+    readonly lane: string;
+    readonly command: number;
+    context: PartitionContext;
+    frame: FrozenFrame;
+    id: bigint;
+    readonly retainable: boolean;
+    readonly lifetime: AbortController;
+    resolving: boolean;
+    retained: boolean;
+    uncertain: boolean;
+    /** An abandon frees the slot of a running replay before the replay ends. */
+    holdsSlot: boolean;
+};
+export declare class MutationLanes {
+    private readonly maxOperations;
+    private readonly maxBytes;
+    private readonly lanes;
+    private readonly operations;
+    /**
+     * The outcomes that replays proved, oldest first: the committed rejection,
+     * or `undefined` for a committed success. A reset keeps them, because
+     * operation ids never repeat within a client.
+     */
+    private readonly proved;
+    private readonly waiting;
+    private readonly capacityWaiting;
+    private readonly changed;
+    private count;
+    private bytes;
+    constructor(maxOperations: number, maxBytes: number);
+    enter(lane: string, command: number, body: Buffer, context: PartitionContext, retainable: boolean, session: VsrSession, deadline: number, signal: AbortSignal): Promise<ClientOperation>;
+    restart(operation: ClientOperation, body: Buffer, context: PartitionContext, session: VsrSession, deadline: number, signal: AbortSignal): Promise<void>;
+    private freeze;
+    throwIfRetained(lane: string): void;
+    retained(id: bigint): ClientOperation;
+    owns(operation: ClientOperation): boolean;
+    retain(operation: ClientOperation): void;
+    /** Completes a call that proved its outcome. A replay keeps the outcome for a later resolve. */
+    prove(operation: ClientOperation, rejection?: unknown): void;
+    /** Returns or throws the outcome that a replay proved for `id`. */
+    provedOutcome(id: bigint): void;
+    /**
+     * Drops the retained operation `id`, whose outcome stays unknown, and frees
+     * its slot. A running replay keeps the lane until it ends, so the lane stays
+     * FIFO.
+     */
+    abandon(id: bigint): void;
+    complete(operation: ClientOperation): void;
+    /**
+     * Drops the retained operations and ends their replays, because no other
+     * session can replay their frames. A call keeps the lane it holds and starts
+     * again under the next session, so the calls in a lane keep their order.
+     */
+    reset(): void;
+    private releaseSlot;
+    private wakeLane;
+    private wakeWaiting;
+    acquireResolution(operation: ClientOperation, deadline: number, signal: AbortSignal): Promise<() => void>;
+}
+//# sourceMappingURL=client.operation.d.ts.map