@upstash/redis 0.2.1 → 1.0.0-alpha.2

package/pkg/commands/index.ts

@@ -0,0 +1,107 @@
+export * from "./append"
+export * from "./bitcount"
+export * from "./bitop"
+export * from "./bitpos"
+export * from "./dbsize"
+export * from "./decr"
+export * from "./decrby"
+export * from "./del"
+export * from "./echo"
+export * from "./exists"
+export * from "./expire"
+export * from "./expireat"
+export * from "./flushall"
+export * from "./flushdb"
+export * from "./get"
+export * from "./getbit"
+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 "./hscan"
+export * from "./hset"
+export * from "./hsetnx"
+export * from "./hstrlen"
+export * from "./hvals"
+export * from "./incr"
+export * from "./incrby"
+export * from "./incrbyfloat"
+export * from "./keys"
+export * from "./lindex"
+export * from "./linsert"
+export * from "./llen"
+export * from "./lpop"
+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 "./ping"
+export * from "./psetex"
+export * from "./pttl"
+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 "./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 "./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 "./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 "./zunionstore"

package/pkg/commands/keys.test.ts

@@ -0,0 +1,17 @@
+import { keygen, newHttpClient } from "../test-utils"
+import { describe, it, expect, afterAll } from "@jest/globals"
+import { SetCommand } from "./set"
+import { KeysCommand } from "./keys"
+const client = newHttpClient()
+
+const { newKey, cleanup } = keygen()
+afterAll(cleanup)
+
+describe("when keys are found", () => {
+  it("returns keys", async () => {
+    const key = newKey()
+    await new SetCommand(key, "value").exec(client)
+    const res = await new KeysCommand(key).exec(client)
+    expect(res).toEqual([key])
+  })
+})

package/pkg/commands/keys.ts

@@ -0,0 +1,10 @@
+import { Command } from "../command"
+
+/**
+ * @see https://redis.io/commands/keys
+ */
+export class KeysCommand extends Command<string[], string[]> {
+  constructor(pattern: string) {
+    super(["keys", pattern])
+  }
+}

package/pkg/commands/lindex.test.ts

@@ -0,0 +1,33 @@
+import { keygen, newHttpClient } from "../test-utils"
+import { randomUUID } from "crypto"
+import { describe, it, expect, afterAll } from "@jest/globals"
+import { LPushCommand } from "./lpush"
+import { LIndexCommand } from "./lindex"
+
+const client = newHttpClient()
+
+const { newKey, cleanup } = keygen()
+afterAll(cleanup)
+
+describe("when list exists", () => {
+  describe("when the index is in range", () => {
+    it("returns the element at index", async () => {
+      const key = newKey()
+
+      const value = randomUUID()
+      await new LPushCommand(key, value).exec(client)
+      const res = await new LIndexCommand(key, 0).exec(client)
+      expect(res).toEqual(value)
+    })
+    describe("when the index is out of bounds", () => {
+      it("returns null", async () => {
+        const key = newKey()
+
+        const value = randomUUID()
+        await new LPushCommand(key, value).exec(client)
+        const res = await new LIndexCommand(key, 1).exec(client)
+        expect(res).toBeNull()
+      })
+    })
+  })
+})

package/pkg/commands/lindex.ts

@@ -0,0 +1,7 @@
+import { Command } from "../command"
+
+export class LIndexCommand<TData = string> extends Command<TData | null, unknown | null> {
+  constructor(key: string, index: number) {
+    super(["lindex", key, index])
+  }
+}

package/pkg/commands/linsert.test.ts

@@ -0,0 +1,19 @@
+import { keygen, newHttpClient } from "../test-utils"
+import { randomUUID } from "crypto"
+import { it, expect, afterAll } from "@jest/globals"
+import { LInsertCommand } from "./linsert"
+import { LPushCommand } from "./lpush"
+const client = newHttpClient()
+
+const { newKey, cleanup } = keygen()
+afterAll(cleanup)
+
+it("adds the element", async () => {
+  const key = newKey()
+  const value1 = randomUUID()
+  const value2 = randomUUID()
+
+  await new LPushCommand(key, value1).exec(client)
+  const res = await new LInsertCommand(key, "before", value1, value2).exec(client)
+  expect(res).toBe(2)
+})

