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

package/pkg/commands/zrange.test.ts

@@ -0,0 +1,188 @@
+import { keygen, newHttpClient, randomID } from "../test-utils";
+
+import { afterAll, describe, expect, test } from "bun:test";
+import { ZAddCommand } from "./zadd";
+import { ZRangeCommand } from "./zrange";
+const client = newHttpClient();
+
+const { newKey, cleanup } = keygen();
+afterAll(cleanup);
+
+describe("without options", () => {
+  test("returns the set", async () => {
+    const key = newKey();
+    const score1 = 2;
+    const member1 = randomID();
+
+    const score2 = 5;
+    const member2 = randomID();
+
+    await new ZAddCommand([
+      key,
+      { score: score1, member: member1 },
+      { score: score2, member: member2 },
+    ]).exec(client);
+
+    const res = await new ZRangeCommand([key, 1, 3]).exec(client);
+    expect(res.length).toBe(1);
+    expect(res[0]).toEqual(member2);
+  });
+});
+
+describe("withscores", () => {
+  test("returns the set", async () => {
+    const key = newKey();
+    const score1 = 2;
+    const member1 = randomID();
+
+    const score2 = 5;
+    const member2 = randomID();
+
+    await new ZAddCommand([
+      key,
+      { score: score1, member: member1 },
+      { score: score2, member: member2 },
+    ]).exec(client);
+
+    const res = await new ZRangeCommand([key, 1, 3, { withScores: true }]).exec(client);
+    expect(res.length).toBe(2);
+    expect(res[0]).toEqual(member2);
+    expect(res[1]).toEqual(score2);
+  });
+});
+
+describe("byscore", () => {
+  test("returns the set", async () => {
+    const key = newKey();
+    const score1 = 1;
+    const member1 = randomID();
+
+    const score2 = 2;
+    const member2 = randomID();
+
+    const score3 = 3;
+    const member3 = randomID();
+
+    await new ZAddCommand([
+      key,
+      { score: score1, member: member1 },
+      { score: score2, member: member2 },
+      { score: score3, member: member3 },
+    ]).exec(client);
+
+    const res = await new ZRangeCommand([
+      key,
+      score1,
+      score2,
+      {
+        byScore: true,
+      },
+    ]).exec(client);
+
+    expect(res.length).toBe(2);
+    expect(res[0]).toEqual(member1);
+    expect(res[1]).toEqual(member2);
+
+    const res2 = await new ZRangeCommand([
+      key,
+      score1,
+      score3,
+      {
+        byScore: true,
+      },
+    ]).exec(client);
+    expect(res2.length).toBe(3);
+    expect(res2[0]).toEqual(member1);
+    expect(res2[1]).toEqual(member2);
+    expect(res2[2]).toEqual(member3);
+
+    const res3 = await new ZRangeCommand([
+      key,
+      "-inf",
+      "+inf",
+      {
+        byScore: true,
+      },
+    ]).exec(client);
+    expect(res3).toEqual(res2);
+  });
+});
+
+describe("bylex", () => {
+  test("returns the set", async () => {
+    const key = newKey();
+
+    await new ZAddCommand([
+      key,
+      { score: 0, member: "a" },
+      { score: 0, member: "b" },
+      { score: 0, member: "c" },
+    ]).exec(client);
+
+    // everything in between a and c, excluding "a" and including "c"
+    const res = await new ZRangeCommand([key, "(a", "[c", { byLex: true }]).exec(client);
+    expect(res.length).toBe(2);
+    expect(res[0]).toBe("b");
+    expect(res[1]).toBe("c");
+
+    //everything after "a", excluding a
+    const res2 = await new ZRangeCommand([key, "(a", "+", { byLex: true }]).exec(client);
+    expect(res2).toEqual(res);
+
+    // everything in between a and "bb", including "a" and excluding "bb"
+    const res3 = await new ZRangeCommand([
+      key,
+      "[a",
+      "(bb",
+      {
+        byLex: true,
+      },
+    ]).exec(client);
+    expect(res3.length).toBe(2);
+    expect(res3[0]).toBe("a");
+    expect(res3[1]).toBe("b");
+  });
+});
+
+describe("rev", () => {
+  test("returns the set in reverse order", async () => {
+    const key = newKey();
+    const score1 = 2;
+    const member1 = randomID();
+
+    const score2 = 5;
+    const member2 = randomID();
+
+    await new ZAddCommand([
+      key,
+      { score: score1, member: member1 },
+      { score: score2, member: member2 },
+    ]).exec(client);
+
+    const res = await new ZRangeCommand([key, 0, 7, { rev: true }]).exec(client);
+    expect(res.length).toBe(2);
+    expect(res[0]).toEqual(member2);
+    expect(res[1]).toEqual(member1);
+  });
+});
+
+describe("limit", () => {
+  test("returns only the first 2", async () => {
+    const key = newKey();
+    for (let i = 0; i < 10; i++) {
+      await new ZAddCommand([key, { score: i, member: randomID() }]).exec(client);
+    }
+
+    const res = await new ZRangeCommand([
+      key,
+      0,
+      7,
+      {
+        byScore: true,
+        offset: 0,
+        count: 2,
+      },
+    ]).exec(client);
+    expect(res.length).toBe(2);
+  });
+});

