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

package/pkg/commands/json_objkeys.test.ts

@@ -0,0 +1,32 @@
+import { afterAll, expect, test } from "bun:test";
+import { keygen, newHttpClient } from "../test-utils";
+
+import { JsonSetCommand } from "./json_set";
+
+import { JsonObjKeysCommand } from "./json_objkeys";
+
+const client = newHttpClient();
+
+const { newKey, cleanup } = keygen();
+afterAll(cleanup);
+
+test("return the keys", async () => {
+  const key = newKey();
+  const res1 = await new JsonSetCommand([
+    key,
+    "$",
+    {
+      a: [3],
+      nested: { a: { b: 2, c: 1 } },
+    },
+  ]).exec(client);
+  expect(res1).toEqual("OK");
+  const res2 = await new JsonObjKeysCommand([key, "$..a"]).exec(client);
+  for (const e of res2.sort()) {
+    if (e === null) {
+      continue;
+    }
+    e.sort();
+  }
+  expect(res2).toEqual([["b", "c"], null]);
+});

package/pkg/commands/json_objkeys.ts

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

package/pkg/commands/json_objlen.test.ts

@@ -0,0 +1,26 @@
+import { afterAll, expect, test } from "bun:test";
+import { keygen, newHttpClient } from "../test-utils";
+
+import { JsonSetCommand } from "./json_set";
+
+import { JsonObjLenCommand } from "./json_objlen";
+
+const client = newHttpClient();
+
+const { newKey, cleanup } = keygen();
+afterAll(cleanup);
+
+test("return the length", async () => {
+  const key = newKey();
+  const res1 = await new JsonSetCommand([
+    key,
+    "$",
+    {
+      a: [3],
+      nested: { a: { b: 2, c: 1 } },
+    },
+  ]).exec(client);
+  expect(res1).toBe("OK");
+  const res2 = await new JsonObjLenCommand([key, "$..a"]).exec(client);
+  expect(res2).toEqual([2, null]);
+});

package/pkg/commands/json_objlen.ts

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

package/pkg/commands/json_resp.test.ts

@@ -0,0 +1,31 @@
+import { afterAll, expect, test } from "bun:test";
+import { keygen, newHttpClient } from "../test-utils";
+
+import { JsonSetCommand } from "./json_set";
+
+import { JsonRespCommand } from "./json_resp";
+
+const client = newHttpClient();
+
+const { newKey, cleanup } = keygen();
+afterAll(cleanup);
+
+test("Return an array of RESP details about a document", async () => {
+  const key = newKey();
+  const res1 = await new JsonSetCommand([
+    key,
+    "$",
+    {
+      name: "Wireless earbuds",
+      description: "Wireless Bluetooth in-ear headphones",
+      connection: { wireless: true, type: "Bluetooth" },
+      price: 64.99,
+      stock: 17,
+      colors: ["black", "white"],
+      max_level: [80, 100, 120],
+    },
+  ]).exec(client);
+  expect(res1).toBe("OK");
+  const res2 = await new JsonRespCommand([key]).exec(client);
+  expect(res2.length).toBe(15);
+});

package/pkg/commands/json_resp.ts

@@ -0,0 +1,11 @@
+import type { CommandOptions } from "./command";
+import { Command } from "./command";
+
+/**
+ * @see https://redis.io/commands/json.resp
+ */
+export class JsonRespCommand<TData extends unknown[]> extends Command<TData, TData> {
+  constructor(cmd: [key: string, path?: string], opts?: CommandOptions<TData, TData>) {
+    super(["JSON.RESP", ...cmd], opts);
+  }
+}

package/pkg/commands/json_set.test.ts

