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

package/pkg/commands/zunion.test.ts

@@ -0,0 +1,251 @@
+import { keygen, newHttpClient, randomID } from "../test-utils";
+
+import { afterAll, describe, expect, test } from "bun:test";
+
+import { ZAddCommand } from "./zadd";
+import { ZUnionCommand } from "./zunion";
+
+const client = newHttpClient();
+
+const { newKey, cleanup } = keygen();
+afterAll(cleanup);
+
+describe("command format", () => {
+  describe("without options", () => {
+    test("builds the correct command", () => {
+      expect(new ZUnionCommand([1, "key"]).command).toEqual(["zunion", 1, "key"]);
+    });
+  });
+  describe("with multiple keys", () => {
+    test("builds the correct command", () => {
+      expect(new ZUnionCommand([2, ["key1", "key2"]]).command).toEqual([
+        "zunion",
+        2,
+        "key1",
+        "key2",
+      ]);
+    });
+  });
+  describe("with single weight", () => {
+    test("builds the correct command", () => {
+      expect(new ZUnionCommand([1, "key", { weight: 4 }]).command).toEqual([
+        "zunion",
+        1,
+        "key",
+        "weights",
+        4,
+      ]);
+    });
+  });
+  describe("with multiple weights", () => {
+    test("builds the correct command", () => {
+      expect(
+        new ZUnionCommand([
+          2,
+          ["key1", "key2"],
+          {
+            weights: [2, 3],
+          },
+        ]).command
+      ).toEqual(["zunion", 2, "key1", "key2", "weights", 2, 3]);
+    });
+    describe("with aggregate", () => {
+      describe("sum", () => {
+        test("builds the correct command", () => {
+          expect(
+            new ZUnionCommand([
+              1,
+              "key",
+              {
+                aggregate: "sum",
+              },
+            ]).command
+          ).toEqual(["zunion", 1, "key", "aggregate", "sum"]);
+        });
+      });
+      describe("min", () => {
+        test("builds the correct command", () => {
+          expect(
+            new ZUnionCommand([
+              1,
+              "key",
+              {
+                aggregate: "min",
+              },
+            ]).command
+          ).toEqual(["zunion", 1, "key", "aggregate", "min"]);
+        });
+      });
+      describe("max", () => {
+        test("builds the correct command", () => {
+          expect(
+            new ZUnionCommand([
+              1,
+              "key",
+              {
+                aggregate: "max",
+              },
+            ]).command
+          ).toEqual(["zunion", 1, "key", "aggregate", "max"]);
+        });
+      });
+    });
+    describe("complex", () => {
+      test("builds the correct command", () => {
+        expect(
+          new ZUnionCommand([
+            2,
+            ["key1", "key2"],
+            {
+              weights: [4, 2],
+              aggregate: "max",
+            },
+          ]).command
+        ).toEqual(["zunion", 2, "key1", "key2", "weights", 4, 2, "aggregate", "max"]);
+      });
+    });
+  });
+});
+
+describe("without options", () => {
+  test("returns the union", async () => {
+    const key1 = newKey();
+    const key2 = newKey();
+    const score1 = 1;
+    const member1 = randomID();
+    const score2 = 2;
+    const member2 = randomID();
+
+    await new ZAddCommand([key1, { score: score1, member: member1 }]).exec(client);
+    await new ZAddCommand([key2, { score: score2, member: member2 }]).exec(client);
+
+    const res = await new ZUnionCommand([2, [key1, key2]]).exec(client);
+
+    expect(res.length).toBe(2);
+    expect(res.sort()).toEqual([member1, member2].sort());
+  });
+});
+
+describe("with weights", () => {
+  test("returns the set", async () => {
+    const key1 = newKey();
+    const key2 = newKey();
+    const score1 = 1;
+    const member1 = randomID();
+    const score2 = 2;
+    const member2 = randomID();
+
+    await new ZAddCommand([key1, { score: score1, member: member1 }]).exec(client);
+
+    await new ZAddCommand([key2, { score: score2, member: member2 }]).exec(client);
+
+    const res = await new ZUnionCommand([
+      2,
+      [key1, key2],
+      {
+        weights: [2, 3],
+      },
+    ]).exec(client);
+
+    expect(res.length).toBe(2);
+  });
+});
+
+describe("aggregate", () => {
+  describe("sum", () => {
+    test("returns the set", async () => {
+      const key1 = newKey();
+      const key2 = newKey();
+      const score1 = 1;
+      const member1 = randomID();
+      const score2 = 2;
+      const member2 = randomID();
+
+      await new ZAddCommand([key1, { score: score1, member: member1 }]).exec(client);
+      await new ZAddCommand([key2, { score: score2, member: member2 }]).exec(client);
+
+      const res = await new ZUnionCommand([
+        2,
+        [key1, key2],
+        {
+          aggregate: "sum",
+        },
+      ]).exec(client);
+
+      expect(Array.isArray(res)).toBe(true);
+      expect(res.length).toBe(2);
+    });
+  });
+  describe("min", () => {
+    test("returns the set ", async () => {
+      const key1 = newKey();
+      const key2 = newKey();
+      const score1 = 1;
+      const member1 = randomID();
+      const score2 = 2;
+      const member2 = randomID();
+
+      await new ZAddCommand([key1, { score: score1, member: member1 }]).exec(client);
+      await new ZAddCommand([key2, { score: score2, member: member2 }]).exec(client);
+
+      const res = await new ZUnionCommand([
+        2,
+        [key1, key2],
+        {
+          aggregate: "min",
+        },
+      ]).exec(client);
+      expect(res.length).toBe(2);
+    });
+  });
+  describe("max", () => {
+    test("returns the set ", async () => {
+      const key1 = newKey();
+      const key2 = newKey();
+      const score1 = 1;
+      const member1 = randomID();
+      const score2 = 2;
+      const member2 = randomID();
+
+      await new ZAddCommand([key1, { score: score1, member: member1 }]).exec(client);
+      await new ZAddCommand([key2, { score: score2, member: member2 }]).exec(client);
+
+      const res = await new ZUnionCommand([
+        2,
+        [key1, key2],
+        {
+          aggregate: "max",
+        },
+      ]).exec(client);
+      expect(res.length).toBe(2);
+    });
+  });
+});
+
+describe("withscores", () => {
+  test("returns the set", async () => {
+    const key1 = newKey();
+    const score1 = 1;
+    const member1 = randomID();
+
+    const key2 = newKey();
+    const member2 = randomID();
+    const score2 = 5;
+
+    await new ZAddCommand([key1, { score: score1, member: member1 }]).exec(client);
+
+    await new ZAddCommand([key2, { score: score2, member: member2 }]).exec(client);
+
+    const res = await new ZUnionCommand([
+      2,
+      [key1, key2],
+      {
+        withScores: true,
+      },
+    ]).exec(client);
+
+    expect(res.length).toBe(4);
+    expect(res[0]).toEqual(member1);
+    expect(res[1]).toEqual(score1);
+  });
+});

