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

package/pkg/commands/unlink.test.ts

@@ -0,0 +1,22 @@
+import { keygen, newHttpClient, randomID } from "../test-utils";
+
+import { afterAll, expect, test } from "bun:test";
+import { MSetCommand } from "./mset";
+import { UnlinkCommand } from "./unlink";
+
+const client = newHttpClient();
+
+const { newKey, cleanup } = keygen();
+afterAll(cleanup);
+
+test("unlinks the keys", async () => {
+  const key1 = newKey();
+  const key2 = newKey();
+  const key3 = newKey();
+  const kv: Record<string, string> = {};
+  kv[key1] = randomID();
+  kv[key2] = randomID();
+  await new MSetCommand([kv]).exec(client);
+  const res = await new UnlinkCommand([key1, key2, key3]).exec(client);
+  expect(res).toEqual(2);
+});

package/pkg/commands/unlink.ts

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

package/pkg/commands/xack.test.ts

@@ -0,0 +1,53 @@
+import { addNewItemToStream, keygen, newHttpClient } from "../test-utils";
+
+import { afterAll, describe, expect, test } from "bun:test";
+import { XAckCommand } from "./xack";
+import { XGroupCommand } from "./xgroup";
+import { XReadGroupCommand } from "./xreadgroup";
+
+const client = newHttpClient();
+
+const { newKey, cleanup } = keygen();
+afterAll(cleanup);
+
+describe("XACK", () => {
+  test("should acknowledge a message successfully", async () => {
+    const streamKey1 = newKey();
+    const group = newKey();
+    const consumer = newKey();
+
+    const { streamId: streamId1 } = await addNewItemToStream(streamKey1, client);
+    const { streamId: streamId2 } = await addNewItemToStream(streamKey1, client);
+
+    await new XGroupCommand([streamKey1, { type: "CREATE", group, id: "0" }]).exec(client);
+
+    (await new XReadGroupCommand([group, consumer, streamKey1, ">", { count: 2 }]).exec(
+      client
+    )) as string[];
+
+    const res = await new XAckCommand([streamKey1, group, [streamId1, streamId2]]).exec(client);
+    expect(res).toEqual(2);
+  });
+
+  test("should try to re-acknowledge and return 0", async () => {
+    const streamKey1 = newKey();
+    const group = newKey();
+    const consumer = newKey();
+
+    const { streamId: streamId1 } = await addNewItemToStream(streamKey1, client);
+
+    await new XGroupCommand([
+      streamKey1,
+      { type: "CREATE", group, id: "0", options: { MKSTREAM: true } },
+    ]).exec(client);
+
+    (await new XReadGroupCommand([group, consumer, streamKey1, ">", { count: 2 }]).exec(
+      client
+    )) as string[];
+
+    const res = await new XAckCommand([streamKey1, group, streamId1]).exec(client);
+    expect(res).toEqual(1);
+    const res1 = await new XAckCommand([streamKey1, group, streamId1]).exec(client);
+    expect(res1).toEqual(0);
+  });
+});

package/pkg/commands/xack.ts

@@ -0,0 +1,15 @@
+import type { CommandOptions } from "./command";
+import { Command } from "./command";
+
+/**
+ * @see https://redis.io/commands/xack
+ */
+export class XAckCommand extends Command<number, number> {
+  constructor(
+    [key, group, id]: [key: string, group: string, id: string | string[]],
+    opts?: CommandOptions<number, number>
+  ) {
+    const ids = Array.isArray(id) ? [...id] : [id];
+    super(["XACK", key, group, ...ids], opts);
+  }
+}

package/pkg/commands/xadd.test.ts

