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

package/pkg/commands/psetex.test.ts

@@ -0,0 +1,23 @@
+import { keygen, newHttpClient, randomID } from "../test-utils";
+
+import { afterAll, expect, test } from "bun:test";
+
+import { GetCommand } from "./get";
+import { PSetEXCommand } from "./psetex";
+const client = newHttpClient();
+
+const { newKey, cleanup } = keygen();
+afterAll(cleanup);
+
+test("sets value", async () => {
+  const key = newKey();
+  const value = randomID();
+
+  const res = await new PSetEXCommand([key, 1000, value]).exec(client);
+
+  expect(res).toEqual("OK");
+  await new Promise((res) => setTimeout(res, 2000));
+  const res2 = await new GetCommand([key]).exec(client);
+
+  expect(res2).toEqual(null);
+});

package/pkg/commands/psetex.ts

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

package/pkg/commands/pttl.test.ts

@@ -0,0 +1,18 @@
+import { keygen, newHttpClient } from "../test-utils";
+import { PTtlCommand } from "./pttl";
+
+import { afterAll, expect, test } from "bun:test";
+import { SetExCommand } from "./setex";
+
+const client = newHttpClient();
+
+const { newKey, cleanup } = keygen();
+afterAll(cleanup);
+
+test("returns the ttl on a key", async () => {
+  const key = newKey();
+  const ttl = 60;
+  await new SetExCommand([key, ttl, "value"]).exec(client);
+  const res = await new PTtlCommand([key]).exec(client);
+  expect(res <= ttl * 1000).toBe(true);
+});

package/pkg/commands/pttl.ts

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

package/pkg/commands/publish.test.ts

@@ -0,0 +1,12 @@
+import { expect, test } from "bun:test";
+import { newHttpClient } from "../test-utils";
+
+import { PublishCommand } from "./publish";
+
+const client = newHttpClient();
+
+test("returns the number of clients that received the message", async () => {
+  const res = await new PublishCommand(["channel", "hello"]).exec(client);
+
+  expect(typeof res).toBe("number");
+});

package/pkg/commands/publish.ts

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

package/pkg/commands/randomkey.test.ts

@@ -0,0 +1,16 @@
+import { keygen, newHttpClient, randomID } from "../test-utils";
+
+import { afterAll, expect, test } from "bun:test";
+import { RandomKeyCommand } from "./randomkey";
+import { SetCommand } from "./set";
+const client = newHttpClient();
+
+const { newKey, cleanup } = keygen();
+afterAll(cleanup);
+
+test("returns a random key", async () => {
+  const key = newKey();
+  await new SetCommand([key, randomID()]).exec(client);
+  const res = await new RandomKeyCommand().exec(client);
+  expect(typeof res).toBe("string");
+});

package/pkg/commands/randomkey.ts

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

package/pkg/commands/rename.test.ts

@@ -0,0 +1,19 @@
+import { keygen, newHttpClient, randomID } from "../test-utils";
+
+import { afterAll, expect, test } from "bun:test";
+
+import { RenameCommand } from "./rename";
+import { SetCommand } from "./set";
+const client = newHttpClient();
+
+const { newKey, cleanup } = keygen();
+afterAll(cleanup);
+
+test("renames the key", async () => {
+  const source = newKey();
+  const destination = newKey();
+  const value = randomID();
+  await new SetCommand([source, value]).exec(client);
+  const res = await new RenameCommand([source, destination]).exec(client);
+  expect(res).toEqual("OK");
+});

package/pkg/commands/rename.ts

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

package/pkg/commands/renamenx.test.ts

@@ -0,0 +1,33 @@
+import { keygen, newHttpClient, randomID } from "../test-utils";
+
+import { afterAll, expect, test } from "bun:test";
+import { RenameNXCommand } from "./renamenx";
+import { SetCommand } from "./set";
+
+const client = newHttpClient();
+
+const { newKey, cleanup } = keygen();
+afterAll(cleanup);
+
+test("when the key exists", () => {
+  test("does nothing", async () => {
+    const source = newKey();
+    const destination = newKey();
+    const sourceValue = randomID();
+    const destinationValue = randomID();
+    await new SetCommand([source, sourceValue]).exec(client);
+    await new SetCommand([destination, destinationValue]).exec(client);
+    const res = await new RenameNXCommand([source, destination]).exec(client);
+    expect(res).toEqual(0);
+  });
+});
+test("when the key does not exist", () => {
+  test("renames the key", async () => {
+    const source = newKey();
+    const destination = newKey();
+    const value = randomID();
+    await new SetCommand([source, value]).exec(client);
+    const res = await new RenameNXCommand([source, destination]).exec(client);
+    expect(res).toEqual(1);
+  });
+});

