@upstash/redis 0.0.0-ci.bafaa360-20230119 → 0.0.0-ci.bb93ac2803c2e927dc8bf1a1b3c5aa2a14034eb6-20240930061920

package/pkg/commands/bitop.ts

@@ -0,0 +1,22 @@
+import type { CommandOptions } from "./command";
+import { Command } from "./command";
+
+/**
+ * @see https://redis.io/commands/bitop
+ */
+export class BitOpCommand extends Command<number, number> {
+  constructor(
+    cmd: [op: "and" | "or" | "xor", destinationKey: string, ...sourceKeys: string[]],
+    opts?: CommandOptions<number, number>
+  );
+  constructor(
+    cmd: [op: "not", destinationKey: string, sourceKey: string],
+    opts?: CommandOptions<number, number>
+  );
+  constructor(
+    cmd: [op: "and" | "or" | "xor" | "not", destinationKey: string, ...sourceKeys: string[]],
+    opts?: CommandOptions<number, number>
+  ) {
+    super(["bitop", ...cmd], opts);
+  }
+}

package/pkg/commands/bitpos.test.ts

@@ -0,0 +1,47 @@
+import { afterAll, describe, expect, test } from "bun:test";
+import { keygen, newHttpClient } from "../test-utils";
+import { BitPosCommand } from "./bitpos";
+import { SetCommand } from "./set";
+
+const client = newHttpClient();
+
+const { newKey, cleanup } = keygen();
+afterAll(cleanup);
+
+describe("when key is not set", () => {
+  test("returns 0", async () => {
+    const key = newKey();
+    const res = await new BitPosCommand([key, 0]).exec(client);
+    expect(res).toEqual(0);
+  });
+});
+
+describe("when key is set", () => {
+  test("returns position of first set bit", async () => {
+    const key = newKey();
+    const value = "\u00FF\u00F0\u0000";
+    await new SetCommand([key, value]).exec(client);
+    const res = await new BitPosCommand([key, 0]).exec(client);
+    expect(res).toEqual(2);
+  });
+});
+
+describe("with start", () => {
+  test("returns position of first set bit", async () => {
+    const key = newKey();
+    const value = "\u0000\u00FF\u00F0";
+    await new SetCommand([key, value]).exec(client);
+    const res = await new BitPosCommand([key, 0, 0]).exec(client);
+    expect(res).toEqual(0);
+  });
+});
+
+describe("with start and end", () => {
+  test("returns position of first set bit", async () => {
+    const key = newKey();
+    const value = "\u0000\u00FF\u00F0";
+    await new SetCommand([key, value]).exec(client);
+    const res = await new BitPosCommand([key, 1, 2, -1]).exec(client);
+    expect(res).toEqual(16);
+  });
+});

package/pkg/commands/bitpos.ts

@@ -0,0 +1,14 @@
+import type { CommandOptions } from "./command";
+import { Command } from "./command";
+
+/**
+ * @see https://redis.io/commands/bitpos
+ */
+export class BitPosCommand extends Command<number, number> {
+  constructor(
+    cmd: [key: string, bit: 0 | 1, start?: number, end?: number],
+    opts?: CommandOptions<number, number>
+  ) {
+    super(["bitpos", ...cmd], opts);
+  }
+}

package/pkg/commands/command.test.ts

@@ -0,0 +1,22 @@
+import { keygen, newHttpClient, randomID } from "../test-utils";
+import { Command } from "./command";
+
+import { afterAll, describe, expect, test } from "bun:test";
+
+const client = newHttpClient();
+
+const { newKey, cleanup } = keygen();
+afterAll(cleanup);
+
+describe("deserialize large numbers", () => {
+  test("returns the correct number", async () => {
+    const key = newKey();
+    const field = randomID();
+    const value = "101600000000150081467";
+
+    await new Command(["hset", key, field, value]).exec(client);
+
+    const res = await new Command(["hget", key, field]).exec(client);
+    expect(res).toEqual(value);
+  });
+});

package/pkg/commands/command.ts