package/pkg/commands/linsert.ts

@@ -0,0 +1,6 @@
+import { Command } from "../command"
+export class LInsertCommand<TData = string> extends Command<number, number> {
+  constructor(key: string, direction: "before" | "after", pivot: TData, value: TData) {
+    super(["linsert", key, direction, pivot, value])
+  }
+}

package/pkg/commands/llen.test.ts

@@ -0,0 +1,26 @@
+import { keygen, newHttpClient } from "../test-utils"
+import { randomUUID } from "crypto"
+import { describe, it, expect, afterAll } from "@jest/globals"
+import { LLenCommand } from "./llen"
+import { LPushCommand } from "./lpush"
+const client = newHttpClient()
+
+const { newKey, cleanup } = keygen()
+afterAll(cleanup)
+
+describe("when list exists", () => {
+  it("returns the length of the list", async () => {
+    const key = newKey()
+    await new LPushCommand(key, randomUUID()).exec(client)
+    const res = await new LLenCommand(key).exec(client)
+    expect(res).toEqual(1)
+  })
+})
+
+describe("when list does not exist", () => {
+  it("returns 0", async () => {
+    const key = newKey()
+    const res = await new LLenCommand(key).exec(client)
+    expect(res).toEqual(0)
+  })
+})

package/pkg/commands/llen.ts

@@ -0,0 +1,10 @@
+import { Command } from "../command"
+
+/**
+ * @see https://redis.io/commands/llen
+ */
+export class LLenCommand extends Command<number, number> {
+  constructor(key: string) {
+    super(["llen", key])
+  }
+}

package/pkg/commands/lpop.test.ts

@@ -0,0 +1,27 @@
+import { keygen, newHttpClient } from "../test-utils"
+import { randomUUID } from "crypto"
+import { describe, it, expect, afterAll } from "@jest/globals"
+import { LPopCommand } from "./lpop"
+import { LPushCommand } from "./lpush"
+const client = newHttpClient()
+
+const { newKey, cleanup } = keygen()
+afterAll(cleanup)
+
+describe("when list exists", () => {
+  it("returns the first element", async () => {
+    const key = newKey()
+    const value = randomUUID()
+    await new LPushCommand(key, value).exec(client)
+    const res = await new LPopCommand(key).exec(client)
+    expect(res).toEqual(value)
+  })
+})
+
+describe("when list does not exist", () => {
+  it("returns null", async () => {
+    const key = newKey()
+    const res = await new LPopCommand(key).exec(client)
+    expect(res).toBeNull()
+  })
+})

package/pkg/commands/lpop.ts

@@ -0,0 +1,10 @@
+import { Command } from "../command"
+
+/**
+ * @see https://redis.io/commands/lpop
+ */
+export class LPopCommand<TData = string> extends Command<TData | null, unknown | null> {
+  constructor(key: string) {
+    super(["lpop", key])
+  }
+}

package/pkg/commands/lpush.test.ts

@@ -0,0 +1,17 @@
+import { keygen, newHttpClient } from "../test-utils"
+import { randomUUID } from "crypto"
+import { it, expect, afterAll } from "@jest/globals"
+import { LPushCommand } from "./lpush"
+const client = newHttpClient()
+
+const { newKey, cleanup } = keygen()
+afterAll(cleanup)
+
+it("returns the length after command", async () => {
+  const key = newKey()
+  const res = await new LPushCommand(key, randomUUID()).exec(client)
+  expect(res).toEqual(1)
+  const res2 = await new LPushCommand(key, randomUUID(), randomUUID()).exec(client)
+
+  expect(res2).toEqual(3)
+})

