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

package/pkg/commands/zadd.test.ts

@@ -0,0 +1,242 @@
+import { keygen, newHttpClient, randomID } from "../test-utils";
+
+import { afterAll, describe, expect, test } from "bun:test";
+import { ZAddCommand } from "./zadd";
+import { ZRangeCommand } from "./zrange";
+import { ZScoreCommand } from "./zscore";
+
+const client = newHttpClient();
+
+const { newKey, cleanup } = keygen();
+afterAll(cleanup);
+
+describe("command format", () => {
+  describe("without options", () => {
+    test("build the correct command", () => {
+      expect(new ZAddCommand(["key", { score: 0, member: "member" }]).command).toEqual([
+        "zadd",
+        "key",
+        0,
+        "member",
+      ]);
+    });
+  });
+
+  describe("with nx", () => {
+    test("build the correct command", () => {
+      expect(
+        new ZAddCommand(["key", { nx: true }, { score: 0, member: "member" }]).command
+      ).toEqual(["zadd", "key", "nx", 0, "member"]);
+    });
+  });
+
+  describe("with xx", () => {
+    test("build the correct command", () => {
+      expect(
+        new ZAddCommand(["key", { xx: true }, { score: 0, member: "member" }]).command
+      ).toEqual(["zadd", "key", "xx", 0, "member"]);
+    });
+  });
+
+  describe("with ch", () => {
+    test("build the correct command", () => {
+      expect(
+        new ZAddCommand(["key", { ch: true }, { score: 0, member: "member" }]).command
+      ).toEqual(["zadd", "key", "ch", 0, "member"]);
+    });
+  });
+
+  describe("with incr", () => {
+    test("build the correct command", () => {
+      expect(
+        new ZAddCommand(["key", { incr: true }, { score: 0, member: "member" }]).command
+      ).toEqual(["zadd", "key", "incr", 0, "member"]);
+    });
+  });
+
+  describe("with nx and ch", () => {
+    test("build the correct command", () => {
+      expect(
+        new ZAddCommand(["key", { nx: true, ch: true }, { score: 0, member: "member" }]).command
+      ).toEqual(["zadd", "key", "nx", "ch", 0, "member"]);
+    });
+  });
+
+  describe("with nx,ch and incr", () => {
+    test("build the correct command", () => {
+      expect(
+        new ZAddCommand(["key", { nx: true, ch: true, incr: true }, { score: 0, member: "member" }])
+          .command
+      ).toEqual(["zadd", "key", "nx", "ch", "incr", 0, "member"]);
+    });
+  });
+
+  describe("with nx and multiple members", () => {
+    test("build the correct command", () => {
+      expect(
+        new ZAddCommand([
+          "key",
+          { nx: true },
+          { score: 0, member: "member" },
+          { score: 1, member: "member1" },
+        ]).command
+      ).toEqual(["zadd", "key", "nx", 0, "member", 1, "member1"]);
+    });
+  });
+});
+
+describe("without options", () => {
+  test("adds the member", async () => {
+    const key = newKey();
+    const member = randomID();
+    const score = Math.floor(Math.random() * 10);
+    const res = await new ZAddCommand([key, { score, member }]).exec(client);
+    expect(res).toEqual(1);
+  });
+});
+
+describe("xx", () => {
+  describe("when the element exists", () => {
+    test("updates the element", async () => {
+      const key = newKey();
+      const member = randomID();
+      const score = Math.floor(Math.random() * 10);
+      await new ZAddCommand([key, { score, member }]).exec(client);
+      const newScore = score + 1;
+      const res = await new ZAddCommand([key, { xx: true }, { score: newScore, member }]).exec(
+        client
+      );
+      expect(res).toEqual(0);
+
+      const res2 = await new ZScoreCommand([key, member]).exec(client);
+      expect(res2).toEqual(newScore);
+    });
+  });
+  describe("when the element does not exist", () => {
+    test("does nothing", async () => {
+      const key = newKey();
+      const member = randomID();
+      const score = Math.floor(Math.random() * 10);
+      await new ZAddCommand([key, { score, member }]).exec(client);
+      const newScore = score + 1;
+      const res = await new ZAddCommand([key, { xx: true }, { score: newScore, member }]).exec(
+        client
+      );
+      expect(res).toEqual(0);
+    });
+  });
+});
+
+describe("nx", () => {
+  describe("when the element exists", () => {
+    test("does nothing", async () => {
+      const key = newKey();
+      const member = randomID();
+      const score = Math.floor(Math.random() * 10);
+      await new ZAddCommand([key, { score, member }]).exec(client);
+      const newScore = score + 1;
+      const res = await new ZAddCommand([key, { nx: true }, { score: newScore, member }]).exec(
+        client
+      );
+      expect(res).toEqual(0);
+
+      const res2 = await new ZScoreCommand([key, member]).exec(client);
+      expect(res2).toEqual(score);
+    });
+  });
+  describe("when the element does not exist", () => {
+    test("creates element", async () => {
+      const key = newKey();
+      const member = randomID();
+      const score = Math.floor(Math.random() * 10);
+      const res = await new ZAddCommand([key, { nx: true }, { score, member }]).exec(client);
+      expect(res).toEqual(1);
+    });
+  });
+});
+
+describe("ch", () => {
+  test("returns the number of changed elements", async () => {
+    const key = newKey();
+    const member = randomID();
+    const score = Math.floor(Math.random() * 10);
+    await new ZAddCommand([key, { score, member }]).exec(client);
+    const newScore = score + 1;
+    const res = await new ZAddCommand([key, { ch: true }, { score: newScore, member }]).exec(
+      client
+    );
+    expect(res).toEqual(1);
+  });
+});
+
+describe("incr", () => {
+  test("increments the score", async () => {
+    const key = newKey();
+    const member = randomID();
+    const score = Math.floor(Math.random() * 10);
+    await new ZAddCommand([key, { score, member }]).exec(client);
+    const res = await new ZAddCommand([key, { incr: true }, { score: 1, member }]).exec(client);
+    expect(typeof res).toBe("number");
+    expect(res).toEqual(score + 1);
+  });
+});
+
+describe("LT and GT", () => {
+  describe("GT", () => {
+    test("should replace successfully if greater than", async () => {
+      const key = newKey();
+
+      await new ZAddCommand([key, { score: 1, member: "one" }]).exec(client);
+      await new ZAddCommand([key, { score: 2, member: "two" }]).exec(client);
+      await new ZAddCommand([key, { score: 3, member: "three" }]).exec(client);
+
+      await new ZAddCommand([key, { gt: true }, { score: 4, member: "two" }]).exec(client);
+
+      const res2 = await new ZRangeCommand([key, 0, -1, { withScores: true }]).exec(client);
+
+      expect(res2).toEqual(["one", 1, "three", 3, "two", 4]);
+    });
+
+    test("should fail to replace if its not greater than", async () => {
+      const key = newKey();
+
+      await new ZAddCommand([key, { score: 1, member: "one" }]).exec(client);
+      await new ZAddCommand([key, { score: 2, member: "two" }]).exec(client);
+      await new ZAddCommand([key, { score: 3, member: "three" }]).exec(client);
+
+      await new ZAddCommand([key, { gt: true }, { score: 1, member: "two" }]).exec(client);
+
+      const res2 = await new ZRangeCommand([key, 0, -1, { withScores: true }]).exec(client);
+
+      expect(res2).toEqual(["one", 1, "two", 2, "three", 3]);
+    });
+  });
+
+  describe("LT", () => {
+    test("should replace successfully if less than", async () => {
+      const key = newKey();
+
+      await new ZAddCommand([key, { score: 1, member: "one" }]).exec(client);
+      await new ZAddCommand([key, { score: 2, member: "two" }]).exec(client);
+      await new ZAddCommand([key, { score: 3, member: "three" }]).exec(client);
+      await new ZAddCommand([key, { lt: true }, { score: 2, member: "three" }]).exec(client);
+
+      const res2 = await new ZRangeCommand([key, 0, -1, { withScores: true }]).exec(client);
+      expect(res2).toEqual(["one", 1, "three", 2, "two", 2]);
+    });
+
+    test("should fail to replace if its not less than", async () => {
+      const key = newKey();
+
+      await new ZAddCommand([key, { score: 1, member: "one" }]).exec(client);
+      await new ZAddCommand([key, { score: 2, member: "two" }]).exec(client);
+      await new ZAddCommand([key, { score: 3, member: "three" }]).exec(client);
+
+      await new ZAddCommand([key, { lt: true }, { score: 6, member: "two" }]).exec(client);
+
+      const res2 = await new ZRangeCommand([key, 0, -1, { withScores: true }]).exec(client);
+
+      expect(res2).toEqual(["one", 1, "two", 2, "three", 3]);
+    });
+  });
+});