@@ -0,0 +1,48 @@
+import { afterAll, expect, test } from "bun:test";
+import { keygen, newHttpClient } from "../test-utils";
+
+import { JsonGetCommand } from "./json_get";
+import { JsonSetCommand } from "./json_set";
+
+const client = newHttpClient();
+
+const { newKey, cleanup } = keygen();
+afterAll(cleanup);
+
+test("replace an existing value", async () => {
+  const key = newKey();
+  const res1 = await new JsonSetCommand([key, "$", { a: 2 }]).exec(client);
+  expect(res1).toEqual("OK");
+  const res2 = await new JsonSetCommand([key, "$.a", 3]).exec(client);
+  expect(res2).toEqual("OK");
+  const res3 = await new JsonGetCommand([key, "$"]).exec(client);
+  expect(res3).toEqual([{ a: 3 }]);
+});
+
+test("add a new value", async () => {
+  const key = newKey();
+  const res1 = await new JsonSetCommand([key, "$", { a: 2 }]).exec(client);
+  expect(res1).toEqual("OK");
+  const res2 = await new JsonSetCommand([key, "$.b", 8]).exec(client);
+  expect(res2).toEqual("OK");
+  const res3 = await new JsonGetCommand([key, "$"]).exec(client);
+  expect(res3).toEqual([{ a: 2, b: 8 }]);
+});
+
+test("update multi-paths", async () => {
+  const key = newKey();
+  const data = {
+    f1: { a: 1 },
+    f2: { a: 2 },
+  };
+  const res1 = await new JsonSetCommand([key, "$", data]).exec(client);
+  expect(res1).toEqual("OK");
+  const res2 = await new JsonSetCommand([key, "$..a", 3]).exec(client);
+  expect(res2).toEqual("OK");
+  const res3 = await new JsonGetCommand<any[]>([key, "$"]).exec(client);
+
+  expect(res3).not.toBeNull();
+  expect(res3!.length).toEqual(1);
+  expect(res3![0]?.f1?.a).toEqual(3);
+  expect(res3![0]?.f2?.a).toEqual(3);
+});

package/pkg/commands/json_set.ts

@@ -0,0 +1,34 @@
+import type { CommandOptions } from "./command";
+import { Command } from "./command";
+
+/**
+ * @see https://redis.io/commands/json.set
+ */
+export class JsonSetCommand<
+  TData extends
+    | number
+    | string
+    | boolean
+    | Record<string, unknown>
+    | (number | string | boolean | Record<string, unknown>)[],
+> extends Command<"OK" | null, "OK" | null> {
+  constructor(
+    cmd: [
+      key: string,
+      path: string,
+      value: TData,
+      opts?: { nx: true; xx?: never } | { nx?: never; xx: true },
+    ],
+    opts?: CommandOptions<"OK" | null, "OK" | null>
+  ) {
+    const command = ["JSON.SET", cmd[0], cmd[1], cmd[2]];
+    if (cmd[3]) {
+      if (cmd[3].nx) {
+        command.push("NX");
+      } else if (cmd[3].xx) {
+        command.push("XX");
+      }
+    }
+    super(command, opts);
+  }
+}

package/pkg/commands/json_strappend.test.ts

@@ -0,0 +1,34 @@
+import { afterAll, expect, test } from "bun:test";
+import { keygen, newHttpClient } from "../test-utils";
+
+import { JsonSetCommand } from "./json_set";
+
+import { JsonGetCommand } from "./json_get";
+import { JsonStrAppendCommand } from "./json_strappend";
+
+const client = newHttpClient();
+
+const { newKey, cleanup } = keygen();
+afterAll(cleanup);
+
+test("Add 'baz' to existing string", async () => {
+  const key = newKey();
+  const res1 = await new JsonSetCommand([
+    key,
+    "$",
+    {
+      a: "foo",
+      nested: { a: "hello" },
+      nested2: { a: 31 },
+    },
+  ]).exec(client);
+  expect(res1).toBe("OK");
+  const res2 = await new JsonStrAppendCommand([key, "$..a", '"baz"']).exec(client);
+  expect(res2.sort()).toEqual([6, 8, null]);
+  const res3 = await new JsonGetCommand([key]).exec(client);
+  expect(res3).toEqual({
+    a: "foobaz",
+    nested: { a: "hellobaz" },
+    nested2: { a: 31 },
+  });
+});

package/pkg/commands/json_strappend.ts

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

package/pkg/commands/json_strlen.test.ts