@@ -0,0 +1,128 @@
+import { keygen, newHttpClient, randomID } from "../test-utils";
+
+import { afterAll, expect, test } from "bun:test";
+import { XAddCommand } from "./xadd";
+import { XRangeCommand } from "./xrange";
+
+const client = newHttpClient();
+
+const { newKey, cleanup } = keygen();
+afterAll(cleanup);
+
+test("without options", () => {
+  test("should return valid stream id", async () => {
+    const key = newKey();
+    const field1 = "field1";
+    const member1 = randomID();
+
+    const field2 = "field2";
+    const member2 = randomID();
+
+    const res = await new XAddCommand([
+      key,
+      "*",
+      {
+        [field1]: member1,
+        [field2]: member2,
+      },
+    ]).exec(client);
+
+    expect(res.length).toBeGreaterThan(0);
+  });
+});
+
+test("with NOMKSTREAM", () => {
+  test("should return valid stream id", async () => {
+    const key = newKey();
+    const field1 = "field1";
+    const member1 = randomID();
+
+    const field2 = "field2";
+    const member2 = randomID();
+
+    const first = await new XAddCommand([
+      key,
+      "*",
+      {
+        [field1]: member1,
+        [field2]: member2,
+      },
+    ]).exec(client);
+    expect(first.length).toBeGreaterThan(0);
+
+    const res = await new XAddCommand([
+      key,
+      "*",
+      { [field1]: member1, [field2]: member2 },
+      { nomkStream: true },
+    ]).exec(client);
+    expect(res.length).toBeGreaterThan(0);
+  });
+
+  test("should return null", async () => {
+    const key = newKey();
+    const field1 = "field1";
+    const member1 = randomID();
+
+    const field2 = "field2";
+    const member2 = randomID();
+
+    const res = await new XAddCommand([
+      key,
+      "*",
+      { [field1]: member1, [field2]: member2 },
+      { nomkStream: true },
+    ]).exec(client);
+
+    expect(res).toBeNull();
+  });
+});
+
+test("with threshold", () => {
+  test("should always return less than or equal to 5", async () => {
+    const key = newKey();
+    const field1 = "field1";
+    const member1 = randomID();
+
+    const field2 = "field2";
+    const member2 = randomID();
+
+    for (let i = 0; i < 10; i++) {
+      const xaddRes = await new XAddCommand([
+        key,
+        "*",
+        { [field1]: member1, [field2]: member2 },
+        { trim: { comparison: "=", threshold: 5, type: "MAXLEN" } },
+      ]).exec(client);
+      expect(xaddRes.length).toBeGreaterThan(0);
+
+      const xrangeRes = await new XRangeCommand([key, "-", "+"]).exec(client);
+      expect(Object.keys(xrangeRes).length).toBeLessThanOrEqual(5);
+    }
+  });
+
+  test("should trim the stream by stream id", async () => {
+    const key = newKey();
+    const field1 = "field1";
+    const member1 = randomID();
+
+    const field2 = "field2";
+    const member2 = randomID();
+
+    const xaddRes = await new XAddCommand([
+      key,
+      "*",
+      { [field1]: member1, [field2]: member2 },
+    ]).exec(client);
+
+    await new XAddCommand([
+      key,
+      "*",
+      { [field1]: member1, [field2]: member2 },
+      { trim: { type: "minid", threshold: xaddRes, comparison: "=" } },
+    ]).exec(client);
+
+    const xrangeRes = await new XRangeCommand([key, "-", "+"]).exec(client);
+    expect(Object.keys(xrangeRes).length).toEqual(2);
+  });
+});

package/pkg/commands/xadd.ts

@@ -0,0 +1,64 @@
+import type { CommandOptions } from "./command";
+import { Command } from "./command";
+
+type XAddCommandOptions = {
+  nomkStream?: boolean;
+  trim?: (
+    | {
+        type: "MAXLEN" | "maxlen";
+        threshold: number;
+      }
+    | {
+        type: "MINID" | "minid";
+        threshold: string;
+      }
+  ) &
+    (
+      | {
+          comparison: "~";
+          limit?: number;
+        }
+      | {
+          comparison: "=";
+          limit?: never;
+        }
+    );
+};
+
+/**
+ * @see https://redis.io/commands/xadd
+ */
+export class XAddCommand extends Command<string, string> {
+  constructor(
+    [key, id, entries, opts]: [
+      key: string,
+      id: "*" | string,
+      entries: Record<string, unknown>,
+      opts?: XAddCommandOptions,
+    ],
+    commandOptions?: CommandOptions<string, string>
+  ) {
+    const command: unknown[] = ["XADD", key];
+
+    if (opts) {
+      if (opts.nomkStream) {
+        command.push("NOMKSTREAM");
+      }
+      if (opts.trim) {
+        command.push(opts.trim.type, opts.trim.comparison, opts.trim.threshold);
+        if (opts.trim.limit !== undefined) {
+          command.push("LIMIT", opts.trim.limit);
+        }
+      }
+    }
+
+    command.push(id);
+
+    // entries
+    for (const [k, v] of Object.entries(entries)) {
+      command.push(k, v);
+    }
+
+    super(command, commandOptions);
+  }
+}

