@upstash/redis 0.2.1 → 1.0.0-alpha.2

package/pkg/commands/persist.test.ts

@@ -0,0 +1,22 @@
+import { keygen, newHttpClient } from "../test-utils"
+import { randomUUID } from "crypto"
+import { SetCommand } from "./set"
+import { it, expect, afterAll } from "@jest/globals"
+import { PersistCommand } from "./persist"
+import { GetCommand } from "./get"
+const client = newHttpClient()
+
+const { newKey, cleanup } = keygen()
+afterAll(cleanup)
+
+it("persists the key", async () => {
+  const key = newKey()
+  const value = randomUUID()
+  await new SetCommand(key, value, { ex: 2 }).exec(client)
+  const res = await new PersistCommand(key).exec(client)
+  expect(res).toBe(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,10 @@
+import { Command } from "../command"
+
+/**
+ * @see https://redis.io/commands/persist
+ */
+export class PersistCommand extends Command<0 | 1, "0" | "1"> {
+  constructor(key: string) {
+    super(["persist", key])
+  }
+}

package/pkg/commands/pexpire.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 { PExpireCommand } from "./pexpire"
+import { GetCommand } from "./get"
+const client = newHttpClient()
+
+const { newKey, cleanup } = keygen()
+afterAll(cleanup)
+
+describe("without options", () => {
+  it("expires a key correctly", async () => {
+    const key = newKey()
+    const value = randomUUID()
+    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).toBeNull()
+  })
+})

package/pkg/commands/pexpire.ts

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

package/pkg/commands/pexpireat.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 { PExpireAtCommand } from "./pexpireat"
+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 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).toBeNull
+  })
+})

package/pkg/commands/pexpireat.ts

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

package/pkg/commands/ping.test.ts

@@ -0,0 +1,19 @@
+import { newHttpClient } from "../test-utils"
+import { randomUUID } from "crypto"
+import { describe, it, expect } from "@jest/globals"
+import { PingCommand } from "./ping"
+const client = newHttpClient()
+
+describe("with message", () => {
+  it("returns the message", async () => {
+    const message = randomUUID()
+    const res = await new PingCommand(message).exec(client)
+    expect(res).toBe(message)
+  })
+})
+describe("without message", () => {
+  it("returns pong", async () => {
+    const res = await new PingCommand().exec(client)
+    expect(res).toBe("PONG")
+  })
+})

package/pkg/commands/ping.ts

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

package/pkg/commands/psetex.test.ts

@@ -0,0 +1,23 @@
+import { keygen, newHttpClient } from "../test-utils"
+import { randomUUID } from "crypto"
+import { it, expect, afterAll } from "@jest/globals"
+
+import { PSetEXCommand } from "./psetex"
+import { GetCommand } from "./get"
+const client = newHttpClient()
+
+const { newKey, cleanup } = keygen()
+afterAll(cleanup)
+
+it("sets value", async () => {
+  const key = newKey()
+  const value = randomUUID()
+
+  const res = await new PSetEXCommand(key, 1000, value).exec(client)
+
+  expect(res).toEqual("OK")
+  await new Promise((res) => setTimeout(res, 2000))
+  const res2 = await new GetCommand(key).exec(client)
+
+  expect(res2).toBeNull()
+})

package/pkg/commands/psetex.ts

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

package/pkg/commands/pttl.test.ts

@@ -0,0 +1,17 @@
+import { keygen, newHttpClient } from "../test-utils"
+
+import { it, expect, afterAll } from "@jest/globals"
+import { SetExCommand } from "./setex"
+import { PTtlCommand } from "./pttl"
+const client = newHttpClient()
+
+const { newKey, cleanup } = keygen()
+afterAll(cleanup)
+
+it("returns the ttl on a key", async () => {
+  const key = newKey()
+  const ttl = 60
+  await new SetExCommand(key, ttl, "value").exec(client)
+  const res = await new PTtlCommand(key).exec(client)
+  expect(res).toBeLessThanOrEqual(ttl * 1000)
+})

package/pkg/commands/pttl.ts

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

package/pkg/commands/randomkey.test.ts

