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

package/pkg/commands/xgroup.test.ts

@@ -0,0 +1,202 @@
+/* eslint-disable unicorn/consistent-function-scoping */
+import { keygen, newHttpClient } from "../test-utils";
+
+import { afterAll, describe, expect, test } from "bun:test";
+import { XAddCommand } from "./xadd";
+import { XGroupCommand } from "./xgroup";
+
+const client = newHttpClient();
+
+const { newKey, cleanup } = keygen();
+afterAll(cleanup);
+
+describe("XGROUP CREATE", () => {
+  test("should create a group successfully", async () => {
+    const key = newKey();
+    const group = newKey();
+    const res = await new XGroupCommand([
+      key,
+      {
+        type: "CREATE",
+        group,
+        id: "$",
+        options: {
+          MKSTREAM: true,
+        },
+      },
+    ]).exec(client);
+    expect(res).toEqual("OK");
+  });
+  test("should return error if stream and mkstream don't exist ", () => {
+    const throwable = async () => {
+      const key = newKey();
+      const group = newKey();
+      await new XGroupCommand([key, { type: "CREATE", group, id: "$" }]).exec(client);
+    };
+
+    expect(throwable).toThrow();
+  });
+});
+
+describe("XGROUP CREATECONSUMER", () => {
+  test("should create a group successfully with CREATECONSUMER", async () => {
+    const key = newKey();
+    const group = newKey();
+    const consumer = newKey();
+    await new XGroupCommand([
+      key,
+      {
+        type: "CREATE",
+        group,
+        id: "$",
+        options: {
+          MKSTREAM: true,
+        },
+      },
+    ]).exec(client);
+    const res = await new XGroupCommand([
+      key,
+      {
+        type: "CREATECONSUMER",
+        group,
+        consumer,
+      },
+    ]).exec(client);
+    expect(res).toEqual(1);
+  });
+});
+
+describe("XGROUP CREATECONSUMER", () => {
+  test("should return 0 since nothing to delete", async () => {
+    const key = newKey();
+    const group = newKey();
+    const consumer = newKey();
+    await new XGroupCommand([
+      key,
+      {
+        type: "CREATE",
+        group,
+        id: "$",
+        options: {
+          MKSTREAM: true,
+        },
+      },
+    ]).exec(client);
+
+    const res = await new XGroupCommand([
+      key,
+      {
+        type: "DELCONSUMER",
+        group,
+        consumer,
+      },
+    ]).exec(client);
+    expect(res).toEqual(0);
+  });
+});
+
+describe("XGROUP DESTROY", () => {
+  test("should DESTROY the consumer group", async () => {
+    const key = newKey();
+    const group = newKey();
+    await new XGroupCommand([
+      key,
+      {
+        type: "CREATE",
+        group,
+        id: "$",
+        options: {
+          MKSTREAM: true,
+        },
+      },
+    ]).exec(client);
+
+    const res = await new XGroupCommand([
+      key,
+      {
+        type: "DESTROY",
+        group,
+      },
+    ]).exec(client);
+    expect(res).toEqual(1);
+  });
+
+  test("should throw if stream doesn't exist", () => {
+    const throwable = async () => {
+      const key = newKey();
+      const group = newKey();
+
+      await new XGroupCommand([
+        key,
+        {
+          type: "DESTROY",
+          group,
+        },
+      ]).exec(client);
+    };
+    expect(throwable).toThrow();
+  });
+
+  test("should try to destroy empty group, then destroy filled group successfully", async () => {
+    const key = newKey();
+    const group = newKey();
+    await new XAddCommand([key, "*", { hello: "world" }]).exec(client);
+
+    const numOfDeletedGroups = await new XGroupCommand([
+      key,
+      {
+        type: "DESTROY",
+        group,
+      },
+    ]).exec(client);
+    expect(numOfDeletedGroups).toEqual(0);
+
+    await new XGroupCommand([
+      key,
+      {
+        type: "CREATE",
+        group,
+        id: "$",
+      },
+    ]).exec(client);
+
+    const numOfDeletedGroupsAfterCreate = await new XGroupCommand([
+      key,
+      {
+        type: "DESTROY",
+        group,
+      },
+    ]).exec(client);
+
+    expect(numOfDeletedGroupsAfterCreate).toEqual(1);
+  });
+});
+
+describe("XGROUP SETID", () => {
+  test("should DESTROY the consumer group", async () => {
+    const key = newKey();
+    const group = newKey();
+    await new XGroupCommand([
+      key,
+      {
+        type: "CREATE",
+        group,
+        id: "$",
+        options: {
+          MKSTREAM: true,
+        },
+      },
+    ]).exec(client);
+
+    const res = await new XGroupCommand([
+      key,
+      {
+        type: "SETID",
+        group,
+        id: "$",
+      },
+    ]).exec(client);
+
+    expect(res).toEqual("OK");
+  });
+});