package/pkg/commands/xautoclaim.test.ts

@@ -0,0 +1,105 @@
+import { addNewItemToStream, keygen, newHttpClient } from "../test-utils";
+
+import { afterAll, describe, expect, test } from "bun:test";
+import { sleep } from "bun";
+import { XAutoClaim } from "./xautoclaim";
+import { XGroupCommand } from "./xgroup";
+import { XReadGroupCommand } from "./xreadgroup";
+
+const client = newHttpClient();
+
+const { newKey, cleanup } = keygen();
+afterAll(cleanup);
+
+describe("XCLAIM", () => {
+  test("should move ownership to newly created consumer ", async () => {
+    const streamKey = newKey();
+    const group = newKey();
+    const consumer1 = newKey();
+    const consumer2 = newKey();
+
+    await addNewItemToStream(streamKey, client);
+    await addNewItemToStream(streamKey, client);
+
+    await new XGroupCommand([streamKey, { type: "CREATE", group, id: "0" }]).exec(client);
+
+    await new XReadGroupCommand([group, consumer1, [streamKey], [">"], { count: 2 }]).exec(client);
+
+    const res = (await new XAutoClaim([streamKey, group, consumer2, 10, "0-0", { count: 1 }]).exec(
+      client
+    )) as string[];
+    expect(res).toBeInstanceOf(Array);
+  });
+
+  test("should try to move ownership and fail due to too high idle time", async () => {
+    const streamKey = newKey();
+    const group = newKey();
+    const consumer1 = newKey();
+    const consumer2 = newKey();
+
+    await addNewItemToStream(streamKey, client);
+    await addNewItemToStream(streamKey, client);
+
+    await new XGroupCommand([streamKey, { type: "CREATE", group, id: "0" }]).exec(client);
+
+    await new XReadGroupCommand([group, consumer1, [streamKey], [">"], { count: 2 }]).exec(client);
+    await sleep(2000);
+    const res = (await new XAutoClaim([
+      streamKey,
+      group,
+      consumer2,
+      3000,
+      "0-0",
+      { count: 1 },
+    ]).exec(client)) as string[];
+    expect(res).toEqual(["0-0", []]);
+  });
+
+  test("should successfull move the ownership with idle time", async () => {
+    const streamKey = newKey();
+    const group = newKey();
+    const consumer1 = newKey();
+    const consumer2 = newKey();
+
+    await addNewItemToStream(streamKey, client);
+    const { streamId } = await addNewItemToStream(streamKey, client);
+
+    await new XGroupCommand([streamKey, { type: "CREATE", group, id: "0" }]).exec(client);
+
+    await new XReadGroupCommand([group, consumer1, [streamKey], [">"], { count: 2 }]).exec(client);
+    await sleep(2000);
+    const xclaim = (await new XAutoClaim([
+      streamKey,
+      group,
+      consumer2,
+      1000,
+      "0-0",
+      { count: 1 },
+    ]).exec(client)) as string[];
+    expect(xclaim[0]).toEqual(streamId);
+  });
+
+  test("should successfull return justid", async () => {
+    const streamKey = newKey();
+    const group = newKey();
+    const consumer1 = newKey();
+    const consumer2 = newKey();
+
+    await addNewItemToStream(streamKey, client);
+    await addNewItemToStream(streamKey, client);
+
+    await new XGroupCommand([streamKey, { type: "CREATE", group, id: "0" }]).exec(client);
+
+    await new XReadGroupCommand([group, consumer1, [streamKey], [">"], { count: 2 }]).exec(client);
+
+    const xclaim = (await new XAutoClaim([
+      streamKey,
+      group,
+      consumer2,
+      0,
+      "0-0",
+      { count: 1, justId: true },
+    ]).exec(client)) as string[];
+    expect(xclaim[1].length).toBe(1);
+  });
+});

