@upstash/redis 0.0.0-ci.babdc47f97e036e2863dfed16300cda2b97bf6ad-20240322001434 → 0.0.0-ci.bb93ac2803c2e927dc8bf1a1b3c5aa2a14034eb6-20240930061920

package/pkg/commands/lmpop.test.ts

@@ -0,0 +1,86 @@
+import { keygen, newHttpClient, randomID } from "../test-utils";
+
+import { afterAll, describe, expect, test } from "bun:test";
+
+import { LmPopCommand } from "./lmpop";
+import { LPushCommand } from "./lpush";
+const client = newHttpClient();
+
+const { newKey, cleanup } = keygen();
+afterAll(cleanup);
+
+describe("LMPOP", () => {
+  test("should pop elements from the left-most end of the list", async () => {
+    const key = newKey();
+    const lpushElement1 = { name: randomID(), surname: randomID() };
+    const lpushElement2 = { name: randomID(), surname: randomID() };
+
+    await new LPushCommand([key, lpushElement1, lpushElement2]).exec(client);
+
+    const result = await new LmPopCommand<{ name: string; surname: string }>([
+      1,
+      [key],
+      "LEFT",
+      2,
+    ]).exec(client);
+
+    expect(result?.[1][0].name).toEqual(lpushElement2.name);
+  });
+
+  test("should pop elements from the right-most end of the list", async () => {
+    const key = newKey();
+    const lpushElement1 = randomID();
+    const lpushElement2 = randomID();
+
+    await new LPushCommand([key, lpushElement1, lpushElement2]).exec(client);
+
+    const result = await new LmPopCommand<string>([1, [key], "RIGHT", 2]).exec(client);
+
+    expect(result?.[1][0]).toEqual(lpushElement1);
+  });
+
+  test("should pop elements from the first list then second list", async () => {
+    const key = newKey();
+    const lpushElement1 = randomID();
+    const lpushElement2 = randomID();
+
+    const key2 = newKey();
+    const lpushElement2_1 = randomID();
+    const lpushElement2_2 = randomID();
+
+    await new LPushCommand([key, lpushElement1, lpushElement2]).exec(client);
+    await new LPushCommand([key2, lpushElement2_1, lpushElement2_2]).exec(client);
+
+    const result = await new LmPopCommand<string>([2, [key, key2], "RIGHT", 4]).exec(client);
+    expect(result).toEqual([key, [lpushElement1, lpushElement2]]);
+
+    const result1 = await new LmPopCommand<string>([2, [key, key2], "RIGHT", 4]).exec(client);
+    expect(result1).toEqual([key2, [lpushElement2_1, lpushElement2_2]]);
+  });
+
+  test("should return null after first attempt", async () => {
+    const key = newKey();
+    const lpushElement1 = randomID();
+    const lpushElement2 = randomID();
+
+    await new LPushCommand([key, lpushElement1, lpushElement2]).exec(client);
+
+    await new LmPopCommand([1, [key], "LEFT", 2]).exec(client);
+
+    const result1 = await new LmPopCommand([1, [key], "LEFT", 2]).exec(client);
+
+    expect(result1).toBeNull();
+  });
+
+  test("should return without count", async () => {
+    const key = newKey();
+    const lpushElement1 = randomID();
+    const lpushElement2 = randomID();
+
+    await new LPushCommand([key, lpushElement1, lpushElement2]).exec(client);
+
+    const result1 = await new LmPopCommand([1, [key], "LEFT"]).exec(client);
+
+    expect(result1).toEqual([key, [lpushElement2]]);
+  });
+});

package/pkg/commands/lmpop.ts

@@ -0,0 +1,19 @@
+import type { CommandOptions } from "./command";
+import { Command } from "./command";
+
+/**
+ * @see https://redis.io/commands/lmpop
+ */
+export class LmPopCommand<TValues> extends Command<
+  [string, TValues[]] | null,
+  [string, TValues[]] | null
+> {
+  constructor(
+    cmd: [numkeys: number, keys: string[], "LEFT" | "RIGHT", count?: number],
+    opts?: CommandOptions<[string, TValues[]] | null, [string, TValues[]] | null>
+  ) {
+    const [numkeys, keys, direction, count] = cmd;
+
+    super(["LMPOP", numkeys, ...keys, direction, ...(count ? ["COUNT", count] : [])], opts);
+  }
+}

package/pkg/commands/lpop.test.ts

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

package/pkg/commands/lpop.ts

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

package/pkg/commands/lpos.test.ts