package/pkg/commands/xgroup.ts

@@ -0,0 +1,100 @@
+import type { CommandOptions } from "./command.ts";
+import { Command } from "./command.ts";
+
+type XGroupCommandType =
+  | {
+      type: "CREATE";
+      group: string;
+      id: `$` | string;
+      options?: { MKSTREAM?: boolean; ENTRIESREAD?: number };
+    }
+  | {
+      type: "CREATECONSUMER";
+      group: string;
+      consumer: string;
+    }
+  | {
+      type: "DELCONSUMER";
+      group: string;
+      consumer: string;
+    }
+  | {
+      type: "DESTROY";
+      group: string;
+    }
+  | {
+      type: "SETID";
+      group: string;
+      id: `$` | string;
+      options?: { ENTRIESREAD?: number };
+    };
+
+type XGroupReturnType<T extends XGroupCommandType> = T["type"] extends "CREATE"
+  ? string
+  : T["type"] extends "CREATECONSUMER"
+    ? 0 | 1
+    : T["type"] extends "DELCONSUMER"
+      ? number
+      : T["type"] extends "DESTROY"
+        ? 0 | 1
+        : T["type"] extends "SETID"
+          ? string
+          : never;
+
+/**
+ * @see https://redis.io/commands/xgroup
+ */
+export class XGroupCommand<TOptions extends XGroupCommandType = XGroupCommandType> extends Command<
+  any,
+  XGroupReturnType<TOptions>
+> {
+  constructor(
+    [key, opts]: [key: string, opts: TOptions],
+    commandOptions?: CommandOptions<any, any>
+  ) {
+    const command: unknown[] = ["XGROUP"];
+
+    switch (opts.type) {
+      case "CREATE": {
+        command.push("CREATE", key, opts.group, opts.id);
+        if (opts.options) {
+          if (opts.options.MKSTREAM) {
+            command.push("MKSTREAM");
+          }
+          if (opts.options.ENTRIESREAD !== undefined) {
+            command.push("ENTRIESREAD", opts.options.ENTRIESREAD.toString());
+          }
+        }
+        break;
+      }
+
+      case "CREATECONSUMER": {
+        command.push("CREATECONSUMER", key, opts.group, opts.consumer);
+        break;
+      }
+
+      case "DELCONSUMER": {
+        command.push("DELCONSUMER", key, opts.group, opts.consumer);
+        break;
+      }
+
+      case "DESTROY": {
+        command.push("DESTROY", key, opts.group);
+        break;
+      }
+
+      case "SETID": {
+        command.push("SETID", key, opts.group, opts.id);
+        if (opts.options?.ENTRIESREAD !== undefined) {
+          command.push("ENTRIESREAD", opts.options.ENTRIESREAD.toString());
+        }
+        break;
+      }
+
+      default: {
+        throw new Error("Invalid XGROUP");
+      }
+    }
+    super(command, commandOptions);
+  }
+}

package/pkg/commands/xinfo.test.ts

