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

package/pkg/commands/mod.ts

@@ -0,0 +1,168 @@
+export * from "./append";
+export * from "./bitcount";
+export * from "./bitfield";
+export * from "./bitop";
+export * from "./bitpos";
+export * from "./command";
+export * from "./copy";
+export * from "./dbsize";
+export * from "./decr";
+export * from "./decrby";
+export * from "./del";
+export * from "./echo";
+export * from "./eval";
+export * from "./evalsha";
+export * from "./exists";
+export * from "./expire";
+export * from "./expireat";
+export * from "./flushall";
+export * from "./flushdb";
+export * from "./geo_add";
+export * from "./geo_dist";
+export * from "./geo_hash";
+export * from "./geo_pos";
+export * from "./geo_search";
+export * from "./geo_search_store";
+export * from "./get";
+export * from "./getbit";
+export * from "./getdel";
+export * from "./getrange";
+export * from "./getset";
+export * from "./hdel";
+export * from "./hexists";
+export * from "./hget";
+export * from "./hgetall";
+export * from "./hincrby";
+export * from "./hincrbyfloat";
+export * from "./hkeys";
+export * from "./hlen";
+export * from "./hmget";
+export * from "./hmset";
+export * from "./hrandfield";
+export * from "./hscan";
+export * from "./hset";
+export * from "./hsetnx";
+export * from "./hstrlen";
+export * from "./hvals";
+export * from "./incr";
+export * from "./incrby";
+export * from "./incrbyfloat";
+export * from "./json_arrappend";
+export * from "./json_arrindex";
+export * from "./json_arrinsert";
+export * from "./json_arrlen";
+export * from "./json_arrpop";
+export * from "./json_arrtrim";
+export * from "./json_clear";
+export * from "./json_del";
+export * from "./json_forget";
+export * from "./json_get";
+export * from "./json_mget";
+export * from "./json_mset";
+export * from "./json_numincrby";
+export * from "./json_nummultby";
+export * from "./json_objkeys";
+export * from "./json_objlen";
+export * from "./json_resp";
+export * from "./json_set";
+export * from "./json_strappend";
+export * from "./json_strlen";
+export * from "./json_toggle";
+export * from "./json_type";
+export * from "./keys";
+export * from "./lindex";
+export * from "./linsert";
+export * from "./llen";
+export * from "./lmove";
+export * from "./lmpop";
+export * from "./lpop";
+export * from "./lpos";
+export * from "./lpush";
+export * from "./lpushx";
+export * from "./lrange";
+export * from "./lrem";
+export * from "./lset";
+export * from "./ltrim";
+export * from "./mget";
+export * from "./mset";
+export * from "./msetnx";
+export * from "./persist";
+export * from "./pexpire";
+export * from "./pexpireat";
+export * from "./pfadd";
+export * from "./pfcount";
+export * from "./pfmerge";
+export * from "./ping";
+export * from "./psetex";
+export * from "./pttl";
+export * from "./publish";
+export * from "./randomkey";
+export * from "./rename";
+export * from "./renamenx";
+export * from "./rpop";
+export * from "./rpush";
+export * from "./rpushx";
+export * from "./sadd";
+export * from "./scan";
+export * from "./scard";
+export * from "./script_exists";
+export * from "./script_flush";
+export * from "./script_load";
+export * from "./sdiff";
+export * from "./sdiffstore";
+export * from "./set";
+export * from "./setbit";
+export * from "./setex";
+export * from "./setnx";
+export * from "./setrange";
+export * from "./sinter";
+export * from "./sinterstore";
+export * from "./sismember";
+export * from "./smembers";
+export * from "./smismember";
+export * from "./smove";
+export * from "./spop";
+export * from "./srandmember";
+export * from "./srem";
+export * from "./sscan";
+export * from "./strlen";
+export * from "./sunion";
+export * from "./sunionstore";
+export * from "./time";
+export * from "./touch";
+export * from "./ttl";
+export * from "./type";
+export * from "./unlink";
+export * from "./xack";
+export * from "./xadd";
+export * from "./xautoclaim";
+export * from "./xclaim";
+export * from "./xdel";
+export * from "./xgroup";
+export * from "./xinfo";
+export * from "./xlen";
+export * from "./xpending";
+export * from "./xrange";
+export * from "./xread";
+export * from "./xreadgroup";
+export * from "./xrevrange";
+export * from "./xtrim";
+export * from "./zadd";
+export * from "./zcard";
+export * from "./zcount";
+export * from "./zincrby";
+export * from "./zinterstore";
+export * from "./zlexcount";
+export * from "./zpopmax";
+export * from "./zpopmin";
+export * from "./zrange";
+export * from "./zrank";
+export * from "./zrem";
+export * from "./zremrangebylex";
+export * from "./zremrangebyrank";
+export * from "./zremrangebyscore";
+export * from "./zrevrank";
+export * from "./zscan";
+export * from "./zscore";
+export * from "./zunion";
+export * from "./zunionstore";