@@ -0,0 +1,98 @@
+import { UpstashError } from "../error";
+import type { Requester } from "../http";
+import { parseResponse } from "../util";
+
+type Serialize = (data: unknown) => string | number | boolean;
+type Deserialize<TResult, TData> = (result: TResult) => TData;
+
+const defaultSerializer: Serialize = (c: unknown) => {
+  switch (typeof c) {
+    case "string":
+    case "number":
+    case "boolean": {
+      return c;
+    }
+
+    default: {
+      return JSON.stringify(c);
+    }
+  }
+};
+
+export type CommandOptions<TResult, TData> = {
+  /**
+   * Custom deserializer
+   */
+  deserialize?: (result: TResult) => TData;
+  /**
+   * Automatically try to deserialize the returned data from upstash using `JSON.deserialize`
+   *
+   * @default true
+   */
+  automaticDeserialization?: boolean;
+  latencyLogging?: boolean;
+};
+/**
+ * Command offers default (de)serialization and the exec method to all commands.
+ *
+ * TData represents what the user will enter or receive,
+ * TResult is the raw data returned from upstash, which may need to be transformed or parsed.
+ */
+export class Command<TResult, TData> {
+  public readonly command: (string | number | boolean)[];
+  public readonly serialize: Serialize;
+  public readonly deserialize: Deserialize<TResult, TData>;
+  /**
+   * Create a new command instance.
+   *
+   * You can define a custom `deserialize` function. By default we try to deserialize as json.
+   */
+  constructor(
+    command: (string | boolean | number | unknown)[],
+    opts?: CommandOptions<TResult, TData>
+  ) {
+    this.serialize = defaultSerializer;
+    this.deserialize =
+      opts?.automaticDeserialization === undefined || opts.automaticDeserialization
+        ? (opts?.deserialize ?? parseResponse)
+        : (x) => x as unknown as TData;
+
+    this.command = command.map((c) => this.serialize(c));
+
+    if (opts?.latencyLogging) {
+      const originalExec = this.exec.bind(this);
+      this.exec = async (client: Requester): Promise<TData> => {
+        const start = performance.now();
+        const result = await originalExec(client);
+        const end = performance.now();
+        const loggerResult = (end - start).toFixed(2);
+        // eslint-disable-next-line no-console
+        console.log(
+          `Latency for \u001B[38;2;19;185;39m${this.command[0]
+            .toString()
+            .toUpperCase()}\u001B[0m: \u001B[38;2;0;255;255m${loggerResult} ms\u001B[0m`
+        );
+        return result;
+      };
+    }
+  }
+
+  /**
+   * Execute the command using a client.
+   */
+  public async exec(client: Requester): Promise<TData> {
+    const { result, error } = await client.request<TResult>({
+      body: this.command,
+      upstashSyncToken: client.upstashSyncToken,
+    });
+
+    if (error) {
+      throw new UpstashError(error);
+    }
+    if (result === undefined) {
+      throw new TypeError("Request did not return a result");
+    }
+
+    return this.deserialize(result);
+  }
+}

package/pkg/commands/copy.test.ts

@@ -0,0 +1,65 @@
+import { keygen, newHttpClient, randomID } from "../test-utils";
+
+import { afterAll, describe, expect, test } from "bun:test";
+import { CopyCommand } from "./copy";
+import { LPushCommand } from "./lpush";
+import { SetCommand } from "./set";
+
+const client = newHttpClient();
+
+const { newKey, cleanup } = keygen();
+afterAll(cleanup);
+
+describe("COPY test", () => {
+  test("should copy key-value to another key", async () => {
+    const key = newKey();
+    const destinationKey = newKey();
+    const value = randomID();
+    await new SetCommand([key, value]).exec(client);
+    const res = await new CopyCommand([key, destinationKey]).exec(client);
+    expect(res).toEqual("COPIED");
+  });
+
+  test("should not override existing destination", async () => {
+    const key = newKey();
+    const destinationKey = newKey();
+    const value = randomID();
+    await new SetCommand([key, value]).exec(client);
+    await new SetCommand([destinationKey, value]).exec(client);
+    const res = await new CopyCommand([key, destinationKey]).exec(client);
+    expect(res).toEqual("NOT_COPIED");
+  });
+
+  test("should override existing destination with replace", async () => {
+    const key = newKey();
+    const destinationKey = newKey();
+    const value = randomID();
+    await new SetCommand([key, value]).exec(client);
+    await new SetCommand([destinationKey, value]).exec(client);
+    const res = await new CopyCommand([key, destinationKey, { replace: true }]).exec(client);
+    expect(res).toEqual("COPIED");
+  });
+
+  test("should handle non-existent source key", async () => {
+    const key = newKey();
+    const destinationKey = newKey();
+    const res = await new CopyCommand([key, destinationKey]).exec(client);
+    expect(res).toEqual("NOT_COPIED");
+  });
+
+  test("should handle same source and destination keys", async () => {
+    const key = newKey();
+    const value = randomID();
+    await new SetCommand([key, value]).exec(client);
+    const res = await new CopyCommand([key, key]).exec(client);
+    expect(res).toEqual("NOT_COPIED");
+  });
+
+  test("should copy list data type", async () => {
+    const key = newKey();
+    const destinationKey = newKey();
+    await new LPushCommand([key, "value1", "value2"]).exec(client);
+    const res = await new CopyCommand([key, destinationKey]).exec(client);
+    expect(res).toEqual("COPIED");
+  });
+});