@@ -0,0 +1,82 @@
+import { addNewItemToStream, keygen, newHttpClient } from "../test-utils";
+
+import { afterAll, describe, expect, test } from "bun:test";
+import { XGroupCommand } from "./xgroup";
+import { XInfoCommand } from "./xinfo";
+import { XReadGroupCommand } from "./xreadgroup";
+
+const client = newHttpClient();
+
+const { newKey, cleanup } = keygen();
+afterAll(cleanup);
+
+describe("GROUPS", () => {
+  test("should return empty array when there is no group", async () => {
+    const wantedAmount = 3;
+    const streamKey = newKey();
+
+    for (let i = 0; i < wantedAmount; i++) {
+      await addNewItemToStream(streamKey, client);
+    }
+
+    const res = (await new XInfoCommand([streamKey, { type: "GROUPS" }]).exec(client)) as string[];
+    expect(res).toEqual([]);
+  });
+
+  test("should return given group id", async () => {
+    const wantedAmount = 3;
+    const streamKey = newKey();
+    const group = newKey();
+
+    for (let i = 0; i < wantedAmount; i++) {
+      await addNewItemToStream(streamKey, client);
+    }
+
+    await new XGroupCommand([streamKey, { type: "CREATE", group, id: "0" }]).exec(client);
+
+    const res = (await new XInfoCommand([streamKey, { type: "GROUPS" }]).exec(client)) as string[];
+    expect(res[0][1]).toEqual(group);
+  });
+});
+
+describe("CONSUMERS", () => {
+  test("should return empty array when there is no consumer", async () => {
+    const wantedAmount = 3;
+    const streamKey = newKey();
+    const group = newKey();
+
+    for (let i = 0; i < wantedAmount; i++) {
+      await addNewItemToStream(streamKey, client);
+    }
+
+    await new XGroupCommand([streamKey, { type: "CREATE", group, id: "0" }]).exec(client);
+
+    const res = (await new XInfoCommand([streamKey, { type: "CONSUMERS", group }]).exec(
+      client
+    )) as string[];
+
+    expect(res).toEqual([]);
+  });
+
+  test("should return empty array when there is no consumer", async () => {
+    const wantedAmount = 3;
+    const streamKey = newKey();
+    const group = newKey();
+    const consumer = newKey();
+
+    for (let i = 0; i < wantedAmount; i++) {
+      await addNewItemToStream(streamKey, client);
+    }
+
+    await new XGroupCommand([streamKey, { type: "CREATE", group, id: "0" }]).exec(client);
+
+    (await new XReadGroupCommand([group, consumer, streamKey, ">"]).exec(client)) as string[];
+
+    const res = (await new XInfoCommand([streamKey, { type: "CONSUMERS", group }]).exec(
+      client
+    )) as string[];
+    const pendingCount = res[0][3];
+
+    expect(pendingCount).toBe(wantedAmount);
+  });
+});

package/pkg/commands/xinfo.ts

@@ -0,0 +1,27 @@
+import type { CommandOptions } from "./command";
+import { Command } from "./command";
+
+type XInfoCommands =
+  | {
+      type: "CONSUMERS";
+      group: string;
+    }
+  | { type: "GROUPS" };
+
+/**
+ * @see https://redis.io/commands/xinfo
+ */
+export class XInfoCommand extends Command<number, unknown[]> {
+  constructor(
+    [key, options]: [key: string, options: XInfoCommands],
+    opts?: CommandOptions<number, unknown[]>
+  ) {
+    const cmds: unknown[] = [];
+    if (options.type === "CONSUMERS") {
+      cmds.push("CONSUMERS", key, options.group);
+    } else {
+      cmds.push("GROUPS", key);
+    }
+    super(["XINFO", ...cmds], opts);
+  }
+}

package/pkg/commands/xlen.test.ts

@@ -0,0 +1,29 @@
+import { keygen, newHttpClient } from "../test-utils";
+
+import { afterAll, describe, expect, test } from "bun:test";
+import { XAddCommand } from "./xadd";
+import { XLenCommand } from "./xlen";
+
+const client = newHttpClient();
+
+const { newKey, cleanup } = keygen();
+afterAll(cleanup);
+
+describe("XLEN", () => {
+  test("should give size of the stream", async () => {
+    const key = newKey();
+    await new XAddCommand([key, "*", { name: "Jane", surname: "Austen" }]).exec(client);
+    await new XAddCommand([key, "*", { name: "Toni", surname: "Morrison" }]).exec(client);
+
+    await new XAddCommand([key, "*", { name: "Hezarfen", surname: "----" }]).exec(client);
+
+    const res = await new XLenCommand([key]).exec(client);
+
+    expect(res).toBe(3);
+  });
+
+  test("should return 0 when specified key does not exist", async () => {
+    const res = await new XLenCommand(["missing-key"]).exec(client);
+    expect(res).toBe(0);
+  });
+});