package/pkg/commands/zunion.ts

@@ -0,0 +1,54 @@
+import type { CommandOptions } from "./command";
+import { Command } from "./command";
+
+export type ZUnionCommandOptions = {
+  withScores?: boolean;
+  aggregate?: "sum" | "min" | "max";
+} & (
+  | { weight: number; weights?: never }
+  | { weight?: never; weights: number[] }
+  | { weight?: never; weights?: never }
+);
+
+/**
+ * @see https://redis.io/commands/zunion
+ */
+export class ZUnionCommand<TData extends unknown[]> extends Command<string[], TData> {
+  constructor(
+    cmd: [numKeys: 1, key: string, opts?: ZUnionCommandOptions],
+    cmdOpts?: CommandOptions<string[], TData>
+  );
+  constructor(
+    cmd: [numKeys: number, keys: string[], opts?: ZUnionCommandOptions],
+    cmdOpts?: CommandOptions<string[], TData>
+  );
+  constructor(
+    [numKeys, keyOrKeys, opts]: [
+      numKeys: number,
+      keyOrKeys: string | string[],
+      opts?: ZUnionCommandOptions,
+    ],
+    cmdOpts?: CommandOptions<string[], TData>
+  ) {
+    const command: unknown[] = ["zunion", numKeys];
+    if (Array.isArray(keyOrKeys)) {
+      command.push(...keyOrKeys);
+    } else {
+      command.push(keyOrKeys);
+    }
+    if (opts) {
+      if ("weights" in opts && opts.weights) {
+        command.push("weights", ...opts.weights);
+      } else if ("weight" in opts && typeof opts.weight === "number") {
+        command.push("weights", opts.weight);
+      }
+      if ("aggregate" in opts) {
+        command.push("aggregate", opts.aggregate);
+      }
+      if (opts.withScores) {
+        command.push("withscores");
+      }
+    }
+    super(command, cmdOpts);
+  }
+}

package/pkg/commands/zunionstore.test.ts