package/pkg/commands/mset.test.ts

@@ -0,0 +1,24 @@
+import { keygen, newHttpClient, randomID } from "../test-utils";
+
+import { afterAll, expect, test } from "bun:test";
+import { MGetCommand } from "./mget";
+import { MSetCommand } from "./mset";
+
+const client = newHttpClient();
+
+const { newKey, cleanup } = keygen();
+afterAll(cleanup);
+
+test("gets exiting values", async () => {
+  const key1 = newKey();
+  const key2 = newKey();
+  const kv = {
+    [key1]: randomID(),
+    [key2]: randomID(),
+  };
+  const res = await new MSetCommand([kv]).exec(client);
+
+  expect(res).toEqual("OK");
+  const res2 = await new MGetCommand([key1, key2]).exec(client);
+  expect(res2).toEqual(Object.values(kv));
+});

package/pkg/commands/mset.ts

@@ -0,0 +1,11 @@
+import type { CommandOptions } from "./command";
+import { Command } from "./command";
+
+/**
+ * @see https://redis.io/commands/mset
+ */
+export class MSetCommand<TData> extends Command<"OK", "OK"> {
+  constructor([kv]: [kv: Record<string, TData>], opts?: CommandOptions<"OK", "OK">) {
+    super(["mset", ...Object.entries(kv).flatMap(([key, value]) => [key, value])], opts);
+  }
+}

package/pkg/commands/msetnx.test.ts

@@ -0,0 +1,46 @@
+import { keygen, newHttpClient, randomID } from "../test-utils";
+
+import { afterAll, expect, test } from "bun:test";
+import { GetCommand } from "./get";
+import { MGetCommand } from "./mget";
+import { MSetNXCommand } from "./msetnx";
+import { SetCommand } from "./set";
+const client = newHttpClient();
+
+const { newKey, cleanup } = keygen();
+afterAll(cleanup);
+
+test("sets values", async () => {
+  const key1 = newKey();
+  const value1 = randomID();
+  const key2 = newKey();
+  const value2 = randomID();
+
+  const kv: Record<string, string> = {};
+  kv[key1] = value1;
+  kv[key2] = value2;
+  const res = await new MSetNXCommand([kv]).exec(client);
+
+  expect(res).toEqual(1);
+  const res2 = await new MGetCommand<[string, string]>([key1, key2]).exec(client);
+
+  expect(res2).toEqual([value1, value2]);
+});
+
+test("does not set values if one key already exists", async () => {
+  const key1 = newKey();
+  const value1 = randomID();
+  const key2 = newKey();
+  const value2 = randomID();
+  await new SetCommand([key1, value1]).exec(client);
+  const kv: Record<string, string> = {};
+  kv[key1] = value1;
+  kv[key2] = value2;
+  const res = await new MSetNXCommand([kv]).exec(client);
+
+  expect(res).toEqual(0);
+
+  const res2 = await new GetCommand([key2]).exec(client);
+
+  expect(res2).toEqual(null);
+});