package/pkg/commands/renamenx.ts

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

package/pkg/commands/rpop.test.ts

@@ -0,0 +1,40 @@
+import { keygen, newHttpClient, randomID } from "../test-utils";
+
+import { afterAll, describe, expect, test } from "bun:test";
+import { RPopCommand } from "./rpop";
+
+import { LPushCommand } from "./lpush";
+const client = newHttpClient();
+
+const { newKey, cleanup } = keygen();
+afterAll(cleanup);
+
+describe("when list exists", () => {
+  test("returns the last element", async () => {
+    const key = newKey();
+    const value = randomID();
+    await new LPushCommand([key, value]).exec(client);
+    const res = await new RPopCommand([key]).exec(client);
+    expect(res).toEqual(value);
+  });
+});
+
+describe("when list does not exist", () => {
+  test("returns null", async () => {
+    const key = newKey();
+    const res = await new RPopCommand([key]).exec(client);
+    expect(res).toEqual(null);
+  });
+});
+
+test("with count", () => {
+  test("returns 2 elements", async () => {
+    const key = newKey();
+    const value1 = randomID();
+    const value2 = randomID();
+    await new LPushCommand([key, value1, value2]).exec(client);
+    const res = await new RPopCommand<string[]>([key, 2]).exec(client);
+    expect(res).toBeTruthy();
+    expect(res).toContain([value1, value2]);
+  });
+});

package/pkg/commands/rpop.ts

@@ -0,0 +1,17 @@
+import type { CommandOptions } from "./command";
+import { Command } from "./command";
+
+/**
+ * @see https://redis.io/commands/rpop
+ */
+export class RPopCommand<TData extends unknown | unknown[] = string> extends Command<
+  unknown | null,
+  TData | null
+> {
+  constructor(
+    cmd: [key: string, count?: number],
+    opts?: CommandOptions<unknown | null, TData | null>
+  ) {
+    super(["rpop", ...cmd], opts);
+  }
+}

package/pkg/commands/rpush.test.ts

@@ -0,0 +1,17 @@
+import { keygen, newHttpClient, randomID } from "../test-utils";
+
+import { afterAll, expect, test } from "bun:test";
+import { RPushCommand } from "./rpush";
+const client = newHttpClient();
+
+const { newKey, cleanup } = keygen();
+afterAll(cleanup);
+
+test("returns the length after command", async () => {
+  const key = newKey();
+  const res = await new RPushCommand([key, randomID()]).exec(client);
+  expect(res).toEqual(1);
+  const res2 = await new RPushCommand([key, randomID(), randomID()]).exec(client);
+
+  expect(res2).toEqual(3);
+});

package/pkg/commands/rpush.ts

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

package/pkg/commands/rpushx.test.ts

@@ -0,0 +1,30 @@
+import { keygen, newHttpClient, randomID } from "../test-utils";
+
+import { afterAll, expect, test } from "bun:test";
+import { RPushXCommand } from "./rpushx";
+
+import { LPushCommand } from "./lpush";
+const client = newHttpClient();
+
+const { newKey, cleanup } = keygen();
+afterAll(cleanup);
+
+test("when list exists", () => {
+  test("returns the length after command", async () => {
+    const key = newKey();
+    await new LPushCommand([key, randomID()]).exec(client);
+    const res = await new RPushXCommand([key, randomID()]).exec(client);
+    expect(res).toEqual(2);
+    const res2 = await new RPushXCommand([key, randomID(), randomID()]).exec(client);
+
+    expect(res2).toEqual(4);
+  });
+});
+
+test("when list does not exist", () => {
+  test("does nothing", async () => {
+    const key = newKey();
+    const res = await new RPushXCommand([key, randomID()]).exec(client);
+    expect(res).toEqual(0);
+  });
+});

package/pkg/commands/rpushx.ts

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

package/pkg/commands/sadd.test.ts

@@ -0,0 +1,22 @@
+import { keygen, newHttpClient, randomID } from "../test-utils";
+
+import { afterAll, expect, test } from "bun:test";
+import { SAddCommand } from "./sadd";
+const client = newHttpClient();
+
+const { newKey, cleanup } = keygen();
+afterAll(cleanup);
+
+test("returns the number of added members", async () => {
+  const key = newKey();
+  const value1 = randomID();
+  const value2 = randomID();
+  const res = await new SAddCommand([key, value1, value2]).exec(client);
+  expect(res).toEqual(2);
+});
+
+test("throws when there are no members", async () => {
+  const key = newKey();
+  // @ts-expect-error It should give type error when no members are given
+  expect(async () => await new SAddCommand([key]).exec(client)).toThrow();
+});

