@upstash/redis 0.2.1 → 1.0.0-alpha.2

package/pkg/commands/decrby.test.ts

@@ -0,0 +1,23 @@
+import { keygen, newHttpClient } from "../test-utils"
+import { SetCommand } from "./set"
+import { DecrByCommand } from "./decrby"
+import { it, expect, afterAll } from "@jest/globals"
+const client = newHttpClient()
+
+const { newKey, cleanup } = keygen()
+afterAll(cleanup)
+
+it("decrements a non-existing value", async () => {
+  const key = newKey()
+  const res = await new DecrByCommand(key, 2).exec(client)
+
+  expect(res).toEqual(-2)
+})
+
+it("decrements and existing value", async () => {
+  const key = newKey()
+  await new SetCommand(key, 5).exec(client)
+  const res = await new DecrByCommand(key, 2).exec(client)
+
+  expect(res).toEqual(3)
+})

package/pkg/commands/decrby.ts

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

package/pkg/commands/del.test.ts

@@ -0,0 +1,38 @@
+import { keygen, newHttpClient } from "../test-utils"
+
+import { DelCommand } from "./del"
+import { SetCommand } from "./set"
+import { describe, it, expect, afterAll } from "@jest/globals"
+
+const client = newHttpClient()
+
+const { newKey, cleanup } = keygen()
+afterAll(cleanup)
+
+describe("when key does not exist", () => {
+  it("does nothing", async () => {
+    const key = newKey()
+
+    const res = await new DelCommand(key).exec(client)
+    expect(res).toEqual(0)
+  })
+})
+describe("when key does exist", () => {
+  it("deletes the key", async () => {
+    const key = newKey()
+    await new SetCommand(key, "value").exec(client)
+    const res = await new DelCommand(key).exec(client)
+    expect(res).toEqual(1)
+  })
+})
+describe("with multiple keys", () => {
+  describe("when one does not exist", () => {
+    it("deletes all keys", async () => {
+      const key1 = newKey()
+      const key2 = newKey()
+      await new SetCommand(key1, "value").exec(client)
+      const res = await new DelCommand(key1, key2).exec(client)
+      expect(res).toEqual(1)
+    })
+  })
+})

package/pkg/commands/del.ts

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

package/pkg/commands/echo.test.ts

@@ -0,0 +1,11 @@
+import { newHttpClient } from "../test-utils"
+import { randomUUID } from "crypto"
+import { it, expect } from "@jest/globals"
+import { EchoCommand } from "./echo"
+const client = newHttpClient()
+
+it("returns the message", async () => {
+  const message = randomUUID()
+  const res = await new EchoCommand(message).exec(client)
+  expect(res).toBe(message)
+})

package/pkg/commands/echo.ts

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

package/pkg/commands/exists.test.ts

@@ -0,0 +1,37 @@
+import { keygen, newHttpClient } from "../test-utils"
+import { ExistsCommand } from "./exists"
+import { describe, it, expect, afterAll } from "@jest/globals"
+import { SetCommand } from "./set"
+
+const client = newHttpClient()
+
+const { newKey, cleanup } = keygen()
+afterAll(cleanup)
+
+describe("when the key does not eist", () => {
+  it("it returns 1", async () => {
+    const key = newKey()
+
+    const res = await new ExistsCommand(key).exec(client)
+    expect(res).toEqual(0)
+  })
+})
+describe("when the key exists", () => {
+  it("it returns 1", async () => {
+    const key = newKey()
+    await new SetCommand(key, "value").exec(client)
+    const res = await new ExistsCommand(key).exec(client)
+    expect(res).toEqual(1)
+  })
+})
+describe("with multiple keys", () => {
+  it("it returns the number of found keys", async () => {
+    const key1 = newKey()
+    const key2 = newKey()
+    const key3 = newKey()
+    await new SetCommand(key1, "value").exec(client)
+    await new SetCommand(key2, "value").exec(client)
+    const res = await new ExistsCommand(key1, key2, key3).exec(client)
+    expect(res).toEqual(2)
+  })
+})