package/pkg/commands/msetnx.ts

@@ -0,0 +1,11 @@
+import type { CommandOptions } from "./command";
+import { Command } from "./command";
+
+/**
+ * @see https://redis.io/commands/msetnx
+ */
+export class MSetNXCommand<TData = string> extends Command<number, number> {
+  constructor([kv]: [kv: Record<string, TData>], opts?: CommandOptions<number, number>) {
+    super(["msetnx", ...Object.entries(kv).flat()], opts);
+  }
+}

package/pkg/commands/persist.test.ts

@@ -0,0 +1,22 @@
+import { keygen, newHttpClient, randomID } from "../test-utils";
+
+import { afterAll, expect, test } from "bun:test";
+import { PersistCommand } from "./persist";
+import { SetCommand } from "./set";
+
+import { GetCommand } from "./get";
+const client = newHttpClient();
+
+const { newKey, cleanup } = keygen();
+afterAll(cleanup);
+test("persists the key", async () => {
+  const key = newKey();
+  const value = randomID();
+  await new SetCommand([key, value, { ex: 2 }]).exec(client);
+  const res = await new PersistCommand([key]).exec(client);
+  expect(res).toEqual(1);
+  await new Promise((resolve) => setTimeout(resolve, 2000));
+  const res2 = await new GetCommand([key]).exec(client);
+
+  expect(res2).toEqual(value);
+});

package/pkg/commands/persist.ts

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

package/pkg/commands/pexpire.test.ts