package/pkg/commands/zadd.ts

@@ -0,0 +1,53 @@
+import type { CommandOptions } from "./command";
+import { Command } from "./command";
+
+type NXAndXXOptions =
+  | { nx: true; xx?: never }
+  | { nx?: never; xx: true }
+  | { nx?: never; xx?: never };
+
+type LTAndGTOptions =
+  | { lt: true; gt?: never }
+  | { lt?: never; gt: true }
+  | { lt?: never; gt?: never };
+
+export type ZAddCommandOptions = NXAndXXOptions & LTAndGTOptions & { ch?: true } & { incr?: true };
+
+type Arg2<TData> = ScoreMember<TData> | ZAddCommandOptions;
+export type ScoreMember<TData> = { score: number; member: TData };
+/**
+ * @see https://redis.io/commands/zadd
+ */
+export class ZAddCommand<TData = string> extends Command<number | null, number | null> {
+  constructor(
+    [key, arg1, ...arg2]: [string, Arg2<TData>, ...ScoreMember<TData>[]],
+    opts?: CommandOptions<number | null, number | null>
+  ) {
+    const command: unknown[] = ["zadd", key];
+    if ("nx" in arg1 && arg1.nx) {
+      command.push("nx");
+    } else if ("xx" in arg1 && arg1.xx) {
+      command.push("xx");
+    }
+    if ("ch" in arg1 && arg1.ch) {
+      command.push("ch");
+    }
+    if ("incr" in arg1 && arg1.incr) {
+      command.push("incr");
+    }
+
+    if ("lt" in arg1 && arg1.lt) {
+      command.push("lt");
+    } else if ("gt" in arg1 && arg1.gt) {
+      command.push("gt");
+    }
+
+    if ("score" in arg1 && "member" in arg1) {
+      command.push(arg1.score, arg1.member);
+    }
+
+    command.push(...arg2.flatMap(({ score, member }) => [score, member]));
+
+    super(command, opts);
+  }
+}