package/pkg/commands/sadd.ts

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

package/pkg/commands/scan.test.ts

@@ -0,0 +1,91 @@
+import { keygen, newHttpClient, randomID } from "../test-utils";
+
+import { afterAll, expect, test } from "bun:test";
+import { FlushDBCommand } from "./flushdb";
+import { ScanCommand } from "./scan";
+import { SetCommand } from "./set";
+import { TypeCommand } from "./type";
+import { ZAddCommand } from "./zadd";
+const client = newHttpClient();
+
+const { newKey, cleanup } = keygen();
+afterAll(cleanup);
+test("without options", () => {
+  test("returns cursor and keys", async () => {
+    const key = newKey();
+    const value = randomID();
+    await new SetCommand([key, value]).exec(client);
+    let cursor = "0";
+    const found: string[] = [];
+    do {
+      const res = await new ScanCommand([cursor]).exec(client);
+      cursor = res[0];
+      found.push(...res[1]);
+    } while (cursor !== "0");
+    expect(found.includes(key)).toBeTrue();
+  });
+});
+
+test("with match", () => {
+  test("returns cursor and keys", async () => {
+    const key = newKey();
+    const value = randomID();
+    await new SetCommand([key, value]).exec(client);
+
+    let cursor = "0";
+    const found: string[] = [];
+    do {
+      const res = await new ScanCommand([cursor, { match: key }]).exec(client);
+      expect(typeof res[0]).toEqual("number");
+      cursor = res[0];
+      found.push(...res[1]);
+    } while (cursor !== "0");
+
+    expect(found).toEqual([key]);
+  });
+});
+
+test("with count", () => {
+  test("returns cursor and keys", async () => {
+    const key = newKey();
+    const value = randomID();
+    await new SetCommand([key, value]).exec(client);
+
+    let cursor = "0";
+    const found: string[] = [];
+    do {
+      const res = await new ScanCommand([cursor, { count: 1 }]).exec(client);
+      cursor = res[0];
+      found.push(...res[1]);
+    } while (cursor !== "0");
+
+    expect(found.includes(key)).toEqual(true);
+  });
+});
+
+test("with type", () => {
+  test("returns cursor and keys", async () => {
+    await new FlushDBCommand([]).exec(client);
+    const key1 = newKey();
+    const key2 = newKey();
+    const value = randomID();
+    await new SetCommand([key1, value]).exec(client);
+
+    // Add a non-string type
+    await new ZAddCommand([key2, { score: 1, member: "abc" }]).exec(client);
+
+    let cursor = "0";
+    const found: string[] = [];
+    do {
+      const res = await new ScanCommand([cursor, { type: "string" }]).exec(client);
+      cursor = res[0];
+      found.push(...res[1]);
+    } while (cursor !== "0");
+
+    expect(found.length).toEqual(1);
+    for (const key of found) {
+      const type = await new TypeCommand([key]).exec(client);
+      expect(type).toEqual("string");
+    }
+  });
+});

package/pkg/commands/scan.ts

@@ -0,0 +1,33 @@
+import { deserializeScanResponse } from "../util";
+import type { CommandOptions } from "./command";
+import { Command } from "./command";
+
+export type ScanCommandOptions = {
+  match?: string;
+  count?: number;
+  type?: string;
+};
+/**
+ * @see https://redis.io/commands/scan
+ */
+export class ScanCommand extends Command<[string, string[]], [string, string[]]> {
+  constructor(
+    [cursor, opts]: [cursor: string | number, opts?: ScanCommandOptions],
+    cmdOpts?: CommandOptions<[string, string[]], [string, string[]]>
+  ) {
+    const command: (number | string)[] = ["scan", cursor];
+    if (opts?.match) {
+      command.push("match", opts.match);
+    }
+    if (typeof opts?.count === "number") {
+      command.push("count", opts.count);
+    }
+    if (opts?.type && opts.type.length > 0) {
+      command.push("type", opts.type);
+    }
+    super(command, {
+      deserialize: deserializeScanResponse,
+      ...cmdOpts,
+    });
+  }
+}

package/pkg/commands/scard.test.ts