package/pkg/commands/zrange.ts

@@ -0,0 +1,68 @@
+import type { CommandOptions } from "./command";
+import { Command } from "./command";
+
+export type ZRangeCommandOptions = {
+  withScores?: boolean;
+  rev?: boolean;
+} & (
+  | { byScore: true; byLex?: never }
+  | { byScore?: never; byLex: true }
+  | { byScore?: never; byLex?: never }
+) &
+  ({ offset: number; count: number } | { offset?: never; count?: never });
+/**
+ * @see https://redis.io/commands/zrange
+ */
+export class ZRangeCommand<TData extends unknown[]> extends Command<string[], TData> {
+  constructor(
+    cmd: [key: string, min: number, max: number, opts?: ZRangeCommandOptions],
+    cmdOpts?: CommandOptions<string[], TData>
+  );
+  constructor(
+    cmd: [
+      key: string,
+      min: `(${string}` | `[${string}` | "-" | "+",
+      max: `(${string}` | `[${string}` | "-" | "+",
+      opts: { byLex: true } & ZRangeCommandOptions,
+    ],
+    cmdOpts?: CommandOptions<string[], TData>
+  );
+  constructor(
+    cmd: [
+      key: string,
+      min: number | `(${number}` | "-inf" | "+inf",
+      max: number | `(${number}` | "-inf" | "+inf",
+      opts: { byScore: true } & ZRangeCommandOptions,
+    ],
+    cmdOpts?: CommandOptions<string[], TData>
+  );
+  constructor(
+    [key, min, max, opts]: [
+      key: string,
+      min: number | string,
+      max: number | string,
+      opts?: ZRangeCommandOptions,
+    ],
+    cmdOpts?: CommandOptions<string[], TData>
+  ) {
+    const command: unknown[] = ["zrange", key, min, max];
+
+    // Either byScore or byLex is allowed
+    if (opts?.byScore) {
+      command.push("byscore");
+    }
+    if (opts?.byLex) {
+      command.push("bylex");
+    }
+    if (opts?.rev) {
+      command.push("rev");
+    }
+    if (opts?.count !== undefined && opts.offset !== undefined) {
+      command.push("limit", opts.offset, opts.count);
+    }
+    if (opts?.withScores) {
+      command.push("withscores");
+    }
+    super(command, cmdOpts);
+  }
+}

package/pkg/commands/zrank.test.ts

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

package/pkg/commands/zrank.ts

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

package/pkg/commands/zrem.test.ts

@@ -0,0 +1,21 @@
+import { keygen, newHttpClient, randomID } from "../test-utils";
+
+import { afterAll, expect, test } from "bun:test";
+import { ZAddCommand } from "./zadd";
+import { ZRemCommand } from "./zrem";
+
+const client = newHttpClient();
+
+const { newKey, cleanup } = keygen();
+afterAll(cleanup);
+
+test("returns the number of removed members", async () => {
+  const key = newKey();
+  const member1 = randomID();
+  const member2 = randomID();
+  await new ZAddCommand([key, { score: 1, member: member1 }, { score: 2, member: member2 }]).exec(
+    client
+  );
+  const res = await new ZRemCommand([key, member1, member2]).exec(client);
+  expect(res).toEqual(2);
+});

package/pkg/commands/zrem.ts

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

package/pkg/commands/zremrangebylex.test.ts

@@ -0,0 +1,24 @@
+import { afterAll, expect, test } from "bun:test";
+import { keygen, newHttpClient } from "../test-utils";
+import { ZAddCommand } from "./zadd";
+
+import { ZRemRangeByLexCommand } from "./zremrangebylex";
+const client = newHttpClient();
+
+const { newKey, cleanup } = keygen();
+afterAll(cleanup);
+
+test("returns the number of elements removed", async () => {
+  const key = newKey();
+  await new ZAddCommand([
+    key,
+    { score: 0, member: "aaaa" },
+    { score: 0, member: "b" },
+    { score: 0, member: "c" },
+    { score: 0, member: "d" },
+    { score: 0, member: "e" },
+  ]).exec(client);
+
+  const res = await new ZRemRangeByLexCommand([key, "[b", "[e"]).exec(client);
+  expect(res).toEqual(4);
+});