package/pkg/commands/exists.ts

@@ -0,0 +1,11 @@
+import { NonEmptyArray } from "../types"
+import { Command } from "../command"
+
+/**
+ * @see https://redis.io/commands/exists
+ */
+export class ExistsCommand extends Command<0 | 1, "0" | "1"> {
+  constructor(...keys: NonEmptyArray<string>) {
+    super(["exists", ...keys])
+  }
+}

package/pkg/commands/expire.test.ts

@@ -0,0 +1,22 @@
+import { keygen, newHttpClient } from "../test-utils"
+import { randomUUID } from "crypto"
+import { it, expect, afterAll } from "@jest/globals"
+import { SetCommand } from "./set"
+import { ExpireCommand } from "./expire"
+import { GetCommand } from "./get"
+const client = newHttpClient()
+
+const { newKey, cleanup } = keygen()
+afterAll(cleanup)
+
+it("expires a key correctly", async () => {
+  const key = newKey()
+  const value = randomUUID()
+  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).toBeNull()
+})

package/pkg/commands/expire.ts

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

package/pkg/commands/expireat.test.ts

@@ -0,0 +1,24 @@
+import { keygen, newHttpClient } from "../test-utils"
+import { randomUUID } from "crypto"
+import { describe, it, expect, afterAll } from "@jest/globals"
+import { SetCommand } from "./set"
+import { GetCommand } from "./get"
+import { ExpireAtCommand } from "./expireat"
+const client = newHttpClient()
+
+const { newKey, cleanup } = keygen()
+afterAll(cleanup)
+
+describe("without options", () => {
+  it("expires the key", async () => {
+    const key = newKey()
+    const value = randomUUID()
+    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).toBeNull
+  })
+})

package/pkg/commands/expireat.ts

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

package/pkg/commands/flushall.test.ts

@@ -0,0 +1,17 @@
+import { newHttpClient } from "../test-utils"
+import { describe, it, expect } from "@jest/globals"
+import { FlushAllCommand } from "./flushall"
+const client = newHttpClient()
+
+describe("without options", () => {
+  it("flushes the db", async () => {
+    const res = await new FlushAllCommand().exec(client)
+    expect(res).toBe("OK")
+  })
+})
+describe("async", () => {
+  it("flushes the db", async () => {
+    const res = await new FlushAllCommand({ async: true }).exec(client)
+    expect(res).toBe("OK")
+  })
+})

package/pkg/commands/flushall.ts

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

package/pkg/commands/flushdb.test.ts

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

package/pkg/commands/flushdb.ts

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

package/pkg/commands/get.test.ts

@@ -0,0 +1,34 @@
+import { keygen, newHttpClient } from "../test-utils"
+import { randomUUID } from "crypto"
+import { it, expect, afterAll } from "@jest/globals"
+import { SetCommand } from "./set"
+import { GetCommand } from "./get"
+const client = newHttpClient()
+
+const { newKey, cleanup } = keygen()
+afterAll(cleanup)
+
+it("gets an exiting value", async () => {
+  const key = newKey()
+  const value = randomUUID()
+  await new SetCommand(key, value).exec(client)
+  const res = await new GetCommand(key).exec(client)
+
+  expect(res).toEqual(value)
+})
+
+it("gets a non-existing value", async () => {
+  const key = newKey()
+  const res = await new GetCommand(key).exec(client)
+
+  expect(res).toBeNull()
+})
+
+it("gets an object", async () => {
+  const key = newKey()
+  const value = { v: randomUUID() }
+  await new SetCommand(key, value).exec(client)
+  const res = await new GetCommand(key).exec(client)
+
+  expect(res).toEqual(value)
+})

package/pkg/commands/get.ts

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

package/pkg/commands/getbit.test.ts

