Node: added COPY command

CHANGELOG.md

@@ -25,6 +25,7 @@
 * Node: Added FUNCTION DELETE command ([#1990](https:/valkey-io/valkey-glide/pull/1990))
 * Node: Added FUNCTION FLUSH command ([#1984](https:/valkey-io/valkey-glide/pull/1984))
 * Node: Added FCALL and FCALL_RO commands ([#2011](https:/valkey-io/valkey-glide/pull/2011))
+* Node: Added COPY command ([#2024](https:/valkey-io/valkey-glide/pull/2024))
 * Node: Added ZMPOP command ([#1994](https:/valkey-io/valkey-glide/pull/1994))
 * Node: Added ZINCRBY command ([#2009](https:/valkey-io/valkey-glide/pull/2009))
 * Node: Added BZMPOP command ([#2018](https:/valkey-io/valkey-glide/pull/2018))

node/src/BaseClient.ts

@@ -12,13 +12,13 @@ import * as net from "net";
 import { Buffer, BufferWriter, Reader, Writer } from "protobufjs";
 import {
  AggregationType,
- BitmapIndexType,
  BitOffsetOptions,
+ BitmapIndexType,
  BitwiseOperation,
  ExpireOptions,
  GeoAddOptions,
- GeospatialData,
  GeoUnit,
+ GeospatialData,
  InsertPosition,
  KeyWeight,
  LPosOptions,
@@ -35,10 +35,11 @@ import {
  ZAddOptions,
  createBLPop,
  createBRPop,
+ createBZMPop,
  createBitCount,
  createBitOp,
- createBZMPop,
  createBitPos,
+ createCopy,
  createDecr,
  createDecrBy,
  createDel,
@@ -3494,6 +3495,36 @@ export class BaseClient {
  return this.createWritePromise(createObjectRefcount(key));
  }
 
+ /**
+ * Copies the value stored at the `source` to the `destination` key if the `destination` key does not
+ * yet exist.
+ *
+ * See https://valkey.io/commands/copy/ for more details.
+ *
+ * since Valkey version 6.2.0.
+ *
+ * @remarks When in cluster mode, `source` and `destination` must map to the same hash slot.
+ * @param source - The key to the source value.
+ * @param destination - The key where the value should be copied to.
+ * @param replace - If the destination key should be removed before copying the value to it.
+ * @returns `true` if `source` was copied, `false` if the `source` was not copied.
+ *
+ * @example
+ * ```typescript
+ * const result = await client.copy("set1", "set2", true);
+ * console.log(result); // Output: true - "set1" was copied to "set2".
+ * ```
+ */
+ public async copy(
+ source: string,
+ destination: string,
+ replace?: boolean,
+ ): Promise<boolean> {
+ return this.createWritePromise(
+ createCopy(source, destination, undefined, replace),
+ );
+ }
+
  /**
  * Invokes a previously loaded function.
  *

node/src/Commands.ts

@@ -1982,6 +1982,29 @@ export function createFlushDB(mode?: FlushMode): command_request.Command {
  }
 }
 
+/**
+ *
+ * @internal
+ */
+export function createCopy(
+ source: string,
+ destination: string,
+ destinationDB?: number,
+ replace?: boolean,
+): command_request.Command {
+ let args: string[] = [source, destination];
+
+ if (destinationDB) {
+ args = args.concat("DB", destinationDB.toString());
+ }
+
+ if (replace) {
+ args.push("REPLACE");
+ }
+
+ return createCommand(RequestType.Copy, args);
+}
+
 /**
  * Optional arguments to LPOS command.
  *

node/src/GlideClient.ts

@@ -19,6 +19,7 @@ import {
  createConfigResetStat,
  createConfigRewrite,
  createConfigSet,
+ createCopy,
  createCustomCommand,
  createDBSize,
  createEcho,
@@ -371,6 +372,37 @@ export class GlideClient extends BaseClient {
  return this.createWritePromise(createTime());
  }
 
+ /**
+ * Copies the value stored at the `source` to the `destination` key on `destinationDB`. When `replace`
+ * is true, removes the `destination` key first if it already exists, otherwise performs no action.
+ *
+ * See https://valkey.io/commands/copy/ for more details.
+ *
+ * since Valkey version 6.2.0.
+ *
+ * @param source - The key to the source value.
+ * @param destination - The key where the value should be copied to.
+ * @param destinationDB - The alternative logical database index for the destination key.
+ * @param replace - If the destination key should be removed before copying the value to it.
+ * @returns `true` if `source` was copied, `false` if the `source` was not copied.
+ *
+ * @example
+ * ```typescript
+ * const result = await client.copy("set1", "set2", 1, false);
+ * console.log(result); // Output: true - "set1" was copied to "set2".
+ * ```
+ */
+ public async copyDB(
+ source: string,
+ destination: string,
+ destinationDB?: number,
+ replace?: boolean,
+ ): Promise<boolean> {
+ return this.createWritePromise(
+ createCopy(source, destination, destinationDB, replace),
+ );
+ }
+
  /**
  * Displays a piece of generative computer art and the server version.
  *

node/src/Transaction.ts

@@ -40,6 +40,7 @@ import {
  createConfigResetStat,
  createConfigRewrite,
  createConfigSet,
+ createCopy,
  createCustomCommand,
  createDBSize,
  createDecr,
@@ -1951,6 +1952,32 @@ export class BaseTransaction<T extends BaseTransaction<T>> {
  return this.addAndReturn(createObjectRefcount(key));
  }
 
+ /**
+ * Copies the value stored at the `source` to the `destination` key on `destinationDB`. When `replace`
+ * is true, removes the `destination` key first if it already exists, otherwise performs no action.
+ *
+ * See https://valkey.io/commands/copy/ for more details.
+ *
+ * since Valkey version 6.2.0.
+ *
+ * @param source - The key to the source value.
+ * @param destination - The key where the value should be copied to.
+ * @param destinationDB - The alternative logical database index for the destination key.
+ * @param replace - If the destination key should be removed before copying the value to it.
+ *
+ * Command Response - `true` if `source` was copied, `false` if the `source` was not copied.
+ */
+ public copy(
+ source: string,
+ destination: string,
+ destinationDB?: number, // ychen - should I remove this since copy with DB doesn't work under cluster mode
+ replace?: boolean,
+ ): T {
+ return this.addAndReturn(
+ createCopy(source, destination, destinationDB, replace),
+ );
+ }
+
  /**
  * Displays a piece of generative computer art and the server version.
  *

node/tests/RedisClient.test.ts

@@ -365,6 +365,92 @@ describe("GlideClient", () => {
  TIMEOUT,
  );
 
+ it.each([ProtocolVersion.RESP2, ProtocolVersion.RESP3])(
+ "copy with DB test_%p",
+ async (protocol) => {
+ if (cluster.checkIfServerVersionLessThan("6.2.0")) return;
+
+ const client = await GlideClient.createClient(
+ getClientConfigurationOption(cluster.getAddresses(), protocol),
+ );
+
+ const source = `{key}-${uuidv4()}`;
+ const destination = `{key}-${uuidv4()}`;
+ const value1 = uuidv4();
+ const value2 = uuidv4();
+ const index0 = 0;
+ const index1 = 1;
+ const index2 = 2;
+
+ try {
+ // neither key exists
+ checkSimple(
+ await client.copyDB(source, destination, index1, false),
+ ).toEqual(false);
+
+ // source exists, destination does not
+ expect(await client.set(source, value1)).toEqual("OK");
+ checkSimple(
+ await client.copyDB(source, destination, index1, false),
+ ).toEqual(true);
+ expect(await client.select(index1)).toEqual("OK");
+ checkSimple(await client.get(destination)).toEqual(value1);
+
+ // new value for source key
+ expect(await client.select(index0)).toEqual("OK");
+ expect(await client.set(source, value2)).toEqual("OK");
+
+ // no REPLACE, copying to existing key on DB 0 & 1, non-existing key on DB 2
+ checkSimple(
+ await client.copyDB(source, destination, index1, false),
+ ).toEqual(false);
+ checkSimple(
+ await client.copyDB(source, destination, index2, false),
+ ).toEqual(true);
+
+ // new value only gets copied to DB 2
+ expect(await client.select(index1)).toEqual("OK");
+ checkSimple(await client.get(destination)).toEqual(value1);
+ expect(await client.select(index2)).toEqual("OK");
+ checkSimple(await client.get(destination)).toEqual(value2);
+
+ // both exists, with REPLACE, when value isn't the same, source always get copied to
+ // destination
+ expect(await client.select(index0)).toEqual("OK");
+ checkSimple(
+ await client.copyDB(source, destination, index1, true),
+ ).toEqual(true);
+ expect(await client.select(index1)).toEqual("OK");
+ checkSimple(await client.get(destination)).toEqual(value2);
+ } finally {
+ // switching back to db 0
+ await client.select(index0);
+ }
+
+ // transaction tests
+ try {
+ const transaction = new Transaction();
+ transaction.select(index1);
+ transaction.set(source, value1);
+ transaction.copy(source, destination, index1, true);
+ transaction.get(destination);
+ const results = await client.exec(transaction);
+
+ if (results != null) {
+ checkSimple(results.length).toEqual(4);
+ checkSimple(results[2]).toEqual(true);
+ checkSimple(results[3]).toEqual(value1);
+ }
+ } finally {
+ // switching back to db 0
+ await client.select(index0);
+ }
+
+ client.close();
+ },
+ TIMEOUT,
+ );
+
  it.each([ProtocolVersion.RESP2, ProtocolVersion.RESP3])(
  "function load test_%p",
  async (protocol) => {

node/tests/SharedTests.ts

@@ -18,11 +18,11 @@ import {
  FlushMode,
  GeoUnit,
  GeospatialData,
- ListDirection,
  GlideClient,
  GlideClusterClient,
  InfoOptions,
  InsertPosition,
+ ListDirection,
  ProtocolVersion,
  RequestError,
  ScoreFilter,
@@ -4482,6 +4482,54 @@ export function runBaseTests<Context>(config: {
  config.timeout,
  );
 
+ it.each([ProtocolVersion.RESP2, ProtocolVersion.RESP3])(
+ "copy test_%p",
+ async (protocol) => {
+ await runTest(async (client: BaseClient, cluster: RedisCluster) => {
+ if (cluster.checkIfServerVersionLessThan("6.2.0")) return;
+
+ const source = `{key}-${uuidv4()}`;
+ const destination = `{key}-${uuidv4()}`;
+ const value1 = uuidv4();
+ const value2 = uuidv4();
+
+ // neither key exists
+ checkSimple(
+ await client.copy(source, destination, false),
+ ).toEqual(false);
+ checkSimple(await client.copy(source, destination)).toEqual(
+ false,
+ );
+
+ // source exists, destination does not
+ expect(await client.set(source, value1)).toEqual("OK");
+ checkSimple(
+ await client.copy(source, destination, false),
+ ).toEqual(true);
+ checkSimple(await client.get(destination)).toEqual(value1);
+
+ // new value for source key
+ expect(await client.set(source, value2)).toEqual("OK");
+
+ // both exists, no REPLACE
+ checkSimple(await client.copy(source, destination)).toEqual(
+ false,
+ );
+ checkSimple(
+ await client.copy(source, destination, false),
+ ).toEqual(false);
+ checkSimple(await client.get(destination)).toEqual(value1);
+
+ // both exists, with REPLACE
+ checkSimple(
+ await client.copy(source, destination, true),
+ ).toEqual(true);
+ checkSimple(await client.get(destination)).toEqual(value2);
+ }, protocol);
+ },
+ config.timeout,
+ );
+
  it.each([ProtocolVersion.RESP2, ProtocolVersion.RESP3])(
  `flushall test_%p`,
  async (protocol) => {

node/tests/TestUtilities.ts

@@ -5,8 +5,8 @@
 import { beforeAll, expect } from "@jest/globals";
 import { exec } from "child_process";
 import parseArgs from "minimist";
-import { v4 as uuidv4 } from "uuid";
 import { gte } from "semver";
+import { v4 as uuidv4 } from "uuid";
 import {
  BaseClient,
  BaseClientConfiguration,
@@ -717,6 +717,12 @@ export async function transactionTest(
  'xtrim(key9, { method: "minid", threshold: "0-2", exact: true }',
  1,
  ]);
+
+ if (gte("6.2.0", version)) {
+ baseTransaction.copy(key9, key10, undefined, true);
+ responseData.push(["copy(key9, key10, undefined, true)", true]);
+ }
+
  baseTransaction.rename(key9, key10);
  responseData.push(["rename(key9, key10)", "OK"]);
  baseTransaction.exists([key10]);