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

package/pkg/commands/expire.test.ts

@@ -0,0 +1,119 @@
+import { keygen, newHttpClient, randomID } from "../test-utils";
+
+import { afterAll, describe, expect, test } from "bun:test";
+import { ExpireCommand } from "./expire";
+import { GetCommand } from "./get";
+import { SetCommand } from "./set";
+const client = newHttpClient();
+
+const { newKey, cleanup } = keygen();
+afterAll(cleanup);
+
+test("expires a key correctly", async () => {
+  const key = newKey();
+  const value = randomID();
+  await new SetCommand([key, value]).exec(client);
+  const res = await new ExpireCommand([key, 1]).exec(client);
+  expect(res).toEqual(1);
+  await new Promise((res) => setTimeout(res, 2000));
+  const res2 = await new GetCommand([key]).exec(client);
+
+  expect(res2).toEqual(null);
+});
+
+describe("NX", () => {
+  test("should set expiry only when the key has no expiry", async () => {
+    const key = newKey();
+    const value = randomID();
+    await new SetCommand([key, value]).exec(client);
+    const res = await new ExpireCommand([key, 1, "NX"]).exec(client);
+    expect(res).toEqual(1);
+    await new Promise((res) => setTimeout(res, 2000));
+    const res2 = await new GetCommand([key]).exec(client);
+
+    expect(res2).toEqual(null);
+  });
+
+  test("should not set expiry when the key has expiry", async () => {
+    const key = newKey();
+    const value = randomID();
+    await new SetCommand([key, value, { ex: 1000 }]).exec(client);
+    const res = await new ExpireCommand([key, 1, "NX"]).exec(client);
+    expect(res).toEqual(0);
+  });
+});
+
+describe("XX", () => {
+  test(
+    "should set expiry only when the key has an existing expiry",
+    async () => {
+      const key = newKey();
+      const value = randomID();
+      await new SetCommand([key, value, { ex: 1 }]).exec(client);
+      const res = await new ExpireCommand([key, 5, "XX"]).exec(client);
+      expect(res).toEqual(1);
+      await new Promise((res) => setTimeout(res, 6000));
+      const res2 = await new GetCommand([key]).exec(client);
+      expect(res2).toEqual(null);
+    },
+    { timeout: 10_000 }
+  );
+
+  test("should not set expiry when the key does not have an existing expiry", async () => {
+    const key = newKey();
+    const value = randomID();
+    await new SetCommand([key, value]).exec(client);
+    const res = await new ExpireCommand([key, 5, "XX"]).exec(client);
+    expect(res).toEqual(0);
+  });
+});
+
+describe("GT", () => {
+  test(
+    "should set expiry only when the new expiry is greater than current one",
+    async () => {
+      const key = newKey();
+      const value = randomID();
+      await new SetCommand([key, value, { ex: 1 }]).exec(client);
+      const res = await new ExpireCommand([key, 5, "GT"]).exec(client);
+      expect(res).toEqual(1);
+      await new Promise((res) => setTimeout(res, 6000));
+      const res2 = await new GetCommand([key]).exec(client);
+      expect(res2).toEqual(null);
+    },
+    { timeout: 10_000 }
+  );
+
+  test("should not set expiry when the new expiry is not greater than current one", async () => {
+    const key = newKey();
+    const value = randomID();
+    await new SetCommand([key, value, { ex: 10 }]).exec(client);
+    const res = await new ExpireCommand([key, 5, "GT"]).exec(client);
+    expect(res).toEqual(0);
+  });
+});
+
+describe("LT", () => {
+  test(
+    "should set expiry only when the new expiry is less than current one",
+    async () => {
+      const key = newKey();
+      const value = randomID();
+      await new SetCommand([key, value, { ex: 5 }]).exec(client);
+      const res = await new ExpireCommand([key, 3, "LT"]).exec(client);
+      expect(res).toEqual(1);
+      await new Promise((res) => setTimeout(res, 4000));
+      const res2 = await new GetCommand([key]).exec(client);
+      expect(res2).toEqual(null);
+    },
+    { timeout: 10_000 }
+  );
+
+  test("should not set expiry when the new expiry is not less than current one", async () => {
+    const key = newKey();
+    const value = randomID();
+    await new SetCommand([key, value, { ex: 10 }]).exec(client);
+    const res = await new ExpireCommand([key, 20, "LT"]).exec(client);
+    expect(res).toEqual(0);
+  });
+});

package/pkg/commands/expire.ts

