Add NodeJS

Signed-off-by: Shoham Elias <shohame@amazon.com>

Author: shohamazon

node/src/BaseClient.ts

@@ -46,6 +46,7 @@ import {
     ScoreFilter,
     SearchOrigin,
     SetOptions,
+    SortOptions,
     StreamAddOptions,
     StreamClaimOptions,
     StreamGroupOptions,
@@ -168,6 +169,8 @@ import {
     createSet,
     createSetBit,
     createSetRange,
+    createSort,
+    createSortReadOnly,
     createStrlen,
     createTTL,
     createTouch,
@@ -7305,6 +7308,112 @@ export class BaseClient {
         );
     }
 
+    /**
+     * Sorts the elements in the list, set, or sorted set at `key` and returns the result.
+     *
+     * The `sort` command can be used to sort elements based on different criteria and
+     * apply transformations on sorted elements.
+     *
+     * To store the result into a new key, see {@link sortStore}.
+     *
+     * @see {@link https://valkey.io/commands/sort/|valkey.io} for more details.
+     * @remarks When in cluster mode, both `key` and the patterns specified in {@link SortOptions.byPattern}
+     * and {@link SortOptions.getPatterns} must map to the same hash slot. The use of {@link SortOptions.byPattern}
+     * and {@link SortOptions.getPatterns} in cluster mode is supported since Valkey version 8.0.
+     * @param key - The key of the list, set, or sorted set to be sorted.
+     * @param options - (Optional) The {@link SortOptions} and {@link DecoderOption}.
+     *
+     * @returns An `Array` of sorted elements.
+     *
+     * @example
+     * ```typescript
+     * await client.hset("user:1", new Map([["name", "Alice"], ["age", "30"]]));
+     * await client.hset("user:2", new Map([["name", "Bob"], ["age", "25"]]));
+     * await client.lpush("user_ids", ["2", "1"]);
+     * const result = await client.sort("user_ids", { byPattern: "user:*->age", getPattern: ["user:*->name"] });
+     * console.log(result); // Output: [ 'Bob', 'Alice' ] - Returns a list of the names sorted by age
+     * ```
+     */
+    public async sort(
+        key: GlideString,
+        options?: SortOptions & DecoderOption,
+    ): Promise<(GlideString | null)[]> {
+        return this.createWritePromise(createSort(key, options), options);
+    }
+
+    /**
+     * Sorts the elements in the list, set, or sorted set at `key` and returns the result.
+     *
+     * The `sortReadOnly` command can be used to sort elements based on different criteria and
+     * apply transformations on sorted elements.
+     *
+     * This command is routed depending on the client's {@link ReadFrom} strategy.
+     *
+     * @see {@link https://valkey.io/commands/sort/|valkey.io} for more details.
+     * @remarks Since Valkey version 7.0.0.
+     * @remarks When in cluster mode, both `key` and the patterns specified in {@link SortOptions.byPattern}
+     * and {@link SortOptions.getPatterns} must map to the same hash slot. The use of {@link SortOptions.byPattern}
+     * and {@link SortOptions.getPatterns} in cluster mode is supported since Valkey version 8.0.
+     * @param key - The key of the list, set, or sorted set to be sorted.
+     * @param options - (Optional) The {@link SortOptions} and {@link DecoderOption}.
+     * @returns An `Array` of sorted elements
+     *
+     * @example
+     * ```typescript
+     * await client.hset("user:1", new Map([["name", "Alice"], ["age", "30"]]));
+     * await client.hset("user:2", new Map([["name", "Bob"], ["age", "25"]]));
+     * await client.lpush("user_ids", ["2", "1"]);
+     * const result = await client.sortReadOnly("user_ids", { byPattern: "user:*->age", getPattern: ["user:*->name"] });
+     * console.log(result); // Output: [ 'Bob', 'Alice' ] - Returns a list of the names sorted by age
+     * ```
+     */
+    public async sortReadOnly(
+        key: GlideString,
+        options?: SortOptions & DecoderOption,
+    ): Promise<(GlideString | null)[]> {
+        return this.createWritePromise(
+            createSortReadOnly(key, options),
+            options,
+        );
+    }
+
+    /**
+     * Sorts the elements in the list, set, or sorted set at `key` and stores the result in
+     * `destination`.
+     *
+     * The `sort` command can be used to sort elements based on different criteria and
+     * apply transformations on sorted elements, and store the result in a new key.
+     *
+     * To get the sort result without storing it into a key, see {@link sort} or {@link sortReadOnly}.
+     *
+     * @see {@link https://valkey.io/commands/sort|valkey.io} for more details.
+     * @remarks When in cluster mode, `key`, `destination` and the patterns specified in {@link SortOptions.byPattern}
+     * and {@link SortOptions.getPatterns} must map to the same hash slot. The use of {@link SortOptions.byPattern}
+     * and {@link SortOptions.getPatterns} in cluster mode is supported since Valkey version 8.0.
+     *
+     * @param key - The key of the list, set, or sorted set to be sorted.
+     * @param destination - The key where the sorted result will be stored.
+     * @param options - (Optional) The {@link SortOptions}.
+     * @returns The number of elements in the sorted key stored at `destination`.
+     *
+     * @example
+     * ```typescript
+     * await client.hset("user:1", new Map([["name", "Alice"], ["age", "30"]]));
+     * await client.hset("user:2", new Map([["name", "Bob"], ["age", "25"]]));
+     * await client.lpush("user_ids", ["2", "1"]);
+     * const sortedElements = await client.sortStore("user_ids", "sortedList", { byPattern: "user:*->age", getPattern: ["user:*->name"] });
+     * console.log(sortedElements); // Output: 2 - number of elements sorted and stored
+     * console.log(await client.lrange("sortedList", 0, -1)); // Output: [ 'Bob', 'Alice' ] - Returns a list of the names sorted by age stored in `sortedList`
+     * ```
+     */
+    public async sortStore(
+        key: GlideString,
+        destination: GlideString,
+        options?: SortOptions,
+    ): Promise<number> {
+        return this.createWritePromise(createSort(key, options, destination));
+    }
+
     /**
      * @internal
      */

node/src/Commands.ts

@@ -3544,20 +3544,30 @@ export function createZIncrBy(
 }
 
 /**
- * Optional arguments to {@link GlideClient.sort|sort}, {@link GlideClient.sortStore|sortStore} and {@link GlideClient.sortReadOnly|sortReadOnly} commands.
+ * Optional arguments to {@link BaseClient.sort|sort}, {@link BaseClient.sortStore|sortStore} and {@link BaseClient.sortReadOnly|sortReadOnly} commands.
  *
  * See https://valkey.io/commands/sort/ for more details.
+ *
+ * @remarks When in cluster mode, {@link SortOptions.byPattern|byPattern} and {@link SortOptions.getPatterns|getPattern} must map to the same hash
+ *     slot as the key, and this is supported only since Valkey version 8.0.
  */
-export type SortOptions = SortBaseOptions & {
+export interface SortOptions {
     /**
      * A pattern to sort by external keys instead of by the elements stored at the key themselves. The
      * pattern should contain an asterisk (*) as a placeholder for the element values, where the value
      * from the key replaces the asterisk to create the key name. For example, if `key`
      * contains IDs of objects, `byPattern` can be used to sort these IDs based on an
      * attribute of the objects, like their weights or timestamps.
+     * Supported in cluster mode since Valkey version 8.0 and above.
      */
     byPattern?: GlideString;
 
+    /**
+     * Limiting the range of the query by setting offset and result count. See {@link Limit} class for
+     * more information.
+     */
+    limit?: Limit;
+
     /**
      * A pattern used to retrieve external keys' values, instead of the elements at `key`.
      * The pattern should contain an asterisk (`*`) as a placeholder for the element values, where the
@@ -3570,16 +3580,9 @@ export type SortOptions = SortBaseOptions & {
      * arguments can be provided to retrieve multiple attributes. The special value `#` can
      * be used to include the actual element from `key` being sorted. If not provided, only
      * the sorted elements themselves are returned.
+     * Supported in cluster mode since Valkey version 8.0 and above.
      */
     getPatterns?: GlideString[];
-};
-
-interface SortBaseOptions {
-    /**
-     * Limiting the range of the query by setting offset and result count. See {@link Limit} class for
-     * more information.
-     */
-    limit?: Limit;
 
     /** Options for sorting order of elements. */
     orderBy?: SortOrder;
@@ -3592,13 +3595,6 @@ interface SortBaseOptions {
     isAlpha?: boolean;
 }
 
-/**
- * Optional arguments to {@link GlideClusterClient.sort|sort}, {@link GlideClusterClient.sortStore|sortStore} and {@link GlideClusterClient.sortReadOnly|sortReadOnly} commands.
- *
- * See https://valkey.io/commands/sort/ for more details.
- */
-export type SortClusterOptions = SortBaseOptions;
-
 /**
  * The `LIMIT` argument is commonly used to specify a subset of results from the
  * matching elements, similar to the `LIMIT` clause in SQL (e.g., `SELECT LIMIT offset, count`).

node/src/GlideClient.ts

@@ -13,7 +13,6 @@ import {
     GlideReturnType,
     GlideString,
     PubSubMsg,
-    ReadFrom, // eslint-disable-line @typescript-eslint/no-unused-vars
 } from "./BaseClient";
 import {
     createClientGetName,
@@ -44,8 +43,6 @@ import {
     createPublish,
     createRandomKey,
     createSelect,
-    createSort,
-    createSortReadOnly,
     createTime,
     createUnWatch,
     FlushMode,
@@ -55,7 +52,6 @@ import {
     FunctionStatsFullResponse,
     InfoOptions,
     LolwutOptions,
-    SortOptions,
 } from "./Commands";
 import { connection_request } from "./ProtobufMessage";
 import { Transaction } from "./Transaction";
@@ -862,106 +858,6 @@ export class GlideClient extends BaseClient {
         return this.createWritePromise(createPublish(message, channel));
     }
 
-    /**
-     * Sorts the elements in the list, set, or sorted set at `key` and returns the result.
-     *
-     * The `sort` command can be used to sort elements based on different criteria and
-     * apply transformations on sorted elements.
-     *
-     * To store the result into a new key, see {@link sortStore}.
-     *
-     * @see {@link https://valkey.io/commands/sort/|valkey.io} for more details.
-     *
-     * @param key - The key of the list, set, or sorted set to be sorted.
-     * @param options - (Optional) The {@link SortOptions} and {@link DecoderOption}.
-     *
-     * @returns An `Array` of sorted elements.
-     *
-     * @example
-     * ```typescript
-     * await client.hset("user:1", new Map([["name", "Alice"], ["age", "30"]]));
-     * await client.hset("user:2", new Map([["name", "Bob"], ["age", "25"]]));
-     * await client.lpush("user_ids", ["2", "1"]);
-     * const result = await client.sort("user_ids", { byPattern: "user:*->age", getPattern: ["user:*->name"] });
-     * console.log(result); // Output: [ 'Bob', 'Alice' ] - Returns a list of the names sorted by age
-     * ```
-     */
-    public async sort(
-        key: GlideString,
-        options?: SortOptions & DecoderOption,
-    ): Promise<(GlideString | null)[]> {
-        return this.createWritePromise(createSort(key, options), options);
-    }
-
-    /**
-     * Sorts the elements in the list, set, or sorted set at `key` and returns the result.
-     *
-     * The `sortReadOnly` command can be used to sort elements based on different criteria and
-     * apply transformations on sorted elements.
-     *
-     * This command is routed depending on the client's {@link ReadFrom} strategy.
-     *
-     * @see {@link https://valkey.io/commands/sort/|valkey.io} for more details.
-     * @remarks Since Valkey version 7.0.0.
-     *
-     * @param key - The key of the list, set, or sorted set to be sorted.
-     * @param options - (Optional) The {@link SortOptions} and {@link DecoderOption}.
-     * @returns An `Array` of sorted elements
-     *
-     * @example
-     * ```typescript
-     * await client.hset("user:1", new Map([["name", "Alice"], ["age", "30"]]));
-     * await client.hset("user:2", new Map([["name", "Bob"], ["age", "25"]]));
-     * await client.lpush("user_ids", ["2", "1"]);
-     * const result = await client.sortReadOnly("user_ids", { byPattern: "user:*->age", getPattern: ["user:*->name"] });
-     * console.log(result); // Output: [ 'Bob', 'Alice' ] - Returns a list of the names sorted by age
-     * ```
-     */
-    public async sortReadOnly(
-        key: GlideString,
-        options?: SortOptions & DecoderOption,
-    ): Promise<(GlideString | null)[]> {
-        return this.createWritePromise(
-            createSortReadOnly(key, options),
-            options,
-        );
-    }
-
-    /**
-     * Sorts the elements in the list, set, or sorted set at `key` and stores the result in
-     * `destination`.
-     *
-     * The `sort` command can be used to sort elements based on different criteria and
-     * apply transformations on sorted elements, and store the result in a new key.
-     *
-     * To get the sort result without storing it into a key, see {@link sort} or {@link sortReadOnly}.
-     *
-     * @see {@link https://valkey.io/commands/sort|valkey.io} for more details.
-     * @remarks When in cluster mode, `destination` and `key` must map to the same hash slot.
-     *
-     * @param key - The key of the list, set, or sorted set to be sorted.
-     * @param destination - The key where the sorted result will be stored.
-     * @param options - (Optional) The {@link SortOptions}.
-     * @returns The number of elements in the sorted key stored at `destination`.
-     *
-     * @example
-     * ```typescript
-     * await client.hset("user:1", new Map([["name", "Alice"], ["age", "30"]]));
-     * await client.hset("user:2", new Map([["name", "Bob"], ["age", "25"]]));
-     * await client.lpush("user_ids", ["2", "1"]);
-     * const sortedElements = await client.sortStore("user_ids", "sortedList", { byPattern: "user:*->age", getPattern: ["user:*->name"] });
-     * console.log(sortedElements); // Output: 2 - number of elements sorted and stored
-     * console.log(await client.lrange("sortedList", 0, -1)); // Output: [ 'Bob', 'Alice' ] - Returns a list of the names sorted by age stored in `sortedList`
-     * ```
-     */
-    public async sortStore(
-        key: GlideString,
-        destination: GlideString,
-        options?: SortOptions,
-    ): Promise<number> {
-        return this.createWritePromise(createSort(key, options, destination));
-    }
-
     /**
      * Returns `UNIX TIME` of the last DB save timestamp or startup timestamp if no save
      * was made since then.