@@ -0,0 +1,16 @@
+import { keygen, newHttpClient } from "../test-utils"
+import { it, expect, afterAll } from "@jest/globals"
+import { SetBitCommand } from "./setbit"
+import { GetBitCommand } from "./getbit"
+const client = newHttpClient()
+
+const { newKey, cleanup } = keygen()
+afterAll(cleanup)
+
+it("returns the bit at offset", async () => {
+  const key = newKey()
+
+  await new SetBitCommand(key, 0, 1).exec(client)
+  const res = await new GetBitCommand(key, 0).exec(client)
+  expect(res).toBe(1)
+})

package/pkg/commands/getbit.ts

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

package/pkg/commands/getrange.test.ts

@@ -0,0 +1,25 @@
+import { keygen, newHttpClient } from "../test-utils"
+import { it, expect, afterAll } from "@jest/globals"
+import { GetRangeCommand } from "./getrange"
+import { SetCommand } from "./set"
+const client = newHttpClient()
+
+const { newKey, cleanup } = keygen()
+afterAll(cleanup)
+
+it("gets an exiting value", async () => {
+  const key = newKey()
+  const value = "Hello World"
+  await new SetCommand(key, value).exec(client)
+  const res = await new GetRangeCommand(key, 2, 4).exec(client)
+
+  expect(res).toBeDefined()
+  expect(res!).toEqual(value.slice(2, 5))
+})
+
+it("gets a non-existing value", async () => {
+  const key = newKey()
+  const res = await new GetRangeCommand(key, 10, 24).exec(client)
+
+  expect(res).toEqual("")
+})

package/pkg/commands/getrange.ts

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

package/pkg/commands/getset.test.ts

@@ -0,0 +1,33 @@
+import { keygen, newHttpClient } from "../test-utils"
+import { randomUUID } from "crypto"
+import { it, expect, afterAll } from "@jest/globals"
+import { GetSetCommand } from "./getset"
+import { SetCommand } from "./set"
+import { GetCommand } from "./get"
+const client = newHttpClient()
+
+const { newKey, cleanup } = keygen()
+afterAll(cleanup)
+
+it("overwrites the original value", async () => {
+  const key = newKey()
+  const value = randomUUID()
+  const newValue = randomUUID()
+  await new SetCommand(key, value).exec(client)
+  const res = await new GetSetCommand(key, newValue).exec(client)
+
+  expect(res).toEqual(value)
+  const res2 = await new GetCommand(key).exec(client)
+
+  expect(res2).toEqual(newValue)
+})
+it("sets a new value if empty", async () => {
+  const key = newKey()
+  const newValue = randomUUID()
+  const res = await new GetSetCommand(key, newValue).exec(client)
+
+  expect(res).toBeNull()
+  const res2 = await new GetCommand(key).exec(client)
+
+  expect(res2).toEqual(newValue)
+})

package/pkg/commands/getset.ts

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

package/pkg/commands/hdel.test.ts

@@ -0,0 +1,30 @@
+import { keygen, newHttpClient } from "../test-utils"
+import { randomUUID } from "crypto"
+import { it, expect, afterAll } from "@jest/globals"
+import { HDelCommand } from "./hdel"
+import { HSetCommand } from "./hset"
+import { HGetCommand } from "./hget"
+const client = newHttpClient()
+
+const { newKey, cleanup } = keygen()
+afterAll(cleanup)
+
+it("deletes a hash that does not exist", async () => {
+  const key = newKey()
+  const field = randomUUID()
+  const res = await new HDelCommand(key, field).exec(client)
+
+  expect(res).toEqual(0)
+})
+
+it("deletes a field that exists", async () => {
+  const key = newKey()
+  const field = randomUUID()
+  await new HSetCommand(key, field, randomUUID()).exec(client)
+  const res = await new HDelCommand(key, field).exec(client)
+
+  expect(res).toEqual(1)
+  const res2 = await new HGetCommand(key, field).exec(client)
+
+  expect(res2).toEqual(null)
+})

package/pkg/commands/hdel.ts

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

package/pkg/commands/hexists.test.ts