package/pkg/commands/xautoclaim.ts

@@ -0,0 +1,30 @@
+import type { CommandOptions } from "./command";
+import { Command } from "./command";
+
+/**
+ * @see https://redis.io/commands/xautoclaim
+ */
+export class XAutoClaim extends Command<unknown[], unknown[]> {
+  constructor(
+    [key, group, consumer, minIdleTime, start, options]: [
+      key: string,
+      group: string,
+      consumer: string,
+      minIdleTime: number,
+      start: string,
+      options?: { count?: number; justId?: boolean },
+    ],
+    opts?: CommandOptions<unknown[], unknown[]>
+  ) {
+    const commands: unknown[] = [];
+
+    if (options?.count) {
+      commands.push("COUNT", options.count);
+    }
+
+    if (options?.justId) {
+      commands.push("JUSTID");
+    }
+    super(["XAUTOCLAIM", key, group, consumer, minIdleTime, start, ...commands], opts);
+  }
+}

package/pkg/commands/xclaim.test.ts

@@ -0,0 +1,70 @@
+import { addNewItemToStream, keygen, newHttpClient } from "../test-utils";
+
+import { afterAll, describe, expect, test } from "bun:test";
+import { XClaimCommand } from "./xclaim";
+import { XGroupCommand } from "./xgroup";
+import { XReadGroupCommand } from "./xreadgroup";
+
+const client = newHttpClient();
+
+const { newKey, cleanup } = keygen();
+afterAll(cleanup);
+
+describe("XCLAIM", () => {
+  test("should move ownership from one consumer to other", async () => {
+    const streamKey = newKey();
+    const group = newKey();
+    const consumer1 = newKey();
+    const consumer2 = newKey();
+    const consumer3 = newKey();
+
+    await addNewItemToStream(streamKey, client);
+    const { streamId: streamId2 } = await addNewItemToStream(streamKey, client);
+    await addNewItemToStream(streamKey, client);
+
+    await new XGroupCommand([streamKey, { type: "CREATE", group, id: "0" }]).exec(client);
+
+    await new XReadGroupCommand([group, consumer1, [streamKey], [">"], { count: 1 }]).exec(client);
+
+    await new XReadGroupCommand([group, consumer2, [streamKey], [">"], { count: 1 }]).exec(client);
+
+    await new XReadGroupCommand([group, consumer3, [streamKey], [">"], { count: 1 }]).exec(client);
+
+    const res = (await new XClaimCommand([streamKey, group, consumer3, 100, streamId2]).exec(
+      client
+    )) as string[];
+
+    expect(res).toBeInstanceOf(Array);
+    expect(res[0][0]).toBe(streamId2);
+  });
+
+  test("should claim a message and set its idle time to 10000 milliseconds", async () => {
+    const streamKey = newKey();
+    const group = newKey();
+    const consumer1 = newKey();
+    const consumer3 = newKey();
+
+    const { streamId } = await addNewItemToStream(streamKey, client);
+    await addNewItemToStream(streamKey, client);
+    await addNewItemToStream(streamKey, client);
+
+    await new XGroupCommand([streamKey, { type: "CREATE", group, id: "0" }]).exec(client);
+
+    await new XReadGroupCommand([group, consumer1, [streamKey], [">"], { count: 1 }]).exec(client);
+
+    await new XReadGroupCommand([group, consumer3, [streamKey], [">"], { count: 1 }]).exec(client);
+
+    const res = (await new XClaimCommand([
+      streamKey,
+      group,
+      consumer3,
+      0,
+      streamId,
+      {
+        justId: true,
+      },
+    ]).exec(client)) as string[];
+
+    expect(res).toEqual([streamId]);
+  });
+});

package/pkg/commands/xclaim.ts