@@ -0,0 +1,12 @@
+import type { CommandOptions } from "./command";
+import { Command } from "./command";
+
+type ExpireOptions = "NX" | "nx" | "XX" | "xx" | "GT" | "gt" | "LT" | "lt";
+export class ExpireCommand extends Command<"0" | "1", 0 | 1> {
+  constructor(
+    cmd: [key: string, seconds: number, option?: ExpireOptions],
+    opts?: CommandOptions<"0" | "1", 0 | 1>
+  ) {
+    super(["expire", ...cmd.filter(Boolean)], opts);
+  }
+}

package/pkg/commands/expireat.test.ts

@@ -0,0 +1,25 @@
+import { keygen, newHttpClient, randomID } from "../test-utils";
+
+import { afterAll, describe, expect, test } from "bun:test";
+import { SetCommand } from "./set";
+
+import { ExpireAtCommand } from "./expireat";
+import { GetCommand } from "./get";
+const client = newHttpClient();
+
+const { newKey, cleanup } = keygen();
+afterAll(cleanup);
+
+describe("without options", () => {
+  test("expires the key", async () => {
+    const key = newKey();
+    const value = randomID();
+    await new SetCommand([key, value]).exec(client);
+
+    const res = await new ExpireAtCommand([key, 1]).exec(client);
+    expect(res).toEqual(1);
+    await new Promise((res) => setTimeout(res, 2000));
+    const res2 = await new GetCommand([key]).exec(client);
+    expect(res2).toEqual(null);
+  });
+});

package/pkg/commands/expireat.ts

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

package/pkg/commands/flushall.test.ts

@@ -0,0 +1,18 @@
+import { newHttpClient } from "../test-utils";
+import { FlushAllCommand } from "./flushall";
+
+import { describe, expect, test } from "bun:test";
+const client = newHttpClient();
+
+describe("without options", () => {
+  test("flushes the db", async () => {
+    const res = await new FlushAllCommand().exec(client);
+    expect(res).toEqual("OK");
+  });
+});
+describe("async", () => {
+  test("flushes the db", async () => {
+    const res = await new FlushAllCommand([{ async: true }]).exec(client);
+    expect(res).toEqual("OK");
+  });
+});

package/pkg/commands/flushall.ts

@@ -0,0 +1,14 @@
+import type { CommandOptions } from "./command";
+import { Command } from "./command";
+/**
+ * @see https://redis.io/commands/flushall
+ */
+export class FlushAllCommand extends Command<"OK", "OK"> {
+  constructor(args?: [{ async?: boolean }], opts?: CommandOptions<"OK", "OK">) {
+    const command = ["flushall"];
+    if (args && args.length > 0 && args[0].async) {
+      command.push("async");
+    }
+    super(command, opts);
+  }
+}

package/pkg/commands/flushdb.test.ts

@@ -0,0 +1,17 @@
+import { describe, expect, test } from "bun:test";
+import { newHttpClient } from "../test-utils";
+import { FlushDBCommand } from "./flushdb";
+const client = newHttpClient();
+
+describe("without options", () => {
+  test("flushes the db", async () => {
+    const res = await new FlushDBCommand([]).exec(client);
+    expect(res).toEqual("OK");
+  });
+});
+describe("async", () => {
+  test("flushes the db", async () => {
+    const res = await new FlushDBCommand([{ async: true }]).exec(client);
+    expect(res).toEqual("OK");
+  });
+});

package/pkg/commands/flushdb.ts

@@ -0,0 +1,14 @@
+import type { CommandOptions } from "./command";
+import { Command } from "./command";
+/**
+ * @see https://redis.io/commands/flushdb
+ */
+export class FlushDBCommand extends Command<"OK", "OK"> {
+  constructor([opts]: [opts?: { async?: boolean }], cmdOpts?: CommandOptions<"OK", "OK">) {
+    const command = ["flushdb"];
+    if (opts?.async) {
+      command.push("async");
+    }
+    super(command, cmdOpts);
+  }
+}

package/pkg/commands/geo_add.test.ts