@@ -0,0 +1,31 @@
+import { keygen, newHttpClient } from "../test-utils"
+import { randomUUID } from "crypto"
+import { it, expect, afterAll } from "@jest/globals"
+import { HSetCommand } from "./hset"
+import { HExistsCommand } from "./hexists"
+
+const client = newHttpClient()
+
+const { newKey, cleanup } = keygen()
+afterAll(cleanup)
+
+it("returns 1 for an existing field", async () => {
+  const key = newKey()
+  const field = randomUUID()
+  await new HSetCommand(key, field, randomUUID()).exec(client)
+  const res = await new HExistsCommand(key, field).exec(client)
+  expect(res).toEqual(1)
+})
+it("returns 0 if field does not exist", async () => {
+  const key = newKey()
+  await new HSetCommand(key, randomUUID(), randomUUID()).exec(client)
+
+  const res = await new HExistsCommand(key, "not-existing-field").exec(client)
+  expect(res).toEqual(0)
+})
+it("returns 0 if hash does not exist", async () => {
+  const key = newKey()
+  const field = randomUUID()
+  const res = await new HExistsCommand(key, field).exec(client)
+  expect(res).toEqual(0)
+})

package/pkg/commands/hexists.ts

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

package/pkg/commands/hget.test.ts

@@ -0,0 +1,47 @@
+import { keygen, newHttpClient } from "../test-utils"
+import { randomUUID } from "crypto"
+import { it, expect, afterAll } from "@jest/globals"
+import { HSetCommand } from "./hset"
+import { HGetCommand } from "./hget"
+
+const client = newHttpClient()
+
+const { newKey, cleanup } = keygen()
+afterAll(cleanup)
+
+it("gets an exiting value", async () => {
+  const key = newKey()
+  const field = randomUUID()
+  const value = randomUUID()
+  await new HSetCommand(key, field, value).exec(client)
+  const res = await new HGetCommand(key, field).exec(client)
+
+  expect(res).toEqual(value)
+})
+
+it("gets a non-existing hash", async () => {
+  const key = newKey()
+  const field = randomUUID()
+  const res = await new HGetCommand(key, field).exec(client)
+
+  expect(res).toBeNull()
+})
+
+it("gets a non-existing field", async () => {
+  const key = newKey()
+  const field = randomUUID()
+  await new HSetCommand(key, randomUUID(), randomUUID()).exec(client)
+  const res = await new HGetCommand(key, field).exec(client)
+
+  expect(res).toBeNull()
+})
+
+it("gets an object", async () => {
+  const key = newKey()
+  const field = randomUUID()
+  const value = { v: randomUUID() }
+  await new HSetCommand(key, field, value).exec(client)
+  const res = await new HGetCommand(key, field).exec(client)
+
+  expect(res).toEqual(value)
+})

package/pkg/commands/hget.ts

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

package/pkg/commands/hgetall.test.ts

@@ -0,0 +1,32 @@
+import { keygen, newHttpClient } from "../test-utils"
+import { randomUUID } from "crypto"
+import { describe, it, expect, afterAll } from "@jest/globals"
+import { HSetCommand } from "./hset"
+import { HGetAllCommand } from "./hgetall"
+
+const client = newHttpClient()
+
+const { newKey, cleanup } = keygen()
+afterAll(cleanup)
+it("returns all fields", async () => {
+  const key = newKey()
+  const field2 = randomUUID()
+  const field1 = randomUUID()
+  const value1 = false
+  const value2 = randomUUID()
+  await new HSetCommand(key, field1, value1).exec(client)
+  await new HSetCommand(key, field2, value2).exec(client)
+  const res = await new HGetAllCommand(key).exec(client)
+
+  const obj = {
+    [field1]: value1,
+    [field2]: value2,
+  }
+  expect(res).toEqual(obj)
+})
+describe("when hash does not exist", () => {
+  it("it returns null", async () => {
+    const res = await new HGetAllCommand(randomUUID()).exec(client)
+    expect(res).toBeNull()
+  })
+})