package/pkg/commands/zcard.test.ts

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

package/pkg/commands/zcard.ts

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

package/pkg/commands/zcount.test.ts

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

package/pkg/commands/zcount.ts

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

package/pkg/commands/zdiffstore.test.ts

@@ -0,0 +1,42 @@
+import { afterAll, expect, test } from "bun:test";
+import { keygen, newHttpClient } from "../test-utils";
+import { ZRangeCommand } from "./zrange";
+
+import { ZAddCommand } from "./zadd";
+import { ZDiffStoreCommand } from "./zdiffstore";
+
+const client = newHttpClient();
+
+const { newKey, cleanup } = keygen();
+afterAll(cleanup);
+
+test("stors the diff", async () => {
+  const key1 = newKey();
+  const key2 = newKey();
+  const out = newKey();
+
+  await new ZAddCommand([
+    key1,
+    { score: 1, member: "one" },
+    {
+      score: 2,
+      member: "two",
+    },
+    { score: 3, member: "three" },
+  ]).exec(client);
+  await new ZAddCommand([
+    key2,
+    { score: 1, member: "one" },
+    {
+      score: 2,
+      member: "two",
+    },
+  ]).exec(client);
+  const res = await new ZDiffStoreCommand([out, 2, key1, key2]).exec(client);
+
+  expect(res).toEqual(1);
+
+  const zset3 = await new ZRangeCommand([out, 0, -1, { withScores: true }]).exec(client);
+  expect(zset3[0]).toBe("three");
+  expect(zset3[1]).toBe(3);
+});

package/pkg/commands/zdiffstore.ts

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

package/pkg/commands/zincrby.test.ts

@@ -0,0 +1,19 @@
+import { afterAll, expect, test } from "bun:test";
+import { keygen, newHttpClient, randomID } from "../test-utils";
+import { ZIncrByCommand } from "./zincrby";
+
+import { ZAddCommand } from "./zadd";
+
+const client = newHttpClient();
+
+const { newKey, cleanup } = keygen();
+afterAll(cleanup);
+test("increments and existing value", async () => {
+  const key = newKey();
+  const score = 1;
+  const member = randomID();
+  await new ZAddCommand([key, { score, member }]).exec(client);
+  const res = await new ZIncrByCommand([key, 2, member]).exec(client);
+
+  expect(res).toEqual(3);
+});

package/pkg/commands/zincrby.ts

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