@@ -0,0 +1,27 @@
+import { afterAll, expect, test } from "bun:test";
+import { keygen, newHttpClient } from "../test-utils";
+
+import { JsonSetCommand } from "./json_set";
+
+import { JsonStrLenCommand } from "./json_strlen";
+
+const client = newHttpClient();
+
+const { newKey, cleanup } = keygen();
+afterAll(cleanup);
+
+test("return the length", async () => {
+  const key = newKey();
+  const res1 = await new JsonSetCommand([
+    key,
+    "$",
+    {
+      a: "foo",
+      nested: { a: "hello" },
+      nested2: { a: 31 },
+    },
+  ]).exec(client);
+  expect(res1).toBe("OK");
+  const res2 = await new JsonStrLenCommand([key, "$..a"]).exec(client);
+  expect(res2.sort()).toEqual([3, 5, null]);
+});

package/pkg/commands/json_strlen.ts

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

package/pkg/commands/json_toggle.test.ts

@@ -0,0 +1,26 @@
+import { afterAll, expect, test } from "bun:test";
+import { keygen, newHttpClient } from "../test-utils";
+
+import { JsonSetCommand } from "./json_set";
+
+import { JsonGetCommand } from "./json_get";
+import { JsonToggleCommand } from "./json_toggle";
+
+const client = newHttpClient();
+
+const { newKey, cleanup } = keygen();
+afterAll(cleanup);
+
+test("Toogle a Boolean value stored at path", async () => {
+  const key = newKey();
+  const res1 = await new JsonSetCommand([key, "$", { bool: true }]).exec(client);
+  expect(res1).toBe("OK");
+  const res2 = await new JsonToggleCommand([key, "$.bool"]).exec(client);
+  expect(res2).toEqual([0]);
+  const res3 = await new JsonGetCommand([key, "$"]).exec(client);
+  expect(res3).toEqual([{ bool: false }]);
+  const res4 = await new JsonToggleCommand([key, "$.bool"]).exec(client);
+  expect(res4).toEqual([1]);
+  const res5 = await new JsonGetCommand([key, "$"]).exec(client);
+  expect(res5).toEqual([{ bool: true }]);
+});

package/pkg/commands/json_toggle.ts

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

package/pkg/commands/json_type.test.ts

@@ -0,0 +1,29 @@
+import { afterAll, expect, test } from "bun:test";
+import { keygen, newHttpClient } from "../test-utils";
+
+import { JsonSetCommand } from "./json_set";
+
+import { JsonTypeCommand } from "./json_type";
+
+const client = newHttpClient();
+
+const { newKey, cleanup } = keygen();
+afterAll(cleanup);
+
+test("return the length", async () => {
+  const key = newKey();
+  const res1 = await new JsonSetCommand([
+    key,
+    "$",
+    {
+      a: 2,
+      nested: { a: true },
+      foo: "bar",
+    },
+  ]).exec(client);
+  expect(res1).toBe("OK");
+  const res2 = await new JsonTypeCommand([key, "$..foo"]).exec(client);
+  expect(res2.sort()).toEqual(["string"]);
+  const res3 = await new JsonTypeCommand([key, "$..a"]).exec(client);
+  expect(res3.sort()).toEqual(["boolean", "integer"]);
+});

package/pkg/commands/json_type.ts

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

package/pkg/commands/keys.test.ts

@@ -0,0 +1,18 @@
+import { afterAll, expect, test } from "bun:test";
+import { keygen, newHttpClient } from "../test-utils";
+import { KeysCommand } from "./keys";
+import { SetCommand } from "./set";
+
+const client = newHttpClient();
+
+const { newKey, cleanup } = keygen();
+afterAll(cleanup);
+
+test("when keys are found", () => {
+  test("returns keys", async () => {
+    const key = newKey();
+    await new SetCommand([key, "value"]).exec(client);
+    const res = await new KeysCommand([key]).exec(client);
+    expect(res).toEqual([key]);
+  });
+});

package/pkg/commands/keys.ts

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

package/pkg/commands/lindex.test.ts

@@ -0,0 +1,33 @@
+import { keygen, newHttpClient, randomID } from "../test-utils";
+
+import { afterAll, expect, test } from "bun:test";
+import { LIndexCommand } from "./lindex";
+import { LPushCommand } from "./lpush";
+
+const client = newHttpClient();
+
+const { newKey, cleanup } = keygen();
+afterAll(cleanup);
+
+test("when list exists", () => {
+  test("when the index is in range", () => {
+    test("returns the element at index", async () => {
+      const key = newKey();
+
+      const value = randomID();
+      await new LPushCommand([key, value]).exec(client);
+      const res = await new LIndexCommand([key, 0]).exec(client);
+      expect(res).toEqual(value);
+    });
+    test("when the index is out of bounds", () => {
+      test("returns null", async () => {
+        const key = newKey();
+
+        const value = randomID();
+        await new LPushCommand([key, value]).exec(client);
+        const res = await new LIndexCommand([key, 1]).exec(client);
+        expect(res).toEqual(null);
+      });
+    });
+  });
+});