package/pkg/commands/lpush.ts

@@ -0,0 +1,11 @@
+import { NonEmptyArray } from "../types"
+import { Command } from "../command"
+
+/**
+ * @see https://redis.io/commands/lpush
+ */
+export class LPushCommand<TData = string> extends Command<number, number> {
+  constructor(key: string, ...elements: NonEmptyArray<TData>) {
+    super(["lpush", key, ...elements])
+  }
+}

package/pkg/commands/lpushx.test.ts

@@ -0,0 +1,29 @@
+import { keygen, newHttpClient } from "../test-utils"
+import { randomUUID } from "crypto"
+import { describe, it, expect, afterAll } from "@jest/globals"
+import { LPushXCommand } from "./lpushx"
+import { LPushCommand } from "./lpush"
+const client = newHttpClient()
+
+const { newKey, cleanup } = keygen()
+afterAll(cleanup)
+
+describe("when list exists", () => {
+  it("returns the length after command", async () => {
+    const key = newKey()
+    await new LPushCommand(key, randomUUID()).exec(client)
+    const res = await new LPushXCommand(key, randomUUID()).exec(client)
+    expect(res).toEqual(2)
+    const res2 = await new LPushXCommand(key, randomUUID(), randomUUID()).exec(client)
+
+    expect(res2).toEqual(4)
+  })
+})
+
+describe("when list does not exist", () => {
+  it("does nothing", async () => {
+    const key = newKey()
+    const res = await new LPushXCommand(key, randomUUID()).exec(client)
+    expect(res).toEqual(0)
+  })
+})

package/pkg/commands/lpushx.ts

@@ -0,0 +1,11 @@
+import { NonEmptyArray } from "../types"
+import { Command } from "../command"
+
+/**
+ * @see https://redis.io/commands/lpushx
+ */
+export class LPushXCommand<TData> extends Command<number, number> {
+  constructor(key: string, ...elements: NonEmptyArray<TData>) {
+    super(["lpushx", key, ...elements])
+  }
+}

package/pkg/commands/lrange.test.ts

@@ -0,0 +1,22 @@
+import { keygen, newHttpClient } from "../test-utils"
+import { randomUUID } from "crypto"
+import { it, expect, afterAll } from "@jest/globals"
+import { RPushCommand } from "./rpush"
+import { LRangeCommand } from "./lrange"
+const client = newHttpClient()
+
+const { newKey, cleanup } = keygen()
+afterAll(cleanup)
+
+it("returns the correct range", async () => {
+  const key = newKey()
+  const value1 = randomUUID()
+  const value2 = randomUUID()
+  const value3 = randomUUID()
+  await new RPushCommand(key, value1, value2, value3).exec(client)
+  const res = await new LRangeCommand(key, 1, 2).exec(client)
+  expect(res).toBeDefined()
+  expect(res!.length).toEqual(2)
+  expect(res![0]).toEqual(value2)
+  expect(res![1]).toEqual(value3)
+})

package/pkg/commands/lrange.ts

@@ -0,0 +1,7 @@
+import { Command } from "../command"
+
+export class LRangeCommand<TData = string> extends Command<TData[], unknown[]> {
+  constructor(key: string, start: number, end: number) {
+    super(["lrange", key, start, end])
+  }
+}

package/pkg/commands/lrem.test.ts

@@ -0,0 +1,19 @@
+import { keygen, newHttpClient } from "../test-utils"
+import { it, expect, afterAll } from "@jest/globals"
+
+import { LPushCommand } from "./lpush"
+import { LRemCommand } from "./lrem"
+const client = newHttpClient()
+
+const { newKey, cleanup } = keygen()
+afterAll(cleanup)
+
+it("returns the number of deleted elements", async () => {
+  const key = newKey()
+  await new LPushCommand(key, "element").exec(client)
+  await new LPushCommand(key, "element").exec(client)
+  await new LPushCommand(key, "something else").exec(client)
+
+  const res = await new LRemCommand(key, 2, "element").exec(client)
+  expect(res).toBe(2)
+})