package/pkg/commands/copy.ts

@@ -0,0 +1,22 @@
+import type { CommandOptions } from "./command";
+import { Command } from "./command";
+
+/**
+ * @see https://redis.io/commands/copy
+ */
+export class CopyCommand extends Command<number, "COPIED" | "NOT_COPIED"> {
+  constructor(
+    [key, destinationKey, opts]: [key: string, destinationKey: string, opts?: { replace: boolean }],
+    commandOptions?: CommandOptions<number, "COPIED" | "NOT_COPIED">
+  ) {
+    super(["COPY", key, destinationKey, ...(opts?.replace ? ["REPLACE"] : [])], {
+      ...commandOptions,
+      deserialize(result) {
+        if (result > 0) {
+          return "COPIED";
+        }
+        return "NOT_COPIED";
+      },
+    });
+  }
+}

package/pkg/commands/dbsize.test.ts

@@ -0,0 +1,18 @@
+import { keygen, newHttpClient, randomID } from "../test-utils";
+
+import { afterAll, expect, test } from "bun:test";
+import { DBSizeCommand } from "./dbsize";
+import { SetCommand } from "./set";
+
+const client = newHttpClient();
+
+const { newKey, cleanup } = keygen();
+afterAll(cleanup);
+
+test("returns the db size", async () => {
+  const key = newKey();
+  const value = randomID();
+  await new SetCommand([key, value]).exec(client);
+  const res = await new DBSizeCommand().exec(client);
+  expect(res > 0).toEqual(true);
+});

package/pkg/commands/dbsize.ts

@@ -0,0 +1,11 @@
+import type { CommandOptions } from "./command";
+import { Command } from "./command";
+
+/**
+ * @see https://redis.io/commands/dbsize
+ */
+export class DBSizeCommand extends Command<number, number> {
+  constructor(opts?: CommandOptions<number, number>) {
+    super(["dbsize"], opts);
+  }
+}

package/pkg/commands/decr.test.ts

@@ -0,0 +1,23 @@
+import { afterAll, expect, test } from "bun:test";
+import { keygen, newHttpClient } from "../test-utils";
+import { DecrCommand } from "./decr";
+import { SetCommand } from "./set";
+
+const client = newHttpClient();
+
+const { newKey, cleanup } = keygen();
+afterAll(cleanup);
+test("decrements a non-existing value", async () => {
+  const key = newKey();
+  const res = await new DecrCommand([key]).exec(client);
+
+  expect(res).toEqual(-1);
+});
+
+test("decrements and existing value", async () => {
+  const key = newKey();
+  await new SetCommand([key, 4]).exec(client);
+  const res = await new DecrCommand([key]).exec(client);
+
+  expect(res).toEqual(3);
+});

package/pkg/commands/decr.ts

@@ -0,0 +1,11 @@
+import type { CommandOptions } from "./command";
+import { Command } from "./command";
+
+/**
+ * @see https://redis.io/commands/decr
+ */
+export class DecrCommand extends Command<number, number> {
+  constructor(cmd: [key: string], opts?: CommandOptions<number, number>) {
+    super(["decr", ...cmd], opts);
+  }
+}

package/pkg/commands/decrby.test.ts

