@valkey/valkey-glide 2.4.2-rc2 → 2.5.0-rc2

package/build-ts/GlideClient.js

@@ -306,6 +306,25 @@ class GlideClient extends BaseClient_1.BaseClient {
     async clientId() {
         return this.createWritePromise((0, Commands_1.createClientId)());
     }
+    /**
+     * Returns information about the current client connection's use
+     * of the server assisted client side caching feature.
+     *
+     * @see {@link https://valkey.io/commands/client-trackinginfo/|valkey.io} for details.
+     *
+     * @returns The tracking info for the client.
+     *
+     * @example
+     * ```typescript
+     * const info = await client.clientTrackingInfo();
+     * console.log(info.flags); // Set { "off" }
+     * console.log(info.redirect); // -1
+     * console.log(info.prefixes); // Set {}
+     * ```
+     */
+    async clientTrackingInfo() {
+        return this.createWritePromise((0, Commands_1.createClientTrackingInfo)()).then((res) => (0, Commands_1.parseClientTrackingInfoResponse)((0, BaseClient_1.convertGlideRecordToRecord)(res)));
+    }
     /**
      * Reads the configuration parameters of the running server.
      * Starting from server version 7, command supports multiple parameters.
@@ -695,6 +714,153 @@ class GlideClient extends BaseClient_1.BaseClient {
     async lastsave() {
         return this.createWritePromise((0, Commands_1.createLastSave)());
     }
+    /**
+     * Returns the latency spike time series for the specified event.
+     *
+     * @see {@link https://valkey.io/commands/latency-history/|valkey.io} for details.
+     *
+     * @param event - The name of the latency event (e.g., `"command"`).
+     * @returns An array of {@link LatencyEntry} for the event, or an empty array if the event doesn't exist.
+     *
+     * @example
+     * ```typescript
+     * const history = await client.latencyHistory("command");
+     * for (const entry of history) {
+     *     console.log(`Time: ${entry.time}, Latency: ${entry.latency}`);
+     * }
+     * ```
+     */
+    async latencyHistory(event) {
+        return this.createWritePromise((0, Commands_1.createLatencyHistory)(event)).then((res) => (0, Commands_1.parseLatencyHistoryResponse)(res));
+    }
+    /**
+     * Reports the latest latency events logged by the server.
+     *
+     * @see {@link https://valkey.io/commands/latency-latest/|valkey.io} for details.
+     *
+     * @returns An array of {@link LatencyEventInfo} for the latest latency events.
+     *
+     * @example
+     * ```typescript
+     * const latest = await client.latencyLatest();
+     * for (const info of latest) {
+     *     console.log(`Event: ${info.eventName}, Latest: ${info.latestDuration}`);
+     * }
+     * ```
+     */
+    async latencyLatest() {
+        return this.createWritePromise((0, Commands_1.createLatencyLatest)()).then((res) => (0, Commands_1.parseLatencyLatestResponse)(res));
+    }
+    /**
+     * Resets the latency spike time series for all or specified events.
+     * If no events are provided, resets the latency spike time series for all events.
+     *
+     * @see {@link https://valkey.io/commands/latency-reset/|valkey.io} for details.
+     *
+     * @param events - The event names to reset. If not provided, resets all events.
+     * @returns The number of event time series that were reset.
+     *
+     * @example
+     * ```typescript
+     * await client.latencyReset(); // Resets all events
+     * await client.latencyReset(["command"]); // Resets only "command"
+     * ```
+     */
+    async latencyReset(events) {
+        return this.createWritePromise((0, Commands_1.createLatencyReset)(events));
+    }
+    /**
+     * Synchronously saves the dataset to disk.
+     *
+     * @see {@link https://valkey.io/commands/save/|valkey.io} for more details.
+     *
+     * @returns `"OK"`
+     *
+     * @example
+     * ```typescript
+     * const result = await client.save();
+     * console.log(result); // "OK"
+     * ```
+     */
+    async save() {
+        return this.createWritePromise((0, Commands_1.createSave)(), {
+            decoder: BaseClient_1.Decoder.String,
+        });
+    }
+    /**
+     * Asynchronously saves the dataset to disk in the background.
+     *
+     * @see {@link https://valkey.io/commands/bgsave/|valkey.io} for more details.
+     *
+     * @returns A non-empty status string.
+     *
+     * @example
+     * ```typescript
+     * const result = await client.bgsave();
+     * console.log(result); // "Background saving started"
+     * ```
+     */
+    async bgsave() {
+        return this.createWritePromise((0, Commands_1.createBgSave)(), {
+            decoder: BaseClient_1.Decoder.String,
+        });
+    }
+    /**
+     * Schedules a background save of the database.
+     *
+     * @see {@link https://valkey.io/commands/bgsave/|valkey.io} for more details.
+     *
+     * @returns A non-empty status string.
+     *
+     * @example
+     * ```typescript
+     * const result = await client.bgsaveSchedule();
+     * console.log(result); // "Background saving scheduled"
+     * ```
+     */
+    async bgsaveSchedule() {
+        return this.createWritePromise((0, Commands_1.createBgSave)(["SCHEDULE"]), {
+            decoder: BaseClient_1.Decoder.String,
+        });
+    }
+    /**
+     * Aborts all in-progress and scheduled background saves.
+     *
+     * @see {@link https://valkey.io/commands/bgsave/|valkey.io} for more details.
+     *
+     * @since Valkey 8.1
+     *
+     * @returns A non-empty status string.
+     *
+     * @example
+     * ```typescript
+     * const result = await client.bgsaveCancel();
+     * console.log(result); // "Background saving cancelled"
+     * ```
+     */
+    async bgsaveCancel() {
+        return this.createWritePromise((0, Commands_1.createBgSave)(["CANCEL"]), {
+            decoder: BaseClient_1.Decoder.String,
+        });
+    }
+    /**
+     * Initiates a background rewrite of the append-only file (AOF).
+     *
+     * @see {@link https://valkey.io/commands/bgrewriteaof/|valkey.io} for more details.
+     *
+     * @returns A non-empty status string.
+     *
+     * @example
+     * ```typescript
+     * const result = await client.bgrewriteaof();
+     * console.log(result); // "Background append only file rewriting started"
+     * ```
+     */
+    async bgrewriteaof() {
+        return this.createWritePromise((0, Commands_1.createBgRewriteAof)(), {
+            decoder: BaseClient_1.Decoder.String,
+        });
+    }
     /**
      * Returns a random existing key name from the currently selected database.
      *
@@ -711,6 +877,40 @@ class GlideClient extends BaseClient_1.BaseClient {
     async randomKey(options) {
         return this.createWritePromise((0, Commands_1.createRandomKey)(), options);
     }
+    /**
+     * Atomically transfers a key or multiple keys from the current Valkey instance
+     * to a destination Valkey instance.
+     * On success, keys are deleted from the source unless `copy` is set to `true` in options.
+     *
+     * @see {@link https://valkey.io/commands/migrate/|valkey.io} for details.
+     *
+     * @param host - The host of the destination Valkey instance.
+     * @param port - The port of the destination Valkey instance.
+     * @param key - The key to migrate, or an array of keys to migrate.
+     * @param destinationDB - The database index on the destination instance.
+     * @param timeout - The maximum idle time in milliseconds for the bulk-transfer.
+     * @param options - Optional migration options.
+     * @returns `"OK"` on success, `"NOKEY"` if the key(s) do not exist.
+     *
+     * @example Single-key:
+     * ```typescript
+     * const result = await client.migrate("127.0.0.1", 6379, "mykey", 0, 5000);
+     * console.log(result); // "OK"
+     * ```
+     * @example Single-key with copy and replace:
+     * ```typescript
+     * const result = await client.migrate("127.0.0.1", 6379, "mykey", 0, 5000, { copy: true, replace: true });
+     * console.log(result); // "OK"
+     * ```
+     * @example Multi-key:
+     * ```typescript
+     * const result = await client.migrate("127.0.0.1", 6379, ["key1", "key2"], 0, 5000);
+     * console.log(result); // "OK"
+     * ```
+     */
+    async migrate(host, port, key, destinationDB, timeout, options) {
+        return this.createWritePromise((0, Commands_1.createMigrate)(host, port, key, destinationDB, timeout, options));
+    }
     /**
      * Flushes all the previously watched keys for a transaction. Executing a transaction will
      * automatically flush all previously watched keys.
@@ -847,5 +1047,178 @@ class GlideClient extends BaseClient_1.BaseClient {
         const response = await this.createWritePromise((0, Commands_1.createGetSubscriptions)());
         return this.parseGetSubscriptionsResponse(response);
     }
+    /**
+     * Suspends all clients for the specified timeout.
+     *
+     * @see {@link https://valkey.io/commands/client-pause/|valkey.io} for details.
+     *
+     * @param timeout - The time in milliseconds to pause clients.
+     * @param mode - (Optional) The pause mode to use.
+     *   + If not provided, all commands are paused.
+     * @param options - (Optional) See {@link DecoderOption}.
+     * @returns `"OK"` response on success.
+     *
+     * @example
+     * ```typescript
+     * const result = await client.clientPause(1000);
+     * console.log(result); // Output: 'OK'
+     * ```
+     *
+     * @example
+     * ```typescript
+     * const result = await client.clientPause(1000, ClientPauseMode.WRITE);
+     * console.log(result); // Output: 'OK'
+     * ```
+     */
+    async clientPause(timeout, mode, options) {
+        return this.createWritePromise((0, Commands_1.createClientPause)(timeout, mode), options);
+    }
+    /**
+     * Resumes processing commands on all clients.
+     *
+     * @see {@link https://valkey.io/commands/client-unpause/|valkey.io} for details.
+     *
+     * @param options - (Optional) See {@link DecoderOption}.
+     * @returns `"OK"` response on success.
+     *
+     * @example
+     * ```typescript
+     * const result = await client.clientUnpause();
+     * console.log(result); // Output: 'OK'
+     * ```
+     */
+    async clientUnpause(options) {
+        return this.createWritePromise((0, Commands_1.createClientUnpause)(), options);
+    }
+    /**
+     * Starts a coordinated failover from the connected primary to one of its replicas.
+     * This is the standalone equivalent of `CLUSTER FAILOVER`.
+     *
+     * @see {@link https://valkey.io/commands/failover/|valkey.io} for details.
+     *
+     * @param options - (Optional) Failover options. See {@link FailoverOptions}.
+     * @returns `"OK"` if the failover was successfully initiated.
+     *
+     * @example
+     * ```typescript
+     * const result = await client.failover();
+     * console.log(result); // Output: 'OK'
+     * ```
+     */
+    async failover(options) {
+        return this.createWritePromise((0, Commands_1.createFailover)(options), {
+            decoder: BaseClient_1.Decoder.String,
+        });
+    }
+    /**
+     * Makes the server a replica of the specified primary.
+     *
+     * @see {@link https://valkey.io/commands/replicaof/|valkey.io} for details.
+     *
+     * @param host - The host of the primary to replicate.
+     * @param port - The port of the primary to replicate.
+     * @returns `"OK"` on success.
+     *
+     * @example
+     * ```typescript
+     * const result = await client.replicaof("localhost", 6379);
+     * console.log(result); // Output: 'OK'
+     * ```
+     */
+    async replicaof(host, port) {
+        return this.createWritePromise((0, Commands_1.createReplicaOf)(host, port), {
+            decoder: BaseClient_1.Decoder.String,
+        });
+    }
+    /**
+     * Promotes the current server to a primary by stopping replication.
+     *
+     * @see {@link https://valkey.io/commands/replicaof/|valkey.io} for details.
+     *
+     * @returns `"OK"` on success.
+     *
+     * @example
+     * ```typescript
+     * const result = await client.replicaofNoOne();
+     * console.log(result); // Output: 'OK'
+     * ```
+     */
+    async replicaofNoOne() {
+        return this.createWritePromise((0, Commands_1.createReplicaOfNoOne)(), {
+            decoder: BaseClient_1.Decoder.String,
+        });
+    }
+    // TODO #6166: move to shared base
+    /**
+     * Returns a report about memory problems detected by the server.
+     *
+     * @see {@link https://valkey.io/commands/memory-doctor/|valkey.io} for details.
+     *
+     * @returns The memory diagnostic report.
+     *
+     * @example
+     * ```typescript
+     * const report = await client.memoryDoctor();
+     * console.log(report); // Output: "Sam, I have no memory problems"
+     * ```
+     */
+    async memoryDoctor() {
+        return this.createWritePromise((0, Commands_1.createMemoryDoctor)(), {
+            decoder: BaseClient_1.Decoder.String,
+        });
+    }
+    /**
+     * Returns the internal statistics of the memory allocator.
+     *
+     * @see {@link https://valkey.io/commands/memory-malloc-stats/|valkey.io} for details.
+     *
+     * @returns The memory allocator statistics.
+     *
+     * @example
+     * ```typescript
+     * const stats = await client.memoryMallocStats();
+     * console.log(stats);
+     * ```
+     */
+    async memoryMallocStats() {
+        return this.createWritePromise((0, Commands_1.createMemoryMallocStats)(), {
+            decoder: BaseClient_1.Decoder.String,
+        });
+    }
+    /**
+     * Asks the server to reclaim memory from the allocator back to the operating system.
+     *
+     * @see {@link https://valkey.io/commands/memory-purge/|valkey.io} for details.
+     *
+     * @returns `"OK"`.
+     *
+     * @example
+     * ```typescript
+     * const result = await client.memoryPurge();
+     * console.log(result); // Output: 'OK'
+     * ```
+     */
+    async memoryPurge() {
+        return this.createWritePromise((0, Commands_1.createMemoryPurge)(), {
+            decoder: BaseClient_1.Decoder.String,
+        });
+    }
+    /**
+     * Returns detailed memory consumption statistics of the server.
+     *
+     * @see {@link https://valkey.io/commands/memory-stats/|valkey.io} for details.
+     *
+     * @returns A {@link MemoryStats} object containing detailed memory usage statistics.
+     *
+     * @example
+     * ```typescript
+     * const stats = await client.memoryStats();
+     * console.log(stats.peakAllocated); // Peak memory in bytes
+     * console.log(stats.totalAllocated); // Total allocated memory in bytes
+     * ```
+     */
+    async memoryStats() {
+        return this.createWritePromise((0, Commands_1.createMemoryStats)()).then((res) => (0, Commands_1.parseMemoryStatsResponse)((0, BaseClient_1.convertGlideRecordToRecord)(res)));
+    }
 }
 exports.GlideClient = GlideClient;