@@ -0,0 +1,17 @@
+import { keygen, newHttpClient } from "../test-utils"
+import { randomUUID } from "crypto"
+import { it, expect, afterAll } from "@jest/globals"
+import { SetCommand } from "./set"
+import { RandomKeyCommand } from "./randomkey"
+const client = newHttpClient()
+
+const { newKey, cleanup } = keygen()
+afterAll(cleanup)
+
+it("returns a random key", async () => {
+  const key = newKey()
+  await new SetCommand(key, randomUUID()).exec(client)
+  const res = await new RandomKeyCommand().exec(client)
+  expect(res).toBeDefined()
+  expect(typeof res).toBe("string")
+})

package/pkg/commands/randomkey.ts

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

package/pkg/commands/rename.test.ts

@@ -0,0 +1,18 @@
+import { keygen, newHttpClient } from "../test-utils"
+import { randomUUID } from "crypto"
+import { it, expect, afterAll } from "@jest/globals"
+import { SetCommand } from "./set"
+import { RenameCommand } from "./rename"
+const client = newHttpClient()
+
+const { newKey, cleanup } = keygen()
+afterAll(cleanup)
+
+it("renames the key", async () => {
+  const source = newKey()
+  const destination = newKey()
+  const value = randomUUID()
+  await new SetCommand(source, value).exec(client)
+  const res = await new RenameCommand(source, destination).exec(client)
+  expect(res).toBe("OK")
+})

package/pkg/commands/rename.ts

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

package/pkg/commands/renamenx.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 { SetCommand } from "./set"
+import { RenameNXCommand } from "./renamenx"
+const client = newHttpClient()
+
+const { newKey, cleanup } = keygen()
+afterAll(cleanup)
+
+describe("when the key exists", () => {
+  it("does nothing", async () => {
+    const source = newKey()
+    const destination = newKey()
+    const sourceValue = randomUUID()
+    const destinationValue = randomUUID()
+    await new SetCommand(source, sourceValue).exec(client)
+    await new SetCommand(destination, destinationValue).exec(client)
+    const res = await new RenameNXCommand(source, destination).exec(client)
+    expect(res).toBe(0)
+  })
+})
+describe("when the key does not exist", () => {
+  it("renames the key", async () => {
+    const source = newKey()
+    const destination = newKey()
+    const value = randomUUID()
+    await new SetCommand(source, value).exec(client)
+    const res = await new RenameNXCommand(source, destination).exec(client)
+    expect(res).toBe(1)
+  })
+})

package/pkg/commands/renamenx.ts

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

package/pkg/commands/rpop.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 { RPopCommand } from "./rpop"
+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 RPopCommand(key).exec(client)
+    expect(res).toEqual(value)
+  })
+})
+
+describe("when list does not exist", () => {
+  it("returns null", async () => {
+    const key = newKey()
+    const res = await new RPopCommand(key).exec(client)
+    expect(res).toBeNull()
+  })
+})

package/pkg/commands/rpop.ts

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

package/pkg/commands/rpush.test.ts

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

package/pkg/commands/rpush.ts

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

package/pkg/commands/rpushx.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 { RPushXCommand } from "./rpushx"
+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 RPushXCommand(key, randomUUID()).exec(client)
+    expect(res).toEqual(2)
+    const res2 = await new RPushXCommand(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 RPushXCommand(key, randomUUID()).exec(client)
+    expect(res).toEqual(0)
+  })
+})

package/pkg/commands/rpushx.ts

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

package/pkg/commands/sadd.test.ts

@@ -0,0 +1,16 @@
+import { keygen, newHttpClient } from "../test-utils"
+import { randomUUID } from "crypto"
+import { it, expect, afterAll } from "@jest/globals"
+import { SAddCommand } from "./sadd"
+const client = newHttpClient()
+
+const { newKey, cleanup } = keygen()
+afterAll(cleanup)
+
+it("returns the number of added members", async () => {
+  const key = newKey()
+  const value1 = randomUUID()
+  const value2 = randomUUID()
+  const res = await new SAddCommand(key, value1, value2).exec(client)
+  expect(res).toBe(2)
+})

package/pkg/commands/sadd.ts

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

package/pkg/commands/scan.test.ts