@@ -0,0 +1,24 @@
+import { keygen, newHttpClient } from "../test-utils";
+import { SetCommand } from "./set";
+
+import { afterAll, expect, test } from "bun:test";
+import { DecrByCommand } from "./decrby";
+const client = newHttpClient();
+
+const { newKey, cleanup } = keygen();
+afterAll(cleanup);
+
+test("decrements a non-existing value", async () => {
+  const key = newKey();
+  const res = await new DecrByCommand([key, 2]).exec(client);
+
+  expect(res).toEqual(-2);
+});
+
+test("decrements and existing value", async () => {
+  const key = newKey();
+  await new SetCommand([key, 5]).exec(client);
+  const res = await new DecrByCommand([key, 2]).exec(client);
+
+  expect(res).toEqual(3);
+});

package/pkg/commands/decrby.ts

@@ -0,0 +1,11 @@
+import type { CommandOptions } from "./command";
+import { Command } from "./command";
+
+/**
+ * @see https://redis.io/commands/decrby
+ */
+export class DecrByCommand extends Command<number, number> {
+  constructor(cmd: [key: string, decrement: number], opts?: CommandOptions<number, number>) {
+    super(["decrby", ...cmd], opts);
+  }
+}

package/pkg/commands/del.test.ts

@@ -0,0 +1,38 @@
+import { keygen, newHttpClient } from "../test-utils";
+
+import { afterAll, describe, expect, test } from "bun:test";
+import { DelCommand } from "./del";
+import { SetCommand } from "./set";
+
+const client = newHttpClient();
+
+const { newKey, cleanup } = keygen();
+afterAll(cleanup);
+
+describe("when key does not exist", () => {
+  test("does nothing", async () => {
+    const key = newKey();
+
+    const res = await new DelCommand([key]).exec(client);
+    expect(res).toEqual(0);
+  });
+});
+describe("when key does exist", () => {
+  test("deletes the key", async () => {
+    const key = newKey();
+    await new SetCommand([key, "value"]).exec(client);
+    const res = await new DelCommand([key]).exec(client);
+    expect(res).toEqual(1);
+  });
+});
+describe("with multiple keys", () => {
+  describe("when one does not exist", () => {
+    test("deletes all keys", async () => {
+      const key1 = newKey();
+      const key2 = newKey();
+      await new SetCommand([key1, "value"]).exec(client);
+      const res = await new DelCommand([key1, key2]).exec(client);
+      expect(res).toEqual(1);
+    });
+  });
+});

package/pkg/commands/del.ts

@@ -0,0 +1,11 @@
+import type { CommandOptions } from "./command";
+import { Command } from "./command";
+
+/**
+ * @see https://redis.io/commands/del
+ */
+export class DelCommand extends Command<number, number> {
+  constructor(cmd: [...keys: string[]], opts?: CommandOptions<number, number>) {
+    super(["del", ...cmd], opts);
+  }
+}

package/pkg/commands/echo.test.ts

@@ -0,0 +1,11 @@
+import { newHttpClient, randomID } from "../test-utils";
+
+import { expect, test } from "bun:test";
+import { EchoCommand } from "./echo";
+const client = newHttpClient();
+
+test("returns the message", async () => {
+  const message = randomID();
+  const res = await new EchoCommand([message]).exec(client);
+  expect(res).toEqual(message);
+});

package/pkg/commands/echo.ts

@@ -0,0 +1,11 @@
+import type { CommandOptions } from "./command";
+import { Command } from "./command";
+
+/**
+ * @see https://redis.io/commands/echo
+ */
+export class EchoCommand extends Command<string, string> {
+  constructor(cmd: [message: string], opts?: CommandOptions<string, string>) {
+    super(["echo", ...cmd], opts);
+  }
+}

package/pkg/commands/eval.test.ts

