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

package/pkg/commands/geo_pos.test.ts

@@ -0,0 +1,60 @@
+import { describe, expect, test } from "bun:test";
+import { newHttpClient } from "../test-utils";
+import { GeoAddCommand } from "./geo_add";
+import { GeoPosCommand } from "./geo_pos";
+
+const client = newHttpClient();
+
+describe("GEOPOS tests", () => {
+  test("should swallow non-existing member and return only the valid ones", 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 GeoPosCommand([key, [...members, "FooBar"]]).exec(client);
+    expect(response.length).toEqual(3);
+  });
+
+  test("should return three valid positions", 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 GeoPosCommand([key, members]).exec(client);
+
+    expect(response.every(Boolean)).toEqual(true);
+  });
+
+  test("should return empty array due to null value FooBar", async () => {
+    const key = "Sicily";
+    const members = ["Palermo"];
+    await new GeoAddCommand([
+      key,
+      { longitude: 13.361_389, latitude: 38.115_556, member: members[0] },
+    ]).exec(client);
+    const response = await new GeoPosCommand([key, "FooBar"]).exec(client);
+    expect(response).toEqual([]);
+  });
+
+  test("should work with object members", async () => {
+    const key = "Sicily";
+    const members = [{ name: "Palermo" }, { name: "Catania" }, { name: "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 GeoPosCommand([key, [...members, "FooBar"]]).exec(client);
+    expect(response.length).toEqual(3);
+  });
+});

package/pkg/commands/geo_pos.ts

@@ -0,0 +1,39 @@
+import type { CommandOptions } from "./command.ts";
+import { Command } from "./command.ts";
+
+type Coordinates = {
+  lng: number;
+  lat: number;
+};
+
+/**
+ * @see https://redis.io/commands/geopos
+ */
+export class GeoPosCommand<TMember = string> extends Command<(string | null)[][], Coordinates[]> {
+  constructor(
+    cmd: [string, ...(TMember[] | TMember[])],
+    opts?: CommandOptions<(string | null)[][], Coordinates[]>
+  ) {
+    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(["GEOPOS", key, ...members], {
+      deserialize: (result) => transform(result),
+      ...opts,
+    });
+  }
+}
+
+function transform(result: (string | null)[][]): Coordinates[] {
+  const final: Coordinates[] = [];
+  for (const pos of result) {
+    if (!pos?.[0] || !pos?.[1]) {
+      continue;
+    }
+    final.push({ lng: Number.parseFloat(pos[0]), lat: Number.parseFloat(pos[1]) });
+  }
+  return final;
+}

package/pkg/commands/geo_search.test.ts