@@ -0,0 +1,274 @@
+import { keygen, newHttpClient, randomID } from "../test-utils";
+
+import { afterAll, describe, expect, test } from "bun:test";
+
+import { ZAddCommand } from "./zadd";
+import { ZUnionStoreCommand } from "./zunionstore";
+
+const client = newHttpClient();
+
+const { newKey, cleanup } = keygen();
+afterAll(cleanup);
+
+describe("command format", () => {
+  describe("without options", () => {
+    test("builds the correct command", () => {
+      expect(new ZUnionStoreCommand(["destination", 1, "key"]).command).toEqual([
+        "zunionstore",
+        "destination",
+        1,
+        "key",
+      ]);
+    });
+  });
+  describe("with multiple keys", () => {
+    test("builds the correct command", () => {
+      expect(new ZUnionStoreCommand(["destination", 2, ["key1", "key2"]]).command).toEqual([
+        "zunionstore",
+        "destination",
+        2,
+        "key1",
+        "key2",
+      ]);
+    });
+  });
+  describe("with single weight", () => {
+    test("builds the correct command", () => {
+      expect(new ZUnionStoreCommand(["destination", 1, "key", { weight: 4 }]).command).toEqual([
+        "zunionstore",
+        "destination",
+        1,
+        "key",
+        "weights",
+        4,
+      ]);
+    });
+  });
+  describe("with multiple weights", () => {
+    test("builds the correct command", () => {
+      expect(
+        new ZUnionStoreCommand([
+          "destination",
+          2,
+          ["key1", "key2"],
+          {
+            weights: [2, 3],
+          },
+        ]).command
+      ).toEqual(["zunionstore", "destination", 2, "key1", "key2", "weights", 2, 3]);
+    });
+    describe("with aggregate", () => {
+      describe("sum", () => {
+        test("builds the correct command", () => {
+          expect(
+            new ZUnionStoreCommand([
+              "destination",
+              1,
+              "key",
+              {
+                aggregate: "sum",
+              },
+            ]).command
+          ).toEqual(["zunionstore", "destination", 1, "key", "aggregate", "sum"]);
+        });
+      });
+      describe("min", () => {
+        test("builds the correct command", () => {
+          expect(
+            new ZUnionStoreCommand([
+              "destination",
+              1,
+              "key",
+              {
+                aggregate: "min",
+              },
+            ]).command
+          ).toEqual(["zunionstore", "destination", 1, "key", "aggregate", "min"]);
+        });
+      });
+      describe("max", () => {
+        test("builds the correct command", () => {
+          expect(
+            new ZUnionStoreCommand([
+              "destination",
+              1,
+              "key",
+              {
+                aggregate: "max",
+              },
+            ]).command
+          ).toEqual(["zunionstore", "destination", 1, "key", "aggregate", "max"]);
+        });
+      });
+    });
+    describe("complex", () => {
+      test("builds the correct command", () => {
+        expect(
+          new ZUnionStoreCommand([
+            "destination",
+            2,
+            ["key1", "key2"],
+            {
+              weights: [4, 2],
+              aggregate: "max",
+            },
+          ]).command
+        ).toEqual([
+          "zunionstore",
+          "destination",
+          2,
+          "key1",
+          "key2",
+          "weights",
+          4,
+          2,
+          "aggregate",
+          "max",
+        ]);
+      });
+    });
+  });
+});
+
+describe("without options", () => {
+  test("returns the number of elements in the new set ", async () => {
+    const destination = newKey();
+    const key1 = newKey();
+    const key2 = newKey();
+    const score1 = 1;
+    const member1 = randomID();
+    const score2 = 2;
+    const member2 = randomID();
+
+    await new ZAddCommand([key1, { score: score1, member: member1 }]).exec(client);
+    await new ZAddCommand([key2, { score: score2, member: member2 }]).exec(client);
+
+    const res = await new ZUnionStoreCommand([destination, 2, [key1, key2]]).exec(client);
+    expect(res).toEqual(2);
+  });
+});
+
+describe("with weights", () => {
+  describe("single weight", () => {
+    test("returns the number of elements in the new set ", async () => {
+      const destination = newKey();
+      const key1 = newKey();
+      const key2 = newKey();
+      const score1 = 1;
+      const member1 = randomID();
+      const score2 = 2;
+      const member2 = randomID();
+
+      await new ZAddCommand([key1, { score: score1, member: member1 }]).exec(client);
+      await new ZAddCommand([key2, { score: score2, member: member2 }]).exec(client);
+
+      const res = await new ZUnionStoreCommand([
+        destination,
+        2,
+        [key1, key2],
+        {
+          weights: [2, 3],
+        },
+      ]).exec(client);
+      expect(res).toEqual(2);
+    });
+  });
+  describe("multiple weight", () => {
+    test("returns the number of elements in the new set ", async () => {
+      const destination = newKey();
+      const key1 = newKey();
+      const key2 = newKey();
+      const score1 = 1;
+      const member1 = randomID();
+      const score2 = 2;
+      const member2 = randomID();
+
+      await new ZAddCommand([key1, { score: score1, member: member1 }]).exec(client);
+      await new ZAddCommand([key2, { score: score2, member: member2 }]).exec(client);
+
+      const res = await new ZUnionStoreCommand([
+        destination,
+        2,
+        [key1, key2],
+        {
+          weights: [1, 2],
+        },
+      ]).exec(client);
+      expect(res).toEqual(2);
+    });
+  });
+});
+describe("aggregate", () => {
+  describe("sum", () => {
+    test("returns the number of elements in the new set ", async () => {
+      const destination = newKey();
+      const key1 = newKey();
+      const key2 = newKey();
+      const score1 = 1;
+      const member1 = randomID();
+      const score2 = 2;
+      const member2 = randomID();
+
+      await new ZAddCommand([key1, { score: score1, member: member1 }]).exec(client);
+      await new ZAddCommand([key2, { score: score2, member: member2 }]).exec(client);
+
+      const res = await new ZUnionStoreCommand([
+        destination,
+        2,
+        [key1, key2],
+        {
+          aggregate: "sum",
+        },
+      ]).exec(client);
+      expect(res).toEqual(2);
+    });
+  });
+  describe("min", () => {
+    test("returns the number of elements in the new set ", async () => {
+      const destination = newKey();
+      const key1 = newKey();
+      const key2 = newKey();
+      const score1 = 1;
+      const member1 = randomID();
+      const score2 = 2;
+      const member2 = randomID();
+
+      await new ZAddCommand([key1, { score: score1, member: member1 }]).exec(client);
+      await new ZAddCommand([key2, { score: score2, member: member2 }]).exec(client);
+
+      const res = await new ZUnionStoreCommand([
+        destination,
+        2,
+        [key1, key2],
+        {
+          aggregate: "min",
+        },
+      ]).exec(client);
+      expect(res).toEqual(2);
+    });
+  });
+  describe("max", () => {
+    test("returns the number of elements in the new set ", async () => {
+      const destination = newKey();
+      const key1 = newKey();
+      const key2 = newKey();
+      const score1 = 1;
+      const member1 = randomID();
+      const score2 = 2;
+      const member2 = randomID();
+
+      await new ZAddCommand([key1, { score: score1, member: member1 }]).exec(client);
+      await new ZAddCommand([key2, { score: score2, member: member2 }]).exec(client);
+
+      const res = await new ZUnionStoreCommand([
+        destination,
+        2,
+        [key1, key2],
+        {
+          aggregate: "max",
+        },
+      ]).exec(client);
+      expect(res).toEqual(2);
+    });
+  });
+});