@@ -0,0 +1,202 @@
+import { keygen, newHttpClient, randomID } from "../test-utils";
+
+import { afterAll, describe, expect, test } from "bun:test";
+
+import type { GeoMember } from "./geo_add";
+import { GeoAddCommand } from "./geo_add";
+
+const client = newHttpClient();
+
+const { newKey, cleanup } = keygen();
+afterAll(cleanup);
+
+type Coordinate = {
+  latitude: number;
+  longitude: number;
+};
+
+function generateRandomPoint(radius = 100): Coordinate {
+  const center = { lat: 14.23, lng: 23.12 };
+
+  const x0 = center.lng;
+  const y0 = center.lat;
+  // Convert Radius from meters to degrees.
+  const rd = radius / 111_300;
+
+  const u = Math.random();
+  const v = Math.random();
+
+  const w = rd * Math.sqrt(u);
+  const t = 2 * Math.PI * v;
+  const x = w * Math.cos(t);
+  const y = w * Math.sin(t);
+
+  const xp = x / Math.cos(y0);
+
+  // Resulting point.
+  return { latitude: y + y0, longitude: xp + x0 };
+}
+
+function getTestMember(): GeoMember<Record<string, number>> {
+  const member = randomID();
+
+  return {
+    ...generateRandomPoint(),
+    member: { [member]: Math.random() * 1000 },
+  };
+}
+
+describe("without options", () => {
+  test("adds the geo member", async () => {
+    const key = newKey();
+    const member = randomID();
+
+    const res = await new GeoAddCommand([key, { ...generateRandomPoint(), member }]).exec(client);
+    expect(res).toEqual(1);
+  });
+
+  test("adds multiple members", async () => {
+    const key = newKey();
+
+    const res = await new GeoAddCommand([
+      key,
+      { ...generateRandomPoint(), member: randomID() },
+      { ...generateRandomPoint(), member: randomID() },
+      { ...generateRandomPoint(), member: randomID() },
+      { ...generateRandomPoint(), member: randomID() },
+    ]).exec(client);
+
+    expect(res).toEqual(4);
+  });
+
+  test("adds the geo member with member as object", async () => {
+    const key = newKey();
+
+    const res = await new GeoAddCommand<Record<string, number>>([
+      key,
+      getTestMember(),
+      getTestMember(),
+      getTestMember(),
+      getTestMember(),
+      getTestMember(),
+      getTestMember(),
+      getTestMember(),
+    ]).exec(client);
+
+    expect(res).toEqual(7);
+  });
+});
+
+describe("xx", () => {
+  describe("when the member exists", () => {
+    test("updates the member", async () => {
+      const key = newKey();
+      const member = getTestMember();
+
+      // Create member.
+      await new GeoAddCommand<Record<string, number>>([key, member]).exec(client);
+
+      const updatedMember = { ...generateRandomPoint(), member: member.member };
+
+      const response = await new GeoAddCommand<Record<string, number>>([
+        key,
+        { xx: true },
+        updatedMember,
+      ]).exec(client);
+
+      expect(response).toEqual(0);
+    });
+  });
+  describe("when the member does not exist", () => {
+    test("does nothing", async () => {
+      const key = newKey();
+      const member = getTestMember();
+
+      // Create member.
+      await new GeoAddCommand<Record<string, number>>([key, { xx: true }, member]).exec(client);
+
+      const { result } = await client.request({
+        body: ["geopos", key, JSON.stringify(member.member)],
+      });
+
+      expect(result).toEqual([null]);
+    });
+  });
+});
+
+describe("nx", () => {
+  describe("when the member exists", () => {
+    test("does not update the member", async () => {
+      const key = newKey();
+      const member = getTestMember();
+
+      // Create member.
+      await new GeoAddCommand<Record<string, number>>([key, member]).exec(client);
+
+      // Get member position
+      const { result } = await client.request({
+        body: ["geopos", key, JSON.stringify(member.member)],
+      });
+
+      const updatedMember = { ...generateRandomPoint(), member: member.member };
+
+      // Update member with nx command.
+      const response = await new GeoAddCommand<Record<string, number>>([
+        key,
+        { nx: true },
+        updatedMember,
+      ]).exec(client);
+
+      expect(response).toEqual(0);
+
+      // Get member position again. And assert it didn't change
+      const { result: updatedResult } = await client.request({
+        body: ["geopos", key, JSON.stringify(member.member)],
+      });
+
+      expect(result).toEqual(updatedResult);
+    });
+  });
+
+  describe("when the member does not exist", () => {
+    test("adds new member", async () => {
+      const key = newKey();
+      const member = getTestMember();
+
+      // Create member.
+      const response = await new GeoAddCommand<Record<string, number>>([
+        key,
+        { nx: true },
+        member,
+      ]).exec(client);
+
+      expect(response).toEqual(1);
+    });
+  });
+});
+
+describe("ch", () => {
+  test("returns the number of changed elements", async () => {
+    const key = newKey();
+    const member = getTestMember();
+    const member2 = getTestMember();
+    const member3 = getTestMember();
+
+    // Create member.
+    await new GeoAddCommand<Record<string, number>>([key, member, member2, member3]).exec(client);
+
+    const updatedMember2 = { ...member2, ...generateRandomPoint() };
+    const updatedMember3 = { ...member3, ...generateRandomPoint() };
+
+    // Create members again, but this time change members 2 and 3
+    const response = await new GeoAddCommand<Record<string, number>>([
+      key,
+      { ch: true },
+      member,
+      updatedMember2,
+      updatedMember3,
+    ]).exec(client);
+
+    expect(response).toEqual(2);
+  });
+});