package/pkg/commands/xlen.ts

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

package/pkg/commands/xpending.test.ts

@@ -0,0 +1,94 @@
+import { addNewItemToStream, keygen, newHttpClient } from "../test-utils";
+
+import { afterAll, afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { sleep } from "bun";
+import { XGroupCommand } from "./xgroup";
+import { XPendingCommand } from "./xpending";
+import { XReadGroupCommand } from "./xreadgroup";
+
+const client = newHttpClient();
+
+const { newKey, cleanup } = keygen();
+afterAll(cleanup);
+
+describe("XPENDING", () => {
+  const streamKey1 = newKey();
+  const group = newKey();
+  const consumer = newKey();
+
+  beforeEach(async () => {
+    await new XGroupCommand([
+      streamKey1,
+      { type: "CREATE", group, id: "0", options: { MKSTREAM: true } },
+    ]).exec(client);
+    await addNewItemToStream(streamKey1, client);
+
+    await new XReadGroupCommand([group, consumer, streamKey1, ">", { count: 1 }]).exec(client);
+  });
+  afterEach(cleanup);
+
+  test("should get pending messages", async () => {
+    const pending = await new XPendingCommand([streamKey1, group, "-", "+", 10]).exec(client);
+
+    expect(pending).toBeInstanceOf(Array);
+    expect(pending.length).toBeGreaterThan(0);
+  });
+
+  test("should get pending messages with idle time", async () => {
+    await sleep(1000);
+    const pending = await new XPendingCommand([
+      streamKey1,
+      group,
+      "-",
+      "+",
+      10,
+      { idleTime: 500 },
+    ]).exec(client);
+
+    expect(pending).toBeInstanceOf(Array);
+    expect(pending.length).toBeGreaterThan(0);
+  });
+
+  test("should not get pending messages with idle time", async () => {
+    const pending = await new XPendingCommand([
+      streamKey1,
+      group,
+      "-",
+      "+",
+      10,
+      { idleTime: 500 },
+    ]).exec(client);
+    expect(pending).toBeInstanceOf(Array);
+    expect(pending.length).toEqual(0);
+  });
+
+  test("should get specific consumer", async () => {
+    const newConsumer = newKey();
+    await new XReadGroupCommand([group, newConsumer, streamKey1, ">", { count: 1 }]).exec(client);
+
+    const pending = await new XPendingCommand([
+      streamKey1,
+      group,
+      "-",
+      "+",
+      10,
+      {
+        consumer: newConsumer,
+      },
+    ]).exec(client);
+
+    const pending1 = await new XPendingCommand([
+      streamKey1,
+      group,
+      "-",
+      "+",
+      10,
+      {
+        consumer,
+      },
+    ]).exec(client);
+
+    expect(pending.length).toEqual(0);
+    expect(pending1.length).toEqual(1);
+  });
+});

package/pkg/commands/xpending.ts

@@ -0,0 +1,43 @@
+import type { CommandOptions } from "./command";
+import { Command } from "./command";
+
+/**
+ * @see https://redis.io/commands/xpending
+ */
+export class XPendingCommand extends Command<unknown[], unknown[]> {
+  constructor(
+    [key, group, start, end, count, options]: [
+      key: string,
+      group: string,
+      start: string,
+      end: string,
+      count: number,
+      options?: {
+        idleTime?: number;
+        consumer?: string | string[];
+      },
+    ],
+    opts?: CommandOptions<unknown[], unknown[]>
+  ) {
+    const consumers =
+      options?.consumer === undefined
+        ? []
+        : Array.isArray(options.consumer)
+          ? [...options.consumer]
+          : [options.consumer];
+
+    super(
+      [
+        "XPENDING",
+        key,
+        group,
+        ...(options?.idleTime ? ["IDLE", options.idleTime] : []),
+        start,
+        end,
+        count,
+        ...consumers,
+      ],
+      opts
+    );
+  }
+}

package/pkg/commands/xrange.test.ts

@@ -0,0 +1,69 @@
+import { keygen, newHttpClient, randomID } from "../test-utils";
+
+import { afterAll, describe, expect, test } from "bun:test";
+import { XAddCommand } from "./xadd";
+import { XRangeCommand } from "./xrange";
+
+const client = newHttpClient();
+
+const { newKey, cleanup } = keygen();
+afterAll(cleanup);
+
+describe("without options", () => {
+  test("returns the set", async () => {
+    const key = newKey();
+    const field1 = "field1";
+    const member1 = randomID();
+
+    const field2 = "field2";
+    const member2 = randomID();
+
+    await new XAddCommand([key, "*", { [field1]: member1, [field2]: member2 }]).exec(client);
+
+    const res = await new XRangeCommand([key, "-", "+"]).exec(client);
+    expect(Object.keys(res).length).toBe(1);
+    expect(Object.values(res)[0]).toEqual({
+      [field1]: member1,
+      [field2]: member2,
+    });
+  });
+});
+
+describe("limit", () => {
+  test("returns the only the first one", async () => {
+    const key = newKey();
+    const field1 = "field1";
+    const member1 = randomID();
+
+    const field2 = "field2";
+    const member2 = randomID();
+
+    await new XAddCommand([key, "*", { [field1]: member1 }]).exec(client);
+    await new XAddCommand([key, "*", { [field2]: member2 }]).exec(client);
+
+    const res = await new XRangeCommand([key, "-", "+", 1]).exec(client);
+    expect(Object.keys(res).length).toBe(1);
+    expect(Object.values(res)[0]).toEqual({
+      [field1]: member1,
+    });
+  });
+});
+
+describe("many fields", () => {
+  test("returns all fields", async () => {
+    const key = newKey();
+
+    const fields: Record<string, string> = {};
+
+    for (let i = 1; i <= 10; i++) {
+      const field = randomID();
+      const value = randomID();
+      fields[field] = value;
+      const id = await new XAddCommand([key, "*", fields]).exec(client);
+
+      const res = await new XRangeCommand([key, "-", "+"]).exec(client);
+      expect(Object.keys(res).length).toBe(i);
+      expect(res[id]).toEqual(fields);
+    }
+  });
+});

package/pkg/commands/xrange.ts

@@ -0,0 +1,48 @@
+import type { CommandOptions } from "./command";
+import { Command } from "./command";
+
+function deserialize<TData extends Record<string, Record<string, unknown>>>(
+  result: [string, string[]][]
+): TData {
+  const obj: Record<string, Record<string, unknown>> = {};
+  for (const e of result) {
+    while (e.length >= 2) {
+      const streamId = e.shift() as string;
+      const entries = e.shift()!;
+
+      if (!(streamId in obj)) {
+        obj[streamId] = {};
+      }
+      while (entries.length >= 2) {
+        const field = (entries as string[]).shift()!;
+        const value = (entries as string[]).shift()!;
+
+        try {
+          obj[streamId][field] = JSON.parse(value);
+        } catch {
+          obj[streamId][field] = value;
+        }
+      }
+    }
+  }
+  return obj as TData;
+}
+
+export class XRangeCommand<TData extends Record<string, Record<string, unknown>>> extends Command<
+  string[][],
+  TData
+> {
+  constructor(
+    [key, start, end, count]: [key: string, start: string, end: string, count?: number],
+    opts?: CommandOptions<unknown[], TData[]>
+  ) {
+    const command: unknown[] = ["XRANGE", key, start, end];
+    if (typeof count === "number") {
+      command.push("COUNT", count);
+    }
+    super(command, {
+      deserialize: (result) => deserialize<any>(result as any),
+      ...opts,
+    });
+  }
+}