package/pkg/commands/lrem.ts

@@ -0,0 +1,6 @@
+import { Command } from "../command"
+export class LRemCommand<TData> extends Command<number, number> {
+  constructor(key: string, count: number, value: TData) {
+    super(["lrem", key, count, value])
+  }
+}

package/pkg/commands/lset.test.ts

@@ -0,0 +1,40 @@
+import { keygen, newHttpClient } from "../test-utils"
+import { randomUUID } from "crypto"
+import { describe, it, expect, afterAll } from "@jest/globals"
+import { LPushCommand } from "./lpush"
+import { LSetCommand } from "./lset"
+import { LPopCommand } from "./lpop"
+const client = newHttpClient()
+
+const { newKey, cleanup } = keygen()
+afterAll(cleanup)
+
+describe("when list exists", () => {
+  describe("when the index is in range", () => {
+    it("replaces the element at index", async () => {
+      const key = newKey()
+
+      const value = randomUUID()
+      const newValue = randomUUID()
+      await new LPushCommand(key, value).exec(client)
+      const res = await new LSetCommand(key, newValue, 0).exec(client)
+      expect(res).toEqual("OK")
+
+      const res2 = await new LPopCommand(key).exec(client)
+
+      expect(res2).toEqual(newValue)
+    })
+    describe("when the index is out of bounds", () => {
+      it("returns null", async () => {
+        const key = newKey()
+
+        const value = randomUUID()
+        const newValue = randomUUID()
+        await new LPushCommand(key, value).exec(client)
+        expect(
+          async () => await new LSetCommand(key, newValue, 1).exec(client),
+        ).rejects.toThrowErrorMatchingInlineSnapshot(`"ERR index out of range"`)
+      })
+    })
+  })
+})

package/pkg/commands/lset.ts

@@ -0,0 +1,7 @@
+import { Command } from "../command"
+
+export class LSetCommand<TData = string> extends Command<"OK", "OK"> {
+  constructor(key: string, value: TData, index: number) {
+    super(["lset", key, index, value])
+  }
+}

package/pkg/commands/ltrim.test.ts

@@ -0,0 +1,29 @@
+import { keygen, newHttpClient } from "../test-utils"
+import { randomUUID } from "crypto"
+import { describe, it, expect, afterAll } from "@jest/globals"
+import { LPushCommand } from "./lpush"
+import { LTrimCommand } from "./ltrim"
+const client = newHttpClient()
+
+const { newKey, cleanup } = keygen()
+afterAll(cleanup)
+
+describe("when the list exists", () => {
+  it("returns ok", async () => {
+    const key = newKey()
+    await new LPushCommand(key, randomUUID()).exec(client)
+    await new LPushCommand(key, randomUUID()).exec(client)
+    await new LPushCommand(key, randomUUID()).exec(client)
+    const res = await new LTrimCommand(key, 1, 2).exec(client)
+    expect(res).toEqual("OK")
+  })
+})
+
+describe("when the list does not exist", () => {
+  it("returns ok", async () => {
+    const key = newKey()
+
+    const res = await new LTrimCommand(key, 1, 2).exec(client)
+    expect(res).toEqual("OK")
+  })
+})

package/pkg/commands/ltrim.ts

@@ -0,0 +1,7 @@
+import { Command } from "../command"
+
+export class LTrimCommand extends Command<"OK", "OK"> {
+  constructor(key: string, start: number, end: number) {
+    super(["ltrim", key, start, end])
+  }
+}

package/pkg/commands/mget.test.ts