@@ -0,0 +1,197 @@
+import { afterAll, describe, expect, test } from "bun:test";
+import { keygen, newHttpClient } from "../test-utils.ts";
+
+import { GeoAddCommand } from "./geo_add.ts";
+import { GeoSearchCommand } from "./geo_search.ts";
+
+const client = newHttpClient();
+const { newKey, cleanup } = keygen();
+afterAll(cleanup);
+
+describe("GEOSEARCH tests", () => {
+  test("should return distance successfully in meters", async () => {
+    const key = newKey();
+    await new GeoAddCommand([
+      key,
+      { 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 GeoSearchCommand([
+      key,
+      { type: "FROMLONLAT", coordinate: { lon: 15, lat: 37 } },
+      { type: "BYRADIUS", radius: 200, radiusType: "KM" },
+      "ASC",
+    ]).exec(client);
+
+    expect(res).toEqual([{ member: "Catania" }, { member: "Palermo" }]);
+  });
+
+  test("should return members within the specified box", async () => {
+    const key = newKey();
+
+    await new GeoAddCommand([
+      key,
+      { 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 GeoSearchCommand([
+      key,
+      { type: "FROMLONLAT", coordinate: { lon: 14, lat: 37.5 } },
+      { type: "BYBOX", rect: { width: 200, height: 200 }, rectType: "KM" },
+      "ASC",
+    ]).exec(client);
+
+    expect(res).toEqual([{ member: "Palermo" }, { member: "Catania" }]);
+  });
+
+  test("should return members with coordinates, distances, and hashes", async () => {
+    const key = newKey();
+
+    await new GeoAddCommand([
+      key,
+      { 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 GeoSearchCommand([
+      key,
+      { type: "FROMLONLAT", coordinate: { lon: 14, lat: 37.5 } },
+      { type: "BYRADIUS", radius: 200, radiusType: "KM" },
+      "ASC",
+      { withHash: true, withCoord: true, withDist: true },
+    ]).exec(client);
+
+    expect(res).toEqual([
+      {
+        member: "Palermo",
+        dist: 88.526,
+        hash: "3479099956230698",
+        coord: {
+          long: 13.361_389_338_970_184,
+          lat: 38.115_556_395_496_3,
+        },
+      },
+      {
+        member: "Catania",
+        dist: 95.9406,
+        hash: "3479447370796909",
+        coord: {
+          long: 15.087_267_458_438_873,
+          lat: 37.502_668_423_331_62,
+        },
+      },
+    ]);
+  });
+
+  test("should return members with distances, and hashes", async () => {
+    const key = newKey();
+
+    await new GeoAddCommand([
+      key,
+      { 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 GeoSearchCommand([
+      key,
+      { type: "FROMLONLAT", coordinate: { lon: 14, lat: 37.5 } },
+      { type: "BYRADIUS", radius: 200, radiusType: "KM" },
+      "ASC",
+      { withHash: true, withDist: true },
+    ]).exec(client);
+
+    expect(res).toEqual([
+      {
+        member: "Palermo",
+        dist: 88.526,
+        hash: "3479099956230698",
+      },
+      {
+        member: "Catania",
+        dist: 95.9406,
+        hash: "3479447370796909",
+      },
+    ]);
+  });
+
+  test("should return members with and coordinates", async () => {
+    const key = newKey();
+
+    await new GeoAddCommand([
+      key,
+      { 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 GeoSearchCommand([
+      key,
+      { type: "FROMLONLAT", coordinate: { lon: 14, lat: 37.5 } },
+      { type: "BYRADIUS", radius: 200, radiusType: "KM" },
+      "ASC",
+      { withCoord: true },
+    ]).exec(client);
+
+    expect(res).toEqual([
+      {
+        member: "Palermo",
+        coord: { long: 13.361_389_338_970_184, lat: 38.115_556_395_496_3 },
+      },
+      {
+        member: "Catania",
+        coord: { long: 15.087_267_458_438_873, lat: 37.502_668_423_331_62 },
+      },
+    ]);
+  });
+
+  test("should return members with coordinates, and hashes", async () => {
+    const key = newKey();
+
+    await new GeoAddCommand([
+      key,
+      { 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 GeoSearchCommand([
+      key,
+      { type: "FROMLONLAT", coordinate: { lon: 14, lat: 37.5 } },
+      { type: "BYRADIUS", radius: 200, radiusType: "KM" },
+      "ASC",
+      { withHash: true, withCoord: true },
+    ]).exec(client);
+
+    expect(res).toEqual([
+      {
+        member: "Palermo",
+        hash: "3479099956230698",
+        coord: { long: 13.361_389_338_970_184, lat: 38.115_556_395_496_3 },
+      },
+      {
+        member: "Catania",
+        hash: "3479447370796909",
+        coord: { long: 15.087_267_458_438_873, lat: 37.502_668_423_331_62 },
+      },
+    ]);
+  });
+
+  test("should return one member, with count set", async () => {
+    const key = newKey();
+    await new GeoAddCommand([
+      key,
+      { 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 GeoSearchCommand([
+      key,
+      { type: "FROMLONLAT", coordinate: { lon: 15, lat: 37 } },
+      { type: "BYRADIUS", radius: 200, radiusType: "KM" },
+      "ASC",
+      { count: { limit: 1 } },
+    ]).exec(client);
+
+    expect(res).toEqual([{ member: "Catania" }]);
+  });
+});

package/pkg/commands/geo_search.ts

@@ -0,0 +1,139 @@
+import type { CommandOptions } from "./command.ts";
+import { Command } from "./command.ts";
+
+type RadiusOptions = "M" | "KM" | "FT" | "MI";
+type CenterPoint<TMemberType> =
+  | {
+      type: "FROMMEMBER" | "frommember";
+      member: TMemberType;
+    }
+  | {
+      type: "FROMLONLAT" | "fromlonlat";
+      coordinate: { lon: number; lat: number };
+    };
+
+type Shape =
+  | { type: "BYRADIUS" | "byradius"; radius: number; radiusType: RadiusOptions }
+  | {
+      type: "BYBOX" | "bybox";
+      rect: { width: number; height: number };
+      rectType: RadiusOptions;
+    };
+
+type GeoSearchCommandOptions = {
+  count?: { limit: number; any?: boolean };
+  withCoord?: boolean;
+  withDist?: boolean;
+  withHash?: boolean;
+};
+
+type OptionMappings = {
+  withHash: "hash";
+  withCoord: "coord";
+  withDist: "dist";
+};
+
+type GeoSearchOptions<TOptions> = {
+  [K in keyof TOptions as K extends keyof OptionMappings
+    ? OptionMappings[K]
+    : never]: K extends "withHash"
+    ? string
+    : K extends "withCoord"
+      ? { long: number; lat: number }
+      : K extends "withDist"
+        ? number
+        : never;
+};
+
+type GeoSearchResponse<TOptions, TMemberType> = ({
+  member: TMemberType;
+} & GeoSearchOptions<TOptions>)[];
+
+/**
+ * @see https://redis.io/commands/geosearch
+ */
+export class GeoSearchCommand<
+  TMemberType = string,
+  TOptions extends GeoSearchCommandOptions = GeoSearchCommandOptions,
+> extends Command<any[] | any[][], GeoSearchResponse<TOptions, TMemberType>> {
+  constructor(
+    [key, centerPoint, shape, order, opts]: [
+      key: string,
+      centerPoint: CenterPoint<TMemberType>,
+      shape: Shape,
+      order: "ASC" | "DESC" | "asc" | "desc",
+      opts?: TOptions,
+    ],
+    commandOptions?: CommandOptions<any[] | any[][], GeoSearchResponse<TOptions, TMemberType>>
+  ) {
+    const command: unknown[] = ["GEOSEARCH", key];
+
+    if (centerPoint.type === "FROMMEMBER" || centerPoint.type === "frommember") {
+      command.push(centerPoint.type, centerPoint.member);
+    }
+    if (centerPoint.type === "FROMLONLAT" || centerPoint.type === "fromlonlat") {
+      command.push(centerPoint.type, centerPoint.coordinate.lon, centerPoint.coordinate.lat);
+    }
+
+    if (shape.type === "BYRADIUS" || shape.type === "byradius") {
+      command.push(shape.type, shape.radius, shape.radiusType);
+    }
+    if (shape.type === "BYBOX" || shape.type === "bybox") {
+      command.push(shape.type, shape.rect.width, shape.rect.height, shape.rectType);
+    }
+    command.push(order);
+
+    if (opts?.count) {
+      command.push("COUNT", opts.count.limit, ...(opts.count.any ? ["ANY"] : []));
+    }
+
+    const transform = (result: string[] | string[][]) => {
+      if (!opts?.withCoord && !opts?.withDist && !opts?.withHash) {
+        return result.map((member) => {
+          try {
+            return { member: JSON.parse(member as string) };
+          } catch {
+            return { member };
+          }
+        });
+      }
+      return result.map((members) => {
+        let counter = 1;
+        const obj = {} as any;
+
+        try {
+          obj.member = JSON.parse(members[0]);
+        } catch {
+          obj.member = members[0];
+        }
+
+        if (opts.withDist) {
+          obj.dist = Number.parseFloat(members[counter++]);
+        }
+        if (opts.withHash) {
+          obj.hash = members[counter++].toString();
+        }
+        if (opts.withCoord) {
+          obj.coord = {
+            long: Number.parseFloat(members[counter][0]),
+            lat: Number.parseFloat(members[counter][1]),
+          };
+        }
+        return obj;
+      });
+    };
+
+    super(
+      [
+        ...command,
+        ...(opts?.withCoord ? ["WITHCOORD"] : []),
+        ...(opts?.withDist ? ["WITHDIST"] : []),
+        ...(opts?.withHash ? ["WITHHASH"] : []),
+      ],
+      {
+        deserialize: transform,
+        ...commandOptions,
+      }
+    );
+  }
+}

package/pkg/commands/geo_search_store.test.ts

@@ -0,0 +1,153 @@
+import { afterAll, describe, expect, test } from "bun:test";
+import { keygen, newHttpClient } from "../test-utils.ts";
+
+import { GeoAddCommand } from "./geo_add.ts";
+import { GeoSearchStoreCommand } from "./geo_search_store.ts";
+import { ZRangeCommand } from "./zrange.ts";
+
+const client = newHttpClient();
+const { newKey, cleanup } = keygen();
+afterAll(cleanup);
+
+describe("GEOSSEARCHSTORE tests", () => {
+  test("should return members within the radius and store them in sorted set", async () => {
+    const key = newKey();
+    const destination = newKey();
+
+    await new GeoAddCommand([
+      key,
+      { longitude: -73.9857, latitude: 40.7488, member: "Empire State Building" },
+      { longitude: -74.0445, latitude: 40.6892, member: "Statue of Liberty" },
+      { longitude: -73.9632, latitude: 40.7789, member: "Central Park" },
+      { longitude: -73.873, latitude: 40.7769, member: "LaGuardia Airport" },
+      { longitude: -74.177, latitude: 40.6413, member: "JFK Airport" },
+      { longitude: -73.9772, latitude: 40.7527, member: "Grand Central Terminal" },
+    ]).exec(client);
+
+    const res = await new GeoSearchStoreCommand([
+      destination,
+      key,
+      { type: "FROMMEMBER", member: "Empire State Building" },
+      { type: "BYRADIUS", radius: 5, radiusType: "KM" },
+      "ASC",
+    ]).exec(client);
+    const zrangeRes = await new ZRangeCommand([destination, 0, -1, { withScores: true }]).exec(
+      client
+    );
+    expect(zrangeRes).toEqual([
+      "Empire State Building",
+      1_791_875_672_666_387,
+      "Grand Central Terminal",
+      1_791_875_708_058_440,
+      "Central Park",
+      1_791_875_790_048_608,
+    ]);
+    expect(res).toEqual(zrangeRes.length / 2);
+  });
+
+  test("should store geosearch in sorted set with distances", async () => {
+    const key = newKey();
+    const destination = newKey();
+
+    await new GeoAddCommand([
+      key,
+      { longitude: -73.9857, latitude: 40.7488, member: "Empire State Building" },
+      { longitude: -74.0445, latitude: 40.6892, member: "Statue of Liberty" },
+      { longitude: -73.9632, latitude: 40.7789, member: "Central Park" },
+      { longitude: -73.873, latitude: 40.7769, member: "LaGuardia Airport" },
+      { longitude: -74.177, latitude: 40.6413, member: "JFK Airport" },
+      { longitude: -73.9772, latitude: 40.7527, member: "Grand Central Terminal" },
+    ]).exec(client);
+
+    const res = await new GeoSearchStoreCommand([
+      destination,
+      key,
+      { type: "FROMMEMBER", member: "Empire State Building" },
+      { type: "BYRADIUS", radius: 5, radiusType: "KM" },
+      "ASC",
+      { storeDist: true },
+    ]).exec(client);
+    const zrangeRes = await new ZRangeCommand([destination, 0, -1, { withScores: true }]).exec(
+      client
+    );
+    expect(zrangeRes).toEqual([
+      "Empire State Building",
+      0,
+      "Grand Central Terminal",
+      "0.83757447438393129",
+      "Central Park",
+      "3.8473905221815641",
+    ]);
+    expect(res).toEqual(zrangeRes.length / 2);
+  });
+
+  test("should return object members within the radius and store them in sorted set with distance and members", async () => {
+    const key = newKey();
+    const destination = newKey();
+
+    await new GeoAddCommand<{ name: string }>([
+      key,
+      { longitude: -73.9857, latitude: 40.7488, member: { name: "Empire State Building" } },
+      { longitude: -74.0445, latitude: 40.6892, member: { name: "Statue of Liberty" } },
+      { longitude: -73.9632, latitude: 40.7789, member: { name: "Central Park" } },
+      { longitude: -73.873, latitude: 40.7769, member: { name: "LaGuardia Airport" } },
+      { longitude: -74.177, latitude: 40.6413, member: { name: "JFK Airport" } },
+      { longitude: -73.9772, latitude: 40.7527, member: { name: "Grand Central Terminal" } },
+    ]).exec(client);
+
+    const res = await new GeoSearchStoreCommand([
+      destination,
+      key,
+      { type: "FROMMEMBER", member: { name: "Empire State Building" } },
+      { type: "BYRADIUS", radius: 5, radiusType: "KM" },
+      "DESC",
+      { storeDist: true },
+    ]).exec(client);
+    const zrangeRes = await new ZRangeCommand([destination, 0, -1, { withScores: true }]).exec(
+      client
+    );
+    expect(zrangeRes).toEqual([
+      { name: "Empire State Building" },
+      0,
+      { name: "Grand Central Terminal" },
+      "0.83757447438393129",
+      { name: "Central Park" },
+      "3.8473905221815641",
+    ]);
+    expect(res).toEqual(zrangeRes.length / 2);
+  });
+
+  test("should return limited amount of members and store them in sorted set", async () => {
+    const key = newKey();
+    const destination = newKey();
+
+    await new GeoAddCommand([
+      key,
+      { longitude: -73.9857, latitude: 40.7488, member: "Empire State Building" },
+      { longitude: -74.0445, latitude: 40.6892, member: "Statue of Liberty" },
+      { longitude: -73.9632, latitude: 40.7789, member: "Central Park" },
+      { longitude: -73.873, latitude: 40.7769, member: "LaGuardia Airport" },
+      { longitude: -74.177, latitude: 40.6413, member: "JFK Airport" },
+      { longitude: -73.9772, latitude: 40.7527, member: "Grand Central Terminal" },
+    ]).exec(client);
+
+    const res = await new GeoSearchStoreCommand([
+      destination,
+      key,
+      { type: "FROMMEMBER", member: "Empire State Building" },
+      { type: "BYRADIUS", radius: 5, radiusType: "KM" },
+      "ASC",
+      { count: { limit: 2 } },
+    ]).exec(client);
+    const zrangeRes = await new ZRangeCommand([destination, 0, -1, { withScores: true }]).exec(
+      client
+    );
+    expect(zrangeRes).toEqual([
+      "Empire State Building",
+      1_791_875_672_666_387,
+      "Grand Central Terminal",
+      1_791_875_708_058_440,
+    ]);
+    expect(res).toEqual(zrangeRes.length / 2);
+  });
+});

package/pkg/commands/geo_search_store.ts

@@ -0,0 +1,69 @@
+import type { CommandOptions } from "./command.ts";
+import { Command } from "./command.ts";
+
+type RadiusOptions = "M" | "KM" | "FT" | "MI";
+type CenterPoint<TMemberType> =
+  | {
+      type: "FROMMEMBER" | "frommember";
+      member: TMemberType;
+    }
+  | {
+      type: "FROMLONLAT" | "fromlonlat";
+      coordinate: { lon: number; lat: number };
+    };
+
+type Shape =
+  | { type: "BYRADIUS" | "byradius"; radius: number; radiusType: RadiusOptions }
+  | {
+      type: "BYBOX" | "bybox";
+      rect: { width: number; height: number };
+      rectType: RadiusOptions;
+    };
+
+type GeoSearchCommandOptions = {
+  count?: { limit: number; any?: boolean };
+  storeDist?: boolean;
+};
+
+/**
+ * @see https://redis.io/commands/geosearchstore
+ */
+export class GeoSearchStoreCommand<
+  TMemberType = string,
+  TOptions extends GeoSearchCommandOptions = GeoSearchCommandOptions,
+> extends Command<any[] | any[][], number> {
+  constructor(
+    [destination, key, centerPoint, shape, order, opts]: [
+      destination: string,
+      key: string,
+      centerPoint: CenterPoint<TMemberType>,
+      shape: Shape,
+      order: "ASC" | "DESC" | "asc" | "desc",
+      opts?: TOptions,
+    ],
+    commandOptions?: CommandOptions<any[] | any[][], number>
+  ) {
+    const command: unknown[] = ["GEOSEARCHSTORE", destination, key];
+
+    if (centerPoint.type === "FROMMEMBER" || centerPoint.type === "frommember") {
+      command.push(centerPoint.type, centerPoint.member);
+    }
+    if (centerPoint.type === "FROMLONLAT" || centerPoint.type === "fromlonlat") {
+      command.push(centerPoint.type, centerPoint.coordinate.lon, centerPoint.coordinate.lat);
+    }
+
+    if (shape.type === "BYRADIUS" || shape.type === "byradius") {
+      command.push(shape.type, shape.radius, shape.radiusType);
+    }
+    if (shape.type === "BYBOX" || shape.type === "bybox") {
+      command.push(shape.type, shape.rect.width, shape.rect.height, shape.rectType);
+    }
+    command.push(order);
+
+    if (opts?.count) {
+      command.push("COUNT", opts.count.limit, ...(opts.count.any ? ["ANY"] : []));
+    }
+
+    super([...command, ...(opts?.storeDist ? ["STOREDIST"] : [])], commandOptions);
+  }
+}

package/pkg/commands/get.test.ts

@@ -0,0 +1,35 @@
+import { keygen, newHttpClient, randomID } from "../test-utils";
+
+import { afterAll, expect, test } from "bun:test";
+import { SetCommand } from "./set";
+
+import { GetCommand } from "./get";
+const client = newHttpClient();
+
+const { newKey, cleanup } = keygen();
+afterAll(cleanup);
+
+test("gets an exiting value", async () => {
+  const key = newKey();
+  const value = randomID();
+  await new SetCommand([key, value]).exec(client);
+  const res = await new GetCommand([key]).exec(client);
+
+  expect(res).toEqual(value);
+});
+
+test("gets a non-existing value", async () => {
+  const key = newKey();
+  const res = await new GetCommand([key]).exec(client);
+
+  expect(res).toEqual(null);
+});
+
+test("gets an object", async () => {
+  const key = newKey();
+  const value = { v: randomID() };
+  await new SetCommand([key, value]).exec(client);
+  const res = await new GetCommand<{ v: string }>([key]).exec(client);
+
+  expect(res).toEqual(value);
+});