package/pkg/commands/lindex.ts

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

package/pkg/commands/linsert.test.ts

@@ -0,0 +1,24 @@
+import { keygen, newHttpClient, randomID } from "../test-utils";
+
+import { afterAll, expect, test } from "bun:test";
+import { LInsertCommand } from "./linsert";
+
+import { LPushCommand } from "./lpush";
+import { LRangeCommand } from "./lrange";
+const client = newHttpClient();
+
+const { newKey, cleanup } = keygen();
+afterAll(cleanup);
+
+test("adds the element", async () => {
+  const key = newKey();
+  const value1 = randomID();
+  const value2 = randomID();
+
+  await new LPushCommand([key, value1]).exec(client);
+  const res = await new LInsertCommand([key, "before", value1, value2]).exec(client);
+  expect(res).toEqual(2);
+
+  const list = await new LRangeCommand([key, 0, -1]).exec(client);
+  expect(list).toEqual([value2, value1]);
+});

package/pkg/commands/linsert.ts

@@ -0,0 +1,10 @@
+import type { CommandOptions } from "./command";
+import { Command } from "./command";
+export class LInsertCommand<TData = string> extends Command<number, number> {
+  constructor(
+    cmd: [key: string, direction: "before" | "after", pivot: TData, value: TData],
+    opts?: CommandOptions<number, number>
+  ) {
+    super(["linsert", ...cmd], opts);
+  }
+}

package/pkg/commands/llen.test.ts

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

package/pkg/commands/llen.ts

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

package/pkg/commands/lmove.test.ts

@@ -0,0 +1,48 @@
+import { keygen, newHttpClient, randomID } from "../test-utils";
+
+import { afterAll, expect, test } from "bun:test";
+import { LPushCommand } from "./lpush";
+
+import { LLenCommand } from "./llen";
+import { LMoveCommand } from "./lmove";
+import { LPopCommand } from "./lpop";
+
+const client = newHttpClient();
+
+const { newKey, cleanup } = keygen();
+afterAll(cleanup);
+
+test("moves the entry from left to left", async () => {
+  const source = newKey();
+  const destination = newKey();
+  const value = randomID();
+  await new LPushCommand([source, value]).exec(client);
+
+  const res = await new LMoveCommand([source, destination, "left", "left"]).exec(client);
+  expect(res).toEqual(value);
+
+  const elementInSource = await new LPopCommand([source]).exec(client);
+  expect(elementInSource).toEqual(null);
+
+  const elementInDestination = await new LPopCommand([destination]).exec(client);
+  expect(elementInDestination).toBe(value);
+});
+
+test("moves the entry from left to right", async () => {
+  const source = newKey();
+  const destination = newKey();
+  const values = Array.from({ length: 5 })
+    .fill(0)
+    .map((_) => randomID());
+
+  await new LPushCommand([source, ...values]).exec(client);
+
+  const res = await new LMoveCommand([source, destination, "left", "right"]).exec(client);
+  expect(res).toEqual(values.at(-1));
+
+  const elementsInSource = await new LLenCommand([source]).exec(client);
+  expect(elementsInSource).toEqual(values.length - 1);
+
+  const elementInDestination = await new LPopCommand([destination]).exec(client);
+  expect(elementInDestination).toEqual(values.at(-1));
+});

package/pkg/commands/lmove.ts

@@ -0,0 +1,19 @@
+import type { CommandOptions } from "./command";
+import { Command } from "./command";
+
+/**
+ * @see https://redis.io/commands/lmove
+ */
+export class LMoveCommand<TData = string> extends Command<TData, TData> {
+  constructor(
+    cmd: [
+      source: string,
+      destination: string,
+      whereFrom: "left" | "right",
+      whereTo: "left" | "right",
+    ],
+    opts?: CommandOptions<TData, TData>
+  ) {
+    super(["lmove", ...cmd], opts);
+  }
+}