package/pkg/commands/geo_add.ts

@@ -0,0 +1,54 @@
+import type { CommandOptions } from "./command";
+import { Command } from "./command";
+
+export type GeoAddCommandOptions =
+  | {
+      nx?: boolean;
+      xx?: never;
+    }
+  | ({
+      nx?: never;
+      xx?: boolean;
+    } & { ch?: boolean });
+
+export type GeoMember<TMemberType> = {
+  latitude: number;
+  longitude: number;
+  member: TMemberType;
+};
+
+/**
+ * @see https://redis.io/commands/geoadd
+ */
+export class GeoAddCommand<TMemberType = string> extends Command<number | null, number | null> {
+  constructor(
+    [key, arg1, ...arg2]: [
+      string,
+      GeoMember<TMemberType> | GeoAddCommandOptions,
+      ...GeoMember<TMemberType>[],
+    ],
+    opts?: CommandOptions<number | null, number | null>
+  ) {
+    const command: unknown[] = ["geoadd", key];
+
+    if ("nx" in arg1 && arg1.nx) {
+      command.push("nx");
+    } else if ("xx" in arg1 && arg1.xx) {
+      command.push("xx");
+    }
+
+    if ("ch" in arg1 && arg1.ch) {
+      command.push("ch");
+    }
+
+    if ("latitude" in arg1 && arg1.latitude) {
+      command.push(arg1.longitude, arg1.latitude, arg1.member);
+    }
+
+    command.push(
+      ...arg2.flatMap(({ latitude, longitude, member }) => [longitude, latitude, member])
+    );
+
+    super(command, opts);
+  }
+}

package/pkg/commands/geo_dist.test.ts

@@ -0,0 +1,79 @@
+import { expect, test } from "bun:test";
+import { newHttpClient } from "../test-utils";
+
+import { GeoAddCommand } from "./geo_add";
+import { GeoDistCommand } from "./geo_dist";
+
+const client = newHttpClient();
+
+test("should return distance successfully in meters", async () => {
+  await new GeoAddCommand([
+    "Sicily",
+    { longitude: 13.361_389, latitude: 38.115_556, member: "Palermo" },
+    { longitude: 15.087_269, latitude: 37.502_669, member: "Catania" },
+  ]).exec(client);
+
+  const res = await new GeoDistCommand(["Sicily", "Palermo", "Catania"]).exec(client);
+
+  expect(res).toEqual(166_274.1516);
+});
+
+test("should return distance for object members", async () => {
+  await new GeoAddCommand([
+    "Sicily",
+    { longitude: 13.361_389, latitude: 38.115_556, member: { name: "Palermo" } },
+    { longitude: 15.087_269, latitude: 37.502_669, member: { name: "Catania" } },
+  ]).exec(client);
+
+  const res = await new GeoDistCommand([
+    "Sicily",
+    { name: "Palermo" },
+    {
+      name: "Catania",
+    },
+  ]).exec(client);
+
+  expect(res).toEqual(166_274.1516);
+});
+
+test("should return distance successfully in kilometers", async () => {
+  await new GeoAddCommand([
+    "Sicily",
+    { longitude: 13.361_389, latitude: 38.115_556, member: "Palermo" },
+    { longitude: 15.087_269, latitude: 37.502_669, member: "Catania" },
+  ]).exec(client);
+
+  const res = await new GeoDistCommand(["Sicily", "Palermo", "Catania", "KM"]).exec(client);
+
+  expect(res).toEqual(166.2742);
+});
+
+test("should return distance successfully in miles", async () => {
+  await new GeoAddCommand([
+    "Sicily",
+    { longitude: 13.361_389, latitude: 38.115_556, member: "Palermo" },
+    { longitude: 15.087_269, latitude: 37.502_669, member: "Catania" },
+  ]).exec(client);
+
+  const res = await new GeoDistCommand(["Sicily", "Palermo", "Catania", "MI"]).exec(client);
+
+  expect(res).toEqual(103.3182);
+});
+
+test("should return distance successfully in feet", async () => {
+  await new GeoAddCommand([
+    "Sicily",
+    { longitude: 13.361_389, latitude: 38.115_556, member: "Palermo" },
+    { longitude: 15.087_269, latitude: 37.502_669, member: "Catania" },
+  ]).exec(client);
+
+  const res = await new GeoDistCommand(["Sicily", "Palermo", "Catania", "FT"]).exec(client);
+
+  expect(res?.toString()).toEqual("545518.8700");
+});
+
+test("should return null if members doesn't exist", async () => {
+  const res = await new GeoDistCommand(["Sicily", "FOO", "BAR"]).exec(client);
+
+  expect(res).toEqual(null);
+});