@@ -0,0 +1,16 @@
+import { afterAll, expect, test } from "bun:test";
+import { keygen, newHttpClient } from "../test-utils";
+import { SAddCommand } from "./sadd";
+
+import { SCardCommand } from "./scard";
+const client = newHttpClient();
+
+const { newKey, cleanup } = keygen();
+afterAll(cleanup);
+
+test("returns the cardinality", async () => {
+  const key = newKey();
+  await new SAddCommand([key, "member1"]).exec(client);
+  const res = await new SCardCommand([key]).exec(client);
+  expect(res).toEqual(1);
+});

package/pkg/commands/scard.ts

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

package/pkg/commands/script_exists.test.ts

@@ -0,0 +1,34 @@
+import { describe, expect, test } from "bun:test";
+import { newHttpClient, randomID } from "../test-utils";
+import { ScriptExistsCommand } from "./script_exists";
+import { ScriptLoadCommand } from "./script_load";
+
+const client = newHttpClient();
+
+describe("with a single script", () => {
+  describe("when the script exists", () => {
+    test("returns 1", async () => {
+      const script = `return "${randomID()}"`;
+      const hash = await new ScriptLoadCommand([script]).exec(client);
+      const res = await new ScriptExistsCommand([hash]).exec(client);
+      expect(res).toEqual([1]);
+    });
+  });
+  describe("when the script does not exist", () => {
+    test("returns 0", async () => {
+      const res = await new ScriptExistsCommand(["21"]).exec(client);
+      expect(res).toEqual([0]);
+    });
+  });
+});
+
+describe("with multiple scripts", () => {
+  test("returns the found scripts", async () => {
+    const script1 = `return "${randomID()}"`;
+    const script2 = `return "${randomID()}"`;
+    const hash1 = await new ScriptLoadCommand([script1]).exec(client);
+    const hash2 = await new ScriptLoadCommand([script2]).exec(client);
+    const res = await new ScriptExistsCommand([hash1, hash2]).exec(client);
+    expect(res).toEqual([1, 1]);
+  });
+});

package/pkg/commands/script_exists.ts

@@ -0,0 +1,14 @@
+import type { CommandOptions } from "./command";
+import { Command } from "./command";
+
+/**
+ * @see https://redis.io/commands/script-exists
+ */
+export class ScriptExistsCommand<T extends string[]> extends Command<string[], number[]> {
+  constructor(hashes: T, opts?: CommandOptions<string[], number[]>) {
+    super(["script", "exists", ...hashes], {
+      deserialize: (result) => result as unknown as number[],
+      ...opts,
+    });
+  }
+}

package/pkg/commands/script_flush.ts

@@ -0,0 +1,21 @@
+import type { CommandOptions } from "./command";
+import { Command } from "./command";
+
+export type ScriptFlushCommandOptions =
+  | { sync: true; async?: never }
+  | { sync?: never; async: true };
+
+/**
+ * @see https://redis.io/commands/script-flush
+ */
+export class ScriptFlushCommand extends Command<"OK", "OK"> {
+  constructor([opts]: [opts?: ScriptFlushCommandOptions], cmdOpts?: CommandOptions<"OK", "OK">) {
+    const cmd = ["script", "flush"];
+    if (opts?.sync) {
+      cmd.push("sync");
+    } else if (opts?.async) {
+      cmd.push("async");
+    }
+    super(cmd, cmdOpts);
+  }
+}

package/pkg/commands/script_load.test.ts

@@ -0,0 +1,11 @@
+import { expect, test } from "bun:test";
+import { newHttpClient } from "../test-utils";
+import { ScriptLoadCommand } from "./script_load";
+
+const client = newHttpClient();
+
+test("returns the hash", async () => {
+  const script = "return ARGV[1]";
+  const res = await new ScriptLoadCommand([script]).exec(client);
+  expect(res).toEqual("098e0f0d1448c0a81dafe820f66d460eb09263da");
+});

package/pkg/commands/script_load.ts

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

package/pkg/commands/sdiff.test.ts

@@ -0,0 +1,20 @@
+import { keygen, newHttpClient, randomID } from "../test-utils";
+
+import { afterAll, expect, test } from "bun:test";
+import { SAddCommand } from "./sadd";
+import { SDiffCommand } from "./sdiff";
+const client = newHttpClient();
+
+const { newKey, cleanup } = keygen();
+afterAll(cleanup);
+
+test("returns the diff", async () => {
+  const key1 = newKey();
+  const member1 = randomID();
+  const key2 = newKey();
+  const member2 = randomID();
+  await new SAddCommand([key1, member1]).exec(client);
+  await new SAddCommand([key2, member2]).exec(client);
+  const res = await new SDiffCommand([key1, key2]).exec(client);
+  expect(res).toEqual([member1]);
+});

package/pkg/commands/sdiff.ts

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