@@ -0,0 +1,30 @@
+import { EvalCommand } from "./eval";
+
+import { keygen, newHttpClient, randomID } from "../test-utils";
+
+import { afterAll, describe, expect, test } from "bun:test";
+import { SetCommand } from "./set";
+const client = newHttpClient();
+
+const { newKey, cleanup } = keygen();
+afterAll(cleanup);
+
+describe("without keys", () => {
+  test("returns something", async () => {
+    const value = randomID();
+    const res = await new EvalCommand(["return ARGV[1]", [], [value]]).exec(client);
+    expect(res).toEqual(value);
+  });
+});
+
+describe("with keys", () => {
+  test("returns something", async () => {
+    const value = randomID();
+    const key = newKey();
+    await new SetCommand([key, value]).exec(client);
+    const res = await new EvalCommand([`return redis.call("GET", KEYS[1])`, [key], []]).exec(
+      client
+    );
+    expect(res).toEqual(value);
+  });
+});

package/pkg/commands/eval.ts

@@ -0,0 +1,14 @@
+import type { CommandOptions } from "./command";
+import { Command } from "./command";
+
+/**
+ * @see https://redis.io/commands/eval
+ */
+export class EvalCommand<TArgs extends unknown[], TData> extends Command<unknown, TData> {
+  constructor(
+    [script, keys, args]: [script: string, keys: string[], args: TArgs],
+    opts?: CommandOptions<unknown, TData>
+  ) {
+    super(["eval", script, keys.length, ...keys, ...(args ?? [])], opts);
+  }
+}

package/pkg/commands/evalsha.test.ts

@@ -0,0 +1,19 @@
+import { keygen, newHttpClient, randomID } from "../test-utils";
+
+import { afterAll, describe, expect, test } from "bun:test";
+import { EvalshaCommand } from "./evalsha";
+import { ScriptLoadCommand } from "./script_load";
+
+const client = newHttpClient();
+
+const { cleanup } = keygen();
+afterAll(cleanup);
+
+describe("without keys", () => {
+  test("returns something", async () => {
+    const value = randomID();
+    const sha1 = await new ScriptLoadCommand([`return {ARGV[1], "${value}"}`]).exec(client);
+    const res = await new EvalshaCommand([sha1, [], [value]]).exec(client);
+    expect(res).toEqual([value, value]);
+  });
+});

package/pkg/commands/evalsha.ts

@@ -0,0 +1,14 @@
+import type { CommandOptions } from "./command";
+import { Command } from "./command";
+
+/**
+ * @see https://redis.io/commands/evalsha
+ */
+export class EvalshaCommand<TArgs extends unknown[], TData> extends Command<unknown, TData> {
+  constructor(
+    [sha, keys, args]: [sha: string, keys: string[], args?: TArgs],
+    opts?: CommandOptions<unknown, TData>
+  ) {
+    super(["evalsha", sha, keys.length, ...keys, ...(args ?? [])], opts);
+  }
+}

package/pkg/commands/exists.test.ts

@@ -0,0 +1,38 @@
+import { keygen, newHttpClient } from "../test-utils";
+import { ExistsCommand } from "./exists";
+
+import { afterAll, describe, expect, test } from "bun:test";
+import { SetCommand } from "./set";
+
+const client = newHttpClient();
+
+const { newKey, cleanup } = keygen();
+afterAll(cleanup);
+
+describe("when the key does not eist", () => {
+  test("it returns 0", async () => {
+    const key = newKey();
+
+    const res = await new ExistsCommand([key]).exec(client);
+    expect(res).toEqual(0);
+  });
+});
+describe("when the key exists", () => {
+  test("it returns 1", async () => {
+    const key = newKey();
+    await new SetCommand([key, "value"]).exec(client);
+    const res = await new ExistsCommand([key]).exec(client);
+    expect(res).toEqual(1);
+  });
+});
+describe("with multiple keys", () => {
+  test("it returns the number of found keys", async () => {
+    const key1 = newKey();
+    const key2 = newKey();
+    const key3 = newKey();
+    await new SetCommand([key1, "value"]).exec(client);
+    await new SetCommand([key2, "value"]).exec(client);
+    const res = await new ExistsCommand([key1, key2, key3]).exec(client);
+    expect(res).toEqual(2);
+  });
+});

package/pkg/commands/exists.ts

@@ -0,0 +1,11 @@
+import type { CommandOptions } from "./command";
+import { Command } from "./command";
+
+/**
+ * @see https://redis.io/commands/exists
+ */
+export class ExistsCommand extends Command<number, number> {
+  constructor(cmd: [...keys: string[]], opts?: CommandOptions<number, number>) {
+    super(["exists", ...cmd], opts);
+  }
+}