package/pkg/commands/geo_dist.ts

@@ -0,0 +1,19 @@
+import type { CommandOptions } from "./command";
+import { Command } from "./command";
+
+/**
+ * @see https://redis.io/commands/geodist
+ */
+export class GeoDistCommand<TMemberType = string> extends Command<number | null, number | null> {
+  constructor(
+    [key, member1, member2, unit = "M"]: [
+      key: string,
+      member1: TMemberType,
+      member2: TMemberType,
+      unit?: "M" | "KM" | "FT" | "MI",
+    ],
+    opts?: CommandOptions<number | null, number | null>
+  ) {
+    super(["GEODIST", key, member1, member2, unit], opts);
+  }
+}

package/pkg/commands/geo_hash.test.ts

@@ -0,0 +1,49 @@
+import { describe, expect, test } from "bun:test";
+import { newHttpClient } from "../test-utils.ts";
+
+import { GeoAddCommand } from "./geo_add.ts";
+import { GeoHashCommand } from "./geo_hash.ts";
+
+const client = newHttpClient();
+
+describe("GEOHASH tests", () => {
+  test("should accept two member array and return valid hash", async () => {
+    const key = "Sicily";
+    const members = ["Palermo", "Catania"];
+    await new GeoAddCommand([
+      key,
+      { longitude: 13.361_389, latitude: 38.115_556, member: members[0] },
+      { longitude: 15.087_269, latitude: 37.502_669, member: members[1] },
+    ]).exec(client);
+
+    const response = await new GeoHashCommand([key, members]).exec(client);
+    expect(response.length).toEqual(2);
+  });
+
+  test("should accept three different string members and return valid hash", async () => {
+    const key = "Sicily";
+    const members = ["Palermo", "Catania", "Marsala"];
+    await new GeoAddCommand([
+      key,
+      { longitude: 13.361_389, latitude: 38.115_556, member: members[0] },
+      { longitude: 15.087_269, latitude: 37.502_669, member: members[1] },
+      { longitude: 12.4372, latitude: 37.7981, member: members[2] },
+    ]).exec(client);
+
+    const response = await new GeoHashCommand([key, "Palermo", "Catania", "Marsala"]).exec(client);
+    expect(response.length).toEqual(3);
+  });
+
+  test("should accept two objects as members", async () => {
+    const key = "Sicily";
+    const members = [{ name: "Palermo" }, { name: "Catania" }];
+    await new GeoAddCommand([
+      key,
+      { longitude: 13.361_389, latitude: 38.115_556, member: members[0] },
+      { longitude: 15.087_269, latitude: 37.502_669, member: members[1] },
+    ]).exec(client);
+
+    const response = await new GeoHashCommand([key, members]).exec(client);
+    expect(response.length).toBe(2);
+  });
+});

package/pkg/commands/geo_hash.ts

@@ -0,0 +1,23 @@
+import type { CommandOptions } from "./command.ts";
+import { Command } from "./command.ts";
+
+/**
+ * @see https://redis.io/commands/geohash
+ */
+export class GeoHashCommand<TMember = string> extends Command<
+  (string | null)[],
+  (string | null)[]
+> {
+  constructor(
+    cmd: [string, ...TMember[]],
+    opts?: CommandOptions<(string | null)[], (string | null)[]>
+  ) {
+    const [key] = cmd;
+    // Check if the second argument is an array of strings (members).
+    // If it is, use it directly; if not, it means the members were passed individually,
+    // so we slice the cmd from the second element onwards to get the members.
+    const members = Array.isArray(cmd[1]) ? cmd[1] : cmd.slice(1);
+
+    super(["GEOHASH", key, ...members], opts);
+  }
+}