@@ -0,0 +1,24 @@
+import { keygen, newHttpClient, randomID } from "../test-utils";
+
+import { afterAll, expect, test } from "bun:test";
+import { GetCommand } from "./get";
+import { PExpireCommand } from "./pexpire";
+import { SetCommand } from "./set";
+const client = newHttpClient();
+
+const { newKey, cleanup } = keygen();
+afterAll(cleanup);
+
+test("without options", () => {
+  test("expires a key correctly", async () => {
+    const key = newKey();
+    const value = randomID();
+    await new SetCommand([key, value]).exec(client);
+    const res = await new PExpireCommand([key, 1000]).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/pexpire.ts

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

package/pkg/commands/pexpireat.test.ts

@@ -0,0 +1,31 @@
+import { keygen, newHttpClient, randomID } from "../test-utils";
+import { GetCommand } from "./get";
+import { PExpireAtCommand } from "./pexpireat";
+
+import { afterAll, expect, test } from "bun:test";
+import { SetCommand } from "./set";
+
+const client = newHttpClient();
+const { newKey, cleanup } = keygen();
+afterAll(cleanup);
+
+test("without options", () => {
+  test("expires the key", async () => {
+    const key = newKey();
+    const value = randomID();
+    await new SetCommand([key, value]).exec(client);
+  });
+});
+test("without options", () => {
+  test("expires the key", async () => {
+    const key = newKey();
+    const value = randomID();
+    await new SetCommand([key, value]).exec(client);
+
+    const res = await new PExpireAtCommand([key, 1000]).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/pexpireat.ts

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

package/pkg/commands/pfadd.test.ts

@@ -0,0 +1,80 @@
+import { keygen, newHttpClient, randomID } from "../test-utils.ts";
+
+import { afterEach, describe, expect, test } from "bun:test";
+
+import { PfAddCommand } from "./pfadd.ts";
+import { PfCountCommand } from "./pfcount.ts";
+import { PfMergeCommand } from "./pfmerge.ts";
+
+const client = newHttpClient();
+
+const { newKey, cleanup } = keygen();
+afterEach(cleanup);
+
+describe("adding multiple elements at once", () => {
+  const key = newKey();
+  test("returns 1 if successful, returns 3 as the cardinality", async () => {
+    const value1 = randomID();
+    const value2 = randomID();
+    const value3 = randomID();
+
+    const res = await new PfAddCommand([key, value1, value2, value3]).exec(client);
+    expect(res).toBe(1);
+
+    const res2 = await new PfCountCommand([key]).exec(client);
+
+    expect(res2).toBe(3);
+  });
+});
+
+describe("inserting the same element multiple times", () => {
+  const key = newKey();
+  const value1 = randomID();
+  const value2 = randomID();
+
+  test("modified succesfully and returned correct cardinality for repeated elements", async () => {
+    const resInsert = await new PfAddCommand([key, value1, value1, value2, value2]).exec(client);
+    expect(resInsert).toBe(1);
+
+    const resCount = await new PfCountCommand([key]).exec(client);
+    expect(resCount).toBe(2);
+  });
+});
+
+describe("adding the same strings on different lines doesn't modify the HLL", () => {
+  const key = newKey();
+
+  const value1 = randomID();
+  const value2 = randomID();
+  const value3 = randomID();
+
+  test("modifies the HLL on the first insertion of strings", async () => {
+    const resAdd = await new PfAddCommand([key, value1, value2, value3]).exec(client);
+    expect(resAdd).toBe(1);
+
+    const resAddDuplicate = await new PfAddCommand([key, value1, value2, value3]).exec(client);
+    expect(resAddDuplicate).toBe(0);
+  });
+});
+
+describe("merge HLLs with overlapping values and count", () => {
+  const key1 = newKey();
+  const key2 = newKey();
+  const mergedKey = newKey();
+  const value1 = randomID();
+  const value2 = randomID();
+  const value3 = randomID();
+  const value4 = randomID();
+
+  test("insert overlapping strings into two HLLs", async () => {
+    await new PfAddCommand([key1, value1, value2, value3]).exec(client);
+    const resAdd = await new PfAddCommand([key2, value3, value4]).exec(client);
+    expect(resAdd).toBe(1);
+
+    const resMerge = await new PfMergeCommand([mergedKey, key1, key2]).exec(client);
+    expect(resMerge).toBe("OK");
+
+    const resCount = await new PfCountCommand([mergedKey]).exec(client);
+    expect(resCount).toBe(4);
+  });
+});

package/pkg/commands/pfadd.ts

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

package/pkg/commands/pfcount.test.ts

@@ -0,0 +1,55 @@
+import { afterEach, describe, expect, test } from "bun:test";
+import { keygen, newHttpClient, randomID } from "../test-utils.ts";
+
+import { PfAddCommand } from "./pfadd.ts";
+import { PfCountCommand } from "./pfcount.ts";
+
+const client = newHttpClient();
+
+const { newKey, cleanup } = keygen();
+afterEach(cleanup);
+
+describe("simple cardinality check", () => {
+  const key = newKey();
+
+  test("insert multiple unique strings", async () => {
+    const value1 = randomID();
+    const value2 = randomID();
+    const value3 = randomID();
+    await new PfAddCommand([key, value1, value2, value3]).exec(client);
+
+    const resCount = await new PfCountCommand([key]).exec(client);
+    expect(resCount).toBe(3);
+  });
+});
+
+describe("multiple keys cardinality check", () => {
+  const key1 = newKey();
+  const key2 = newKey();
+  const value1 = randomID();
+  const value2 = randomID();
+  const value3 = randomID();
+  const value4 = randomID();
+
+  test("insert unique strings into two HLLs", async () => {
+    await new PfAddCommand([key1, value1, value2]).exec(client);
+    await new PfAddCommand([key2, value3, value4]).exec(client);
+
+    const resCount = await new PfCountCommand([key1, key2]).exec(client);
+    expect(resCount).toBe(4);
+  });
+});
+
+describe("cardinality after repeated insertions", () => {
+  const key = newKey();
+  const value1 = randomID();
+  const value2 = randomID();
+
+  test("insert strings and then re-insert them", async () => {
+    await new PfAddCommand([key, value1, value2]).exec(client);
+    await new PfAddCommand([key, value1, value2]).exec(client);
+
+    const resCount = await new PfCountCommand([key]).exec(client);
+    expect(resCount).toBe(2);
+  });
+});

package/pkg/commands/pfcount.ts

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

package/pkg/commands/pfmerge.test.ts

@@ -0,0 +1,67 @@
+import { keygen, newHttpClient, randomID } from "../test-utils.ts";
+
+import { afterEach, describe, expect, test } from "bun:test";
+
+import { PfAddCommand } from "./pfadd.ts";
+import { PfCountCommand } from "./pfcount.ts";
+import { PfMergeCommand } from "./pfmerge.ts";
+
+const client = newHttpClient();
+
+const { newKey, cleanup } = keygen();
+
+afterEach(cleanup);
+
+describe("merge HLLs with distinct values and count", () => {
+  const key1 = newKey();
+  const key2 = newKey();
+  const mergedKey = newKey();
+  const value1 = randomID();
+  const value2 = randomID();
+  const value3 = randomID();
+  const value4 = randomID();
+
+  test("insert distinct strings into two HLLs", async () => {
+    await new PfAddCommand([key1, value1, value2]).exec(client);
+    const resAdd = await new PfAddCommand([key2, value3, value4]).exec(client);
+    expect(resAdd).toBe(1);
+
+    const resMerge = await new PfMergeCommand([mergedKey, key1, key2]).exec(client);
+    expect(resMerge).toBe("OK");
+
+    const resCount = await new PfCountCommand([mergedKey]).exec(client);
+    expect(resCount).toBe(4);
+  });
+});
+
+describe("merge HLL with an empty HLL", () => {
+  const key = newKey();
+  const emptyKey = newKey();
+  const mergedKey = newKey();
+  const value1 = randomID();
+
+  test("insert a string into an HLL and keep another HLL empty", async () => {
+    const resAdd = await new PfAddCommand([key, value1]).exec(client);
+    expect(resAdd).toBe(1);
+
+    const resMerge = await new PfMergeCommand([mergedKey, key, emptyKey]).exec(client);
+    expect(resMerge).toBe("OK");
+
+    const resCount = await new PfCountCommand([mergedKey]).exec(client);
+    expect(resCount).toBe(1);
+  });
+});
+
+describe("merge two empty HLLs", () => {
+  const emptyKey1 = newKey();
+  const emptyKey2 = newKey();
+  const mergedKey = newKey();
+
+  test("merge two empty HLLs", async () => {
+    const resMerge = await new PfMergeCommand([mergedKey, emptyKey1, emptyKey2]).exec(client);
+    expect(resMerge).toBe("OK");
+
+    const resCount = await new PfCountCommand([mergedKey]).exec(client);
+    expect(resCount).toBe(0);
+  });
+});

package/pkg/commands/pfmerge.ts

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

package/pkg/commands/ping.test.ts

@@ -0,0 +1,19 @@
+import { describe, expect, test } from "bun:test";
+import { newHttpClient, randomID } from "../test-utils";
+import { PingCommand } from "./ping";
+
+const client = newHttpClient();
+
+describe("with message", () => {
+  test("returns the message", async () => {
+    const message = randomID();
+    const res = await new PingCommand([message]).exec(client);
+    expect(res).toEqual(message);
+  });
+});
+describe("without message", () => {
+  test("returns pong", async () => {
+    const res = await new PingCommand([]).exec(client);
+    expect(res).toEqual("PONG");
+  });
+});

package/pkg/commands/ping.ts

@@ -0,0 +1,14 @@
+import type { CommandOptions } from "./command";
+import { Command } from "./command";
+/**
+ * @see https://redis.io/commands/ping
+ */
+export class PingCommand extends Command<string | "PONG", string | "PONG"> {
+  constructor(cmd?: [message?: string], opts?: CommandOptions<string | "PONG", string | "PONG">) {
+    const command: string[] = ["ping"];
+    if (cmd?.[0] !== undefined) {
+      command.push(cmd[0]);
+    }
+    super(command, opts);
+  }
+}