@@ -0,0 +1,44 @@
+import { keygen, newHttpClient } from "../test-utils"
+import { randomUUID } from "crypto"
+import { it, expect, afterAll } from "@jest/globals"
+import { MSetCommand } from "./mset"
+import { MGetCommand } from "./mget"
+
+import { SetCommand } from "./set"
+const client = newHttpClient()
+
+const { newKey, cleanup } = keygen()
+afterAll(cleanup)
+
+it("gets exiting values", async () => {
+  const key1 = newKey()
+  const value1 = randomUUID()
+  const key2 = newKey()
+  const value2 = randomUUID()
+
+  const kv: Record<string, string> = {}
+  kv[key1] = value1
+  kv[key2] = value2
+  const res = await new MSetCommand(kv).exec(client)
+
+  expect(res).toEqual("OK")
+  const res2 = await new MGetCommand<[string, string]>(key1, key2).exec(client)
+
+  expect(res2).toEqual([value1, value2])
+})
+
+it("gets a non-existing value", async () => {
+  const key = newKey()
+  const res = await new MGetCommand<[null]>(key).exec(client)
+
+  expect(res).toEqual([null])
+})
+
+it("gets an object", async () => {
+  const key = newKey()
+  const value = { v: randomUUID() }
+  await new SetCommand(key, value).exec(client)
+  const res = await new MGetCommand<[{ v: string }]>(key).exec(client)
+
+  expect(res).toEqual([value])
+})

package/pkg/commands/mget.ts

@@ -0,0 +1,9 @@
+import { Command } from "../command"
+/**
+ * @see https://redis.io/commands/mget
+ */
+export class MGetCommand<TData extends unknown[]> extends Command<TData, (string | null)[]> {
+  constructor(...keys: [string, ...string[]]) {
+    super(["mget", ...keys])
+  }
+}

package/pkg/commands/mset.test.ts

@@ -0,0 +1,24 @@
+import { keygen, newHttpClient } from "../test-utils"
+import { randomUUID } from "crypto"
+import { it, expect, afterAll } from "@jest/globals"
+import { MSetCommand } from "./mset"
+import { MGetCommand } from "./mget"
+
+const client = newHttpClient()
+
+const { newKey, cleanup } = keygen()
+afterAll(cleanup)
+
+it("gets exiting values", async () => {
+  const key1 = newKey()
+  const key2 = newKey()
+  const kv = {
+    [key1]: randomUUID(),
+    [key2]: randomUUID(),
+  }
+  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,10 @@
+import { Command } from "../command"
+
+/**
+ * @see https://redis.io/commands/mset
+ */
+export class MSetCommand<TData> extends Command<"OK", "OK"> {
+  constructor(kv: { [key: string]: TData }) {
+    super(["mset", ...Object.entries(kv).flatMap(([key, value]) => [key, value])])
+  }
+}

package/pkg/commands/msetnx.test.ts

@@ -0,0 +1,46 @@
+import { keygen, newHttpClient } from "../test-utils"
+import { randomUUID } from "crypto"
+import { it, expect, afterAll } from "@jest/globals"
+import { MGetCommand } from "./mget"
+import { SetCommand } from "./set"
+import { GetCommand } from "./get"
+import { MSetNXCommand } from "./msetnx"
+const client = newHttpClient()
+
+const { newKey, cleanup } = keygen()
+afterAll(cleanup)
+
+it("sets values", async () => {
+  const key1 = newKey()
+  const value1 = randomUUID()
+  const key2 = newKey()
+  const value2 = randomUUID()
+
+  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])
+})
+
+it("does not set values if one key already exists", async () => {
+  const key1 = newKey()
+  const value1 = randomUUID()
+  const key2 = newKey()
+  const value2 = randomUUID()
+  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).toBeNull()
+})

package/pkg/commands/msetnx.ts

@@ -0,0 +1,10 @@
+import { Command } from "../command"
+
+/**
+ * @see https://redis.io/commands/msetnx
+ */
+export class MSetNXCommand<TData = string> extends Command<number, number> {
+  constructor(kv: { [key: string]: TData }) {
+    super(["msetnx", ...Object.entries(kv).flatMap((_) => _)])
+  }
+}