@@ -0,0 +1,56 @@
+import { keygen, newHttpClient, randomID } from "../test-utils";
+
+import { afterAll, expect, test } from "bun:test";
+import { LPosCommand } from "./lpos";
+
+import { RPushCommand } from "./rpush";
+const client = newHttpClient();
+
+const { newKey, cleanup } = keygen();
+afterAll(cleanup);
+
+test("with single element", () => {
+  test("returns 1", async () => {
+    const key = newKey();
+    const value1 = randomID();
+    const value2 = randomID();
+    await new RPushCommand([key, value1, value2]).exec(client);
+    const res = await new LPosCommand([key, value2]).exec(client);
+    expect(res).toEqual(1);
+  });
+});
+
+test("with rank", () => {
+  test("returns 6", async () => {
+    const key = newKey();
+    await new RPushCommand([key, "a", "b", "c", 1, 2, 3, "c", "c"]).exec(client);
+    const cmd = new LPosCommand([key, "c", { rank: 2 }]);
+    expect(cmd.command).toEqual(["lpos", key, "c", "rank", 2]);
+    const res = await cmd.exec(client);
+    expect(res).toEqual(6);
+  });
+});
+test("with count", () => {
+  test("returns 2,6", async () => {
+    const key = newKey();
+    await new RPushCommand([key, "a", "b", "c", 1, 2, 3, "c", "c"]).exec(client);
+    const res = await new LPosCommand<number[]>([key, "c", { count: 2 }]).exec(client);
+    expect(res).toEqual([2, 6]);
+  });
+});
+
+test("with maxlen", () => {
+  test("returns 2", async () => {
+    const key = newKey();
+    await new RPushCommand([key, "a", "b", "c", 1, 2, 3, "c", "c"]).exec(client);
+    const res = await new LPosCommand<number[]>([
+      key,
+      "c",
+      {
+        count: 2,
+        maxLen: 4,
+      },
+    ]).exec(client);
+    expect(res).toEqual([2]);
+  });
+});

package/pkg/commands/lpos.ts

@@ -0,0 +1,25 @@
+import type { CommandOptions } from "./command";
+import { Command } from "./command";
+
+/**
+ * @see https://redis.io/commands/lpos
+ */
+export class LPosCommand<TData = number> extends Command<TData, TData> {
+  constructor(
+    cmd: [key: string, element: unknown, opts?: { rank?: number; count?: number; maxLen?: number }],
+    opts?: CommandOptions<TData, TData>
+  ) {
+    const args = ["lpos", cmd[0], cmd[1]];
+
+    if (typeof cmd[2]?.rank === "number") {
+      args.push("rank", cmd[2].rank);
+    }
+    if (typeof cmd[2]?.count === "number") {
+      args.push("count", cmd[2].count);
+    }
+    if (typeof cmd[2]?.maxLen === "number") {
+      args.push("maxLen", cmd[2].maxLen);
+    }
+    super(args, opts);
+  }
+}

package/pkg/commands/lpush.test.ts

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

package/pkg/commands/lpush.ts

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

package/pkg/commands/lpushx.test.ts

@@ -0,0 +1,30 @@
+import { keygen, newHttpClient, randomID } from "../test-utils";
+
+import { afterAll, expect, test } from "bun:test";
+import { LPushXCommand } from "./lpushx";
+
+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 LPushXCommand([key, randomID()]).exec(client);
+    expect(res).toEqual(2);
+    const res2 = await new LPushXCommand([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 LPushXCommand([key, randomID()]).exec(client);
+    expect(res).toEqual(0);
+  });
+});

package/pkg/commands/lpushx.ts

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

package/pkg/commands/lrange.test.ts

@@ -0,0 +1,21 @@
+import { keygen, newHttpClient, randomID } from "../test-utils";
+
+import { afterAll, expect, test } from "bun:test";
+import { LRangeCommand } from "./lrange";
+import { RPushCommand } from "./rpush";
+const client = newHttpClient();
+
+const { newKey, cleanup } = keygen();
+afterAll(cleanup);
+
+test("returns the correct range", async () => {
+  const key = newKey();
+  const value1 = randomID();
+  const value2 = randomID();
+  const value3 = randomID();
+  await new RPushCommand([key, value1, value2, value3]).exec(client);
+  const res = await new LRangeCommand([key, 1, 2]).exec(client);
+  expect(res.length).toBe(2);
+  expect(res[0]).toBe(value2);
+  expect(res[1]).toBe(value3);
+});

package/pkg/commands/lrange.ts

@@ -0,0 +1,11 @@
+import type { CommandOptions } from "./command";
+import { Command } from "./command";
+
+export class LRangeCommand<TData = string> extends Command<unknown[], TData[]> {
+  constructor(
+    cmd: [key: string, start: number, end: number],
+    opts?: CommandOptions<unknown[], TData[]>
+  ) {
+    super(["lrange", ...cmd], opts);
+  }
+}

package/pkg/commands/lrem.test.ts

@@ -0,0 +1,19 @@
+import { afterAll, expect, test } from "bun:test";
+import { keygen, newHttpClient } from "../test-utils";
+
+import { LPushCommand } from "./lpush";
+import { LRemCommand } from "./lrem";
+const client = newHttpClient();
+
+const { newKey, cleanup } = keygen();
+afterAll(cleanup);
+
+test("returns the number of deleted elements", async () => {
+  const key = newKey();
+  await new LPushCommand([key, "element"]).exec(client);
+  await new LPushCommand([key, "element"]).exec(client);
+  await new LPushCommand([key, "something else"]).exec(client);
+
+  const res = await new LRemCommand([key, 2, "element"]).exec(client);
+  expect(res).toEqual(2);
+});