package/pkg/commands/zunionstore.ts

@@ -0,0 +1,51 @@
+import type { CommandOptions } from "./command";
+import { Command } from "./command";
+
+export type ZUnionStoreCommandOptions = {
+  aggregate?: "sum" | "min" | "max";
+} & (
+  | { weight: number; weights?: never }
+  | { weight?: never; weights: number[] }
+  | { weight?: never; weights?: never }
+);
+
+/**
+ * @see https://redis.io/commands/zunionstore
+ */
+export class ZUnionStoreCommand extends Command<number, number> {
+  constructor(
+    cmd: [destination: string, numKeys: 1, key: string, opts?: ZUnionStoreCommandOptions],
+    cmdOpts?: CommandOptions<number, number>
+  );
+  constructor(
+    cmd: [destination: string, numKeys: number, keys: string[], opts?: ZUnionStoreCommandOptions],
+    cmdOpts?: CommandOptions<number, number>
+  );
+  constructor(
+    [destination, numKeys, keyOrKeys, opts]: [
+      destination: string,
+      numKeys: number,
+      keyOrKeys: string | string[],
+      opts?: ZUnionStoreCommandOptions,
+    ],
+    cmdOpts?: CommandOptions<number, number>
+  ) {
+    const command: unknown[] = ["zunionstore", destination, numKeys];
+    if (Array.isArray(keyOrKeys)) {
+      command.push(...keyOrKeys);
+    } else {
+      command.push(keyOrKeys);
+    }
+    if (opts) {
+      if ("weights" in opts && opts.weights) {
+        command.push("weights", ...opts.weights);
+      } else if ("weight" in opts && typeof opts.weight === "number") {
+        command.push("weights", opts.weight);
+      }
+      if ("aggregate" in opts) {
+        command.push("aggregate", opts.aggregate);
+      }
+    }
+    super(command, cmdOpts);
+  }
+}

package/pkg/error.ts

@@ -0,0 +1,18 @@
+/**
+ * Result of a bad request to upstash
+ */
+export class UpstashError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = "UpstashError";
+  }
+}
+
+export class UrlError extends Error {
+  constructor(url: string) {
+    super(
+      `Upstash Redis client was passed an invalid URL. You should pass the URL together with https. Received: "${url}". `
+    );
+    this.name = "UrlError";
+  }
+}