package/pkg/commands/zremrangebylex.ts

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

package/pkg/commands/zremrangebyrank.test.ts

@@ -0,0 +1,27 @@
+import { keygen, newHttpClient, randomID } from "../test-utils";
+
+import { afterAll, expect, test } from "bun:test";
+import { ZAddCommand } from "./zadd";
+import { ZRemRangeByRankCommand } from "./zremrangebyrank";
+const client = newHttpClient();
+
+const { newKey, cleanup } = keygen();
+afterAll(cleanup);
+
+test("returns the number of removed elements", async () => {
+  const key = newKey();
+  const score1 = 1;
+  const member1 = randomID();
+  const score2 = 2;
+  const member2 = randomID();
+  const score3 = 3;
+  const member3 = randomID();
+  await new ZAddCommand([
+    key,
+    { score: score1, member: member1 },
+    { score: score2, member: member2 },
+    { score: score3, member: member3 },
+  ]).exec(client);
+  const res = await new ZRemRangeByRankCommand([key, 1, 2]).exec(client);
+  expect(res).toEqual(2);
+});

package/pkg/commands/zremrangebyrank.ts

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

package/pkg/commands/zremrangebyscore.test.ts

@@ -0,0 +1,24 @@
+import { keygen, newHttpClient, randomID } from "../test-utils";
+
+import { afterAll, expect, test } from "bun:test";
+import { ZAddCommand } from "./zadd";
+import { ZRemRangeByScoreCommand } from "./zremrangebyscore";
+
+const client = newHttpClient();
+
+const { newKey, cleanup } = keygen();
+afterAll(cleanup);
+test("returns the number of removed elements", async () => {
+  const key = newKey();
+  const member1 = randomID();
+  const member2 = randomID();
+  const member3 = randomID();
+  await new ZAddCommand([
+    key,
+    { score: 1, member: member1 },
+    { score: 2, member: member2 },
+    { score: 3, member: member3 },
+  ]).exec(client);
+  const res = await new ZRemRangeByScoreCommand([key, 1, 2]).exec(client);
+  expect(res).toEqual(2);
+});

package/pkg/commands/zremrangebyscore.ts

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

package/pkg/commands/zrevrank.test.ts

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

package/pkg/commands/zrevrank.ts

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

package/pkg/commands/zscan.test.ts

@@ -0,0 +1,48 @@
+import { keygen, newHttpClient, randomID } from "../test-utils";
+
+import { afterAll, describe, expect, test } from "bun:test";
+import { ZAddCommand } from "./zadd";
+import { ZScanCommand } from "./zscan";
+const client = newHttpClient();
+
+const { newKey, cleanup } = keygen();
+afterAll(cleanup);
+
+describe("without options", () => {
+  test("returns cursor and members", async () => {
+    const key = newKey();
+    const value = randomID();
+    await new ZAddCommand([key, { score: 0, member: value }]).exec(client);
+    const res = await new ZScanCommand([key, 0]).exec(client);
+
+    expect(res.length).toBe(2);
+    expect(typeof res[0]).toBe("string");
+    expect(res[1].length > 0).toBe(true);
+  });
+});
+
+describe("with match", () => {
+  test("returns cursor and members", async () => {
+    const key = newKey();
+    const value = randomID();
+    await new ZAddCommand([key, { score: 0, member: value }]).exec(client);
+    const res = await new ZScanCommand([key, "0", { match: value }]).exec(client);
+
+    expect(res.length).toBe(2);
+    expect(typeof res[0]).toBe("string");
+    expect(res[1].length > 0).toBe(true);
+  });
+});
+
+test("with count", () => {
+  test("returns cursor and members", async () => {
+    const key = newKey();
+    const value = randomID();
+    await new ZAddCommand([key, { score: 0, member: value }]).exec(client);
+    const res = await new ZScanCommand([key, "0", { count: 1 }]).exec(client);
+
+    expect(res.length).toBe(2);
+    expect(typeof res[0]).toBe("number");
+    expect(res[1].length > 0).toBe(true);
+  });
+});

package/pkg/commands/zscan.ts

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

package/pkg/commands/zscore.test.ts

@@ -0,0 +1,18 @@
+import { afterAll, expect, test } from "bun:test";
+import { keygen, newHttpClient, randomID } from "../test-utils";
+import { ZAddCommand } from "./zadd";
+
+import { ZScoreCommand } from "./zscore";
+const client = newHttpClient();
+
+const { newKey, cleanup } = keygen();
+afterAll(cleanup);
+
+test("returns 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 ZScoreCommand([key, member]).exec(client);
+  expect(res).toEqual(score);
+});

package/pkg/commands/zscore.ts

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