@@ -0,0 +1,50 @@
+import { keygen, newHttpClient } from "../test-utils"
+import { randomUUID } from "crypto"
+import { it, describe, expect, afterAll } from "@jest/globals"
+import { SetCommand } from "./set"
+import { ScanCommand } from "./scan"
+const client = newHttpClient()
+
+const { newKey, cleanup } = keygen()
+afterAll(cleanup)
+describe("without options", () => {
+  it("returns cursor and keys", async () => {
+    const key = newKey()
+    const value = randomUUID()
+    await new SetCommand(key, value).exec(client)
+    const res = await new ScanCommand(0).exec(client)
+
+    expect(res).toBeDefined()
+    expect(res.length).toBe(2)
+    expect(typeof res[0]).toBe("number")
+    expect(res![1].length).toBeGreaterThan(0)
+  })
+})
+
+describe("with match", () => {
+  it("returns cursor and keys", async () => {
+    const key = newKey()
+    const value = randomUUID()
+    await new SetCommand(key, value).exec(client)
+    const res = await new ScanCommand(0, { match: key }).exec(client)
+
+    expect(res).toBeDefined()
+    expect(res.length).toBe(2)
+    expect(typeof res[0]).toBe("number")
+    expect(res![1].length).toBeGreaterThan(0)
+  })
+})
+
+describe("with count", () => {
+  it("returns cursor and keys", async () => {
+    const key = newKey()
+    const value = randomUUID()
+    await new SetCommand(key, value).exec(client)
+    const res = await new ScanCommand(0, { count: 1 }).exec(client)
+
+    expect(res).toBeDefined()
+    expect(res.length).toBe(2)
+    expect(typeof res[0]).toBe("number")
+    expect(res![1].length).toBeGreaterThan(0)
+  })
+})

package/pkg/commands/scan.ts

@@ -0,0 +1,21 @@
+import { Command } from "../command"
+
+export type ScanCommandOptions = {
+  match?: string
+  count?: number
+}
+/**
+ * @see https://redis.io/commands/scan
+ */
+export class ScanCommand extends Command<[number, string[]], [number, string[]]> {
+  constructor(cursor: number, opts?: ScanCommandOptions) {
+    const command = ["scan", cursor]
+    if (opts?.match) {
+      command.push("match", opts.match)
+    }
+    if (typeof opts?.count === "number") {
+      command.push("count", opts.count)
+    }
+    super(command)
+  }
+}

package/pkg/commands/scard.test.ts

@@ -0,0 +1,15 @@
+import { keygen, newHttpClient } from "../test-utils"
+import { it, expect, afterAll } from "@jest/globals"
+import { SAddCommand } from "./sadd"
+import { SCardCommand } from "./scard"
+const client = newHttpClient()
+
+const { newKey, cleanup } = keygen()
+afterAll(cleanup)
+
+it("returns the cardinality", async () => {
+  const key = newKey()
+  await new SAddCommand(key, "member1").exec(client)
+  const res = await new SCardCommand(key).exec(client)
+  expect(res).toBe(1)
+})

package/pkg/commands/scard.ts

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

package/pkg/commands/sdiff.test.ts

@@ -0,0 +1,20 @@
+import { keygen, newHttpClient } from "../test-utils"
+import { randomUUID } from "crypto"
+import { it, expect, afterAll } from "@jest/globals"
+import { SAddCommand } from "./sadd"
+import { SDiffCommand } from "./sdiff"
+const client = newHttpClient()
+
+const { newKey, cleanup } = keygen()
+afterAll(cleanup)
+
+it("returns the diff", async () => {
+  const key1 = newKey()
+  const member1 = randomUUID()
+  const key2 = newKey()
+  const member2 = randomUUID()
+  await new SAddCommand(key1, member1).exec(client)
+  await new SAddCommand(key2, member2).exec(client)
+  const res = await new SDiffCommand(key1, key2).exec(client)
+  expect(res).toEqual([member1])
+})

package/pkg/commands/sdiff.ts

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

package/pkg/commands/sdiffstore.test.ts

@@ -0,0 +1,21 @@
+import { keygen, newHttpClient } from "../test-utils"
+import { randomUUID } from "crypto"
+import { it, expect, afterAll } from "@jest/globals"
+import { SAddCommand } from "./sadd"
+import { SDiffStoreCommand } from "./sdiffstore"
+const client = newHttpClient()
+
+const { newKey, cleanup } = keygen()
+afterAll(cleanup)
+
+it("returns the diff", async () => {
+  const key1 = newKey()
+  const member1 = randomUUID()
+  const key2 = newKey()
+  const member2 = randomUUID()
+  const destination = newKey()
+  await new SAddCommand(key1, member1).exec(client)
+  await new SAddCommand(key2, member2).exec(client)
+  const res = await new SDiffStoreCommand(destination, key1, key2).exec(client)
+  expect(res).toEqual(1)
+})

package/pkg/commands/sdiffstore.ts

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