@@ -0,0 +1,55 @@
+import type { CommandOptions } from "./command";
+import { Command } from "./command";
+
+/**
+ * @see https://redis.io/commands/xclaim
+ */
+export class XClaimCommand extends Command<unknown[], unknown[]> {
+  constructor(
+    [key, group, consumer, minIdleTime, id, options]: [
+      key: string,
+      group: string,
+      consumer: string,
+      minIdleTime: number,
+      id: string | string[],
+      options?: {
+        idleMS?: number;
+        timeMS?: number;
+        retryCount?: number;
+        force?: boolean;
+        justId?: boolean;
+        lastId?: number;
+      },
+    ],
+    opts?: CommandOptions<unknown[], unknown[]>
+  ) {
+    const ids = Array.isArray(id) ? [...id] : [id];
+    const commands: unknown[] = [];
+
+    if (options?.idleMS) {
+      commands.push("IDLE", options.idleMS);
+    }
+
+    if (options?.idleMS) {
+      commands.push("TIME", options.timeMS);
+    }
+
+    if (options?.retryCount) {
+      commands.push("RETRYCOUNT", options.retryCount);
+    }
+
+    if (options?.force) {
+      commands.push("FORCE");
+    }
+
+    if (options?.justId) {
+      commands.push("JUSTID");
+    }
+
+    if (options?.lastId) {
+      commands.push("LASTID", options.lastId);
+    }
+
+    super(["XCLAIM", key, group, consumer, minIdleTime, ...ids, ...commands], opts);
+  }
+}

package/pkg/commands/xdel.test.ts

@@ -0,0 +1,50 @@
+import { keygen, newHttpClient } from "../test-utils";
+
+import { afterAll, describe, expect, test } from "bun:test";
+import { XAddCommand } from "./xadd";
+import { XDelCommand } from "./xdel";
+import { XRangeCommand } from "./xrange";
+
+const client = newHttpClient();
+
+const { newKey, cleanup } = keygen();
+afterAll(cleanup);
+
+describe("XDEL", () => {
+  test("should delete one item from the stream", async () => {
+    const key = newKey();
+    await new XAddCommand([key, "*", { name: "Jane", surname: "Austen" }]).exec(client);
+
+    const res = await new XAddCommand([key, "*", { name: "Toni", surname: "Morrison" }]).exec(
+      client
+    );
+
+    const xdelRes = await new XDelCommand([key, res]).exec(client);
+    const xrangeRes = await new XRangeCommand([key, "-", "+", 1]).exec(client);
+
+    expect(Object.keys(xrangeRes).length).toBe(1);
+    expect(xdelRes).toBe(1);
+  });
+
+  test("should delete multiple items from the stream", async () => {
+    const key = newKey();
+
+    const id1 = await new XAddCommand([key, "*", { name: "Jane", surname: "Austen" }]).exec(client);
+
+    const id2 = await new XAddCommand([key, "*", { name: "Toni", surname: "Morrison" }]).exec(
+      client
+    );
+
+    const id3 = await new XAddCommand([key, "*", { name: "Agatha", surname: "Christie" }]).exec(
+      client
+    );
+
+    await new XAddCommand([key, "*", { name: "Ngozi", surname: "Adichie" }]).exec(client);
+
+    const xdelRes = await new XDelCommand([key, [id1, id2, id3]]).exec(client);
+    const xrangeRes = await new XRangeCommand([key, "-", "+", 1]).exec(client);
+
+    expect(Object.keys(xrangeRes).length).toBe(1);
+    expect(xdelRes).toBe(3);
+  });
+});

package/pkg/commands/xdel.ts

@@ -0,0 +1,15 @@
+import type { CommandOptions } from "./command";
+import { Command } from "./command";
+
+/**
+ * @see https://redis.io/commands/xdel
+ */
+export class XDelCommand extends Command<number, number> {
+  constructor(
+    [key, ids]: [key: string, ids: string[] | string],
+    opts?: CommandOptions<number, number>
+  ) {
+    const cmds = Array.isArray(ids) ? [...ids] : [ids];
+    super(["XDEL", key, ...cmds], opts);
+  }
+}