package/pkg/commands/lrem.ts

@@ -0,0 +1,10 @@
+import type { CommandOptions } from "./command";
+import { Command } from "./command";
+export class LRemCommand<TData> extends Command<number, number> {
+  constructor(
+    cmd: [key: string, count: number, value: TData],
+    opts?: CommandOptions<number, number>
+  ) {
+    super(["lrem", ...cmd], opts);
+  }
+}

package/pkg/commands/lset.test.ts

@@ -0,0 +1,43 @@
+import { keygen, newHttpClient, randomID } from "../test-utils";
+
+import { afterAll, describe, expect, test } from "bun:test";
+import { LPopCommand } from "./lpop";
+import { LPushCommand } from "./lpush";
+import { LSetCommand } from "./lset";
+
+const client = newHttpClient();
+
+const { newKey, cleanup } = keygen();
+afterAll(cleanup);
+
+describe("when list exists", () => {
+  describe("when the index is in range", () => {
+    test("replaces the element at index", async () => {
+      const key = newKey();
+
+      const value = randomID();
+      const newValue = randomID();
+      await new LPushCommand([key, value]).exec(client);
+      const res = await new LSetCommand([key, 0, newValue]).exec(client);
+      expect(res).toEqual("OK");
+
+      const res2 = await new LPopCommand([key]).exec(client);
+
+      expect(res2).toEqual(newValue);
+    });
+    describe("when the index is out of bounds", () => {
+      test("returns null", async () => {
+        const key = newKey();
+
+        const value = randomID();
+        const newValue = randomID();
+        await new LPushCommand([key, value]).exec(client);
+        let hasThrown = false;
+        await new LSetCommand([key, 1, newValue]).exec(client).catch(() => {
+          hasThrown = true;
+        });
+        expect(hasThrown).toBeTrue();
+      });
+    });
+  });
+});

package/pkg/commands/lset.ts

@@ -0,0 +1,8 @@
+import type { CommandOptions } from "./command";
+import { Command } from "./command";
+
+export class LSetCommand<TData = string> extends Command<"OK", "OK"> {
+  constructor(cmd: [key: string, index: number, data: TData], opts?: CommandOptions<"OK", "OK">) {
+    super(["lset", ...cmd], opts);
+  }
+}

package/pkg/commands/ltrim.test.ts

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

package/pkg/commands/ltrim.ts

@@ -0,0 +1,8 @@
+import type { CommandOptions } from "./command";
+import { Command } from "./command";
+
+export class LTrimCommand extends Command<"OK", "OK"> {
+  constructor(cmd: [key: string, start: number, end: number], opts?: CommandOptions<"OK", "OK">) {
+    super(["ltrim", ...cmd], opts);
+  }
+}

package/pkg/commands/mget.test.ts

@@ -0,0 +1,44 @@
+import { keygen, newHttpClient, randomID } from "../test-utils";
+
+import { afterAll, expect, test } from "bun:test";
+import { MGetCommand } from "./mget";
+import { MSetCommand } from "./mset";
+
+import { SetCommand } from "./set";
+const client = newHttpClient();
+
+const { newKey, cleanup } = keygen();
+afterAll(cleanup);
+
+test("gets exiting values", async () => {
+  const key1 = newKey();
+  const value1 = randomID();
+  const key2 = newKey();
+  const value2 = randomID();
+
+  const kv: Record<string, string> = {};
+  kv[key1] = value1;
+  kv[key2] = value2;
+  const res = await new MSetCommand([kv]).exec(client);
+
+  expect(res).toEqual("OK");
+  const res2 = await new MGetCommand<[string, string]>([key1, key2]).exec(client);
+
+  expect(res2).toEqual([value1, value2]);
+});
+
+test("gets a non-existing value", async () => {
+  const key = newKey();
+  const res = await new MGetCommand<[null]>([key]).exec(client);
+
+  expect(res).toEqual([null]);
+});
+
+test("gets an object", async () => {
+  const key = newKey();
+  const value = { v: randomID() };
+  await new SetCommand([key, value]).exec(client);
+  const res = await new MGetCommand<[{ v: string }]>([key]).exec(client);
+
+  expect(res).toEqual([value]);
+});

package/pkg/commands/mget.ts

@@ -0,0 +1,11 @@
+import type { CommandOptions } from "./command";
+import { Command } from "./command";
+/**
+ * @see https://redis.io/commands/mget
+ */
+export class MGetCommand<TData extends unknown[]> extends Command<(string | null)[], TData> {
+  constructor(cmd: [string[]] | [...string[]], opts?: CommandOptions<(string | null)[], TData>) {
+    const keys = Array.isArray(cmd[0]) ? cmd[0] : (cmd as string[]);
+    super(["mget", ...keys], opts);
+  }
+}