@upstash/redis 0.2.1 → 1.0.0-alpha.2

package/pkg/commands/sscan.ts

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

package/pkg/commands/strlen.test.ts

@@ -0,0 +1,16 @@
+import { keygen, newHttpClient } from "../test-utils"
+import { it, expect, afterAll } from "@jest/globals"
+import { SetCommand } from "./set"
+import { StrLenCommand } from "./strlen"
+const client = newHttpClient()
+
+const { newKey, cleanup } = keygen()
+afterAll(cleanup)
+
+it("returns the correct length", async () => {
+  const key = newKey()
+  const value = "abcd"
+  await new SetCommand(key, value).exec(client)
+  const res = await new StrLenCommand(key).exec(client)
+  expect(res).toBe(value.length)
+})

package/pkg/commands/strlen.ts

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

package/pkg/commands/sunion.test.ts

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

package/pkg/commands/sunion.ts

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

package/pkg/commands/sunionstore.test.ts

@@ -0,0 +1,29 @@
+import { keygen, newHttpClient } from "../test-utils"
+import { randomUUID } from "crypto"
+import { it, expect, afterAll } from "@jest/globals"
+import { SAddCommand } from "./sadd"
+import { SUnionStoreCommand } from "./sunionstore"
+import { SMembersCommand } from "./smembers"
+const client = newHttpClient()
+
+const { newKey, cleanup } = keygen()
+afterAll(cleanup)
+
+it("writes the union to destination", async () => {
+  const key1 = newKey()
+  const key2 = newKey()
+  const dest = newKey()
+
+  const member1 = randomUUID()
+  const member2 = randomUUID()
+
+  await new SAddCommand(key1, member1).exec(client)
+  await new SAddCommand(key2, member2).exec(client)
+  const res = await new SUnionStoreCommand(dest, key1, key2).exec(client)
+  expect(res).toBe(2)
+
+  const res2 = await new SMembersCommand(dest).exec(client)
+
+  expect(res2).toBeDefined()
+  expect(res2!.sort()).toEqual([member1, member2].sort())
+})

package/pkg/commands/sunionstore.ts

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

package/pkg/commands/time.test.ts

@@ -0,0 +1,11 @@
+import { newHttpClient } from "../test-utils"
+import { it, expect } from "@jest/globals"
+import { TimeCommand } from "./time"
+const client = newHttpClient()
+
+it("returns the time", async () => {
+  const res = await new TimeCommand().exec(client)
+  expect(res).toBeDefined()
+  expect(typeof res[0]).toBe("number")
+  expect(typeof res[1]).toBe("number")
+})

package/pkg/commands/time.ts

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

package/pkg/commands/touch.test.ts

@@ -0,0 +1,20 @@
+import { keygen, newHttpClient } from "../test-utils"
+import { randomUUID } from "crypto"
+import { it, expect, afterAll } from "@jest/globals"
+import { MSetCommand } from "./mset"
+import { TouchCommand } from "./touch"
+const client = newHttpClient()
+
+const { newKey, cleanup } = keygen()
+afterAll(cleanup)
+
+it("returns the number of touched keys", async () => {
+  const key1 = newKey()
+  const key2 = newKey()
+  const kv: Record<string, string> = {}
+  kv[key1] = randomUUID()
+  kv[key2] = randomUUID()
+  await new MSetCommand(kv).exec(client)
+  const res = await new TouchCommand(key1, key2).exec(client)
+  expect(res).toBe(2)
+})

package/pkg/commands/touch.ts

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

package/pkg/commands/ttl.test.ts

@@ -0,0 +1,17 @@
+import { keygen, newHttpClient } from "../test-utils"
+
+import { it, expect, afterAll } from "@jest/globals"
+import { SetExCommand } from "./setex"
+import { TtlCommand } from "./ttl"
+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 TtlCommand(key).exec(client)
+  expect(res).toBeLessThanOrEqual(ttl)
+})

package/pkg/commands/ttl.ts

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

package/pkg/commands/type.test.ts

@@ -0,0 +1,72 @@
+import { keygen, newHttpClient } from "../test-utils"
+import { randomUUID } from "crypto"
+import { describe, it, expect, afterAll } from "@jest/globals"
+import { SetCommand } from "./set"
+import { TypeCommand } from "./type"
+import { LPushCommand } from "./lpush"
+import { HSetCommand } from "./hset"
+import { SAddCommand } from "./sadd"
+import { ZAddCommand } from "./zadd"
+const client = newHttpClient()
+
+const { newKey, cleanup } = keygen()
+afterAll(cleanup)
+
+describe("string", () => {
+  it("returns the correct type", async () => {
+    const key = newKey()
+    const value = randomUUID()
+    await new SetCommand(key, value).exec(client)
+    const res = await new TypeCommand(key).exec(client)
+    expect(res).toEqual("string")
+  })
+})
+
+describe("list", () => {
+  it("returns the correct type", async () => {
+    const key = newKey()
+    const value = randomUUID()
+    await new LPushCommand(key, value).exec(client)
+    const res = await new TypeCommand(key).exec(client)
+    expect(res).toEqual("list")
+  })
+})
+
+describe("set", () => {
+  it("returns the correct type", async () => {
+    const key = newKey()
+    const value = randomUUID()
+    await new SAddCommand(key, value).exec(client)
+    const res = await new TypeCommand(key).exec(client)
+    expect(res).toEqual("set")
+  })
+})
+
+describe("hash", () => {
+  it("returns the correct type", async () => {
+    const key = newKey()
+    const field = randomUUID()
+    const value = randomUUID()
+    await new HSetCommand(key, field, value).exec(client)
+    const res = await new TypeCommand(key).exec(client)
+    expect(res).toEqual("hash")
+  })
+})
+
+describe("zset", () => {
+  it("returns the correct type", async () => {
+    const key = newKey()
+    const member = randomUUID()
+    await new ZAddCommand(key, { score: 0, member }).exec(client)
+    const res = await new TypeCommand(key).exec(client)
+    expect(res).toEqual("zset")
+  })
+})
+
+describe("none", () => {
+  it("returns the correct type", async () => {
+    const key = newKey()
+    const res = await new TypeCommand(key).exec(client)
+    expect(res).toEqual("none")
+  })
+})

package/pkg/commands/type.ts

@@ -0,0 +1,11 @@
+import { Command } from "../command"
+
+export type Type = "string" | "list" | "set" | "zset" | "hash" | "none"
+/**
+ * @see https://redis.io/commands/type
+ */
+export class TypeCommand extends Command<Type, Type> {
+  constructor(key: string) {
+    super(["type", key])
+  }
+}

package/pkg/commands/unlink.test.ts

@@ -0,0 +1,21 @@
+import { keygen, newHttpClient } from "../test-utils"
+import { randomUUID } from "crypto"
+import { it, expect, afterAll } from "@jest/globals"
+import { MSetCommand } from "./mset"
+import { UnlinkCommand } from "./unlink"
+const client = newHttpClient()
+
+const { newKey, cleanup } = keygen()
+afterAll(cleanup)
+
+it("unlinks the keys", async () => {
+  const key1 = newKey()
+  const key2 = newKey()
+  const key3 = newKey()
+  const kv: Record<string, string> = {}
+  kv[key1] = randomUUID()
+  kv[key2] = randomUUID()
+  await new MSetCommand(kv).exec(client)
+  const res = await new UnlinkCommand(key1, key2, key3).exec(client)
+  expect(res).toEqual(2)
+})

package/pkg/commands/unlink.ts

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

package/pkg/commands/zadd.test.ts

@@ -0,0 +1,177 @@
+import { keygen, newHttpClient } from "../test-utils"
+import { randomInt, randomUUID } from "crypto"
+import { describe, it, expect, afterAll } from "@jest/globals"
+import { ZAddCommand } from "./zadd"
+import { ZScoreCommand } from "./zscore"
+const client = newHttpClient()
+
+const { newKey, cleanup } = keygen()
+afterAll(cleanup)
+
+describe("command format", () => {
+  describe("without options", () => {
+    it("build the correct command", () => {
+      expect(new ZAddCommand("key", { score: 0, member: "member" }).command).toEqual([
+        "zadd",
+        "key",
+        "0",
+        "member",
+      ])
+    })
+  })
+  describe("with nx", () => {
+    it("build the correct command", () => {
+      expect(new ZAddCommand("key", { nx: true }, { score: 0, member: "member" }).command).toEqual([
+        "zadd",
+        "key",
+        "nx",
+        "0",
+        "member",
+      ])
+    })
+  })
+  describe("with xx", () => {
+    it("build the correct command", () => {
+      expect(new ZAddCommand("key", { xx: true }, { score: 0, member: "member" }).command).toEqual([
+        "zadd",
+        "key",
+        "xx",
+        "0",
+        "member",
+      ])
+    })
+  })
+  describe("with ch", () => {
+    it("build the correct command", () => {
+      expect(new ZAddCommand("key", { ch: true }, { score: 0, member: "member" }).command).toEqual([
+        "zadd",
+        "key",
+        "ch",
+        "0",
+        "member",
+      ])
+    })
+  })
+  describe("with incr", () => {
+    it("build the correct command", () => {
+      expect(
+        new ZAddCommand("key", { incr: true }, { score: 0, member: "member" }).command,
+      ).toEqual(["zadd", "key", "incr", "0", "member"])
+    })
+  })
+  describe("with nx and ch", () => {
+    it("build the correct command", () => {
+      expect(
+        new ZAddCommand("key", { nx: true, ch: true }, { score: 0, member: "member" }).command,
+      ).toEqual(["zadd", "key", "nx", "ch", "0", "member"])
+    })
+  })
+  describe("with nx,ch and incr", () => {
+    it("build the correct command", () => {
+      expect(
+        new ZAddCommand("key", { nx: true, ch: true, incr: true }, { score: 0, member: "member" })
+          .command,
+      ).toEqual(["zadd", "key", "nx", "ch", "incr", "0", "member"])
+    })
+  })
+  describe("with nx and multiple members", () => {
+    it("build the correct command", () => {
+      expect(
+        new ZAddCommand(
+          "key",
+          { nx: true },
+          { score: 0, member: "member" },
+          { score: 1, member: "member1" },
+        ).command,
+      ).toEqual(["zadd", "key", "nx", "0", "member", "1", "member1"])
+    })
+  })
+})
+
+describe("without options", () => {
+  it("adds the member", async () => {
+    const key = newKey()
+    const member = randomUUID()
+    const score = randomInt(10)
+    const res = await new ZAddCommand(key, { score, member }).exec(client)
+    expect(res).toBe(1)
+  })
+})
+
+describe("xx", () => {
+  describe("when the element exists", () => {
+    it("updates the element", async () => {
+      const key = newKey()
+      const member = randomUUID()
+      const score = randomInt(10)
+      await new ZAddCommand(key, { score, member }).exec(client)
+      const newScore = score + 1
+      const res = await new ZAddCommand(key, { xx: true }, { score: newScore, member }).exec(client)
+      expect(res).toBe(0)
+
+      const res2 = await new ZScoreCommand(key, member).exec(client)
+      expect(res2).toBe(newScore)
+    })
+  })
+  describe("when the element does not exist", () => {
+    it("does nothing", async () => {
+      const key = newKey()
+      const member = randomUUID()
+      const score = randomInt(10)
+      await new ZAddCommand(key, { score, member }).exec(client)
+      const newScore = score + 1
+      const res = await new ZAddCommand(key, { xx: true }, { score: newScore, member }).exec(client)
+      expect(res).toBe(0)
+    })
+  })
+})
+
+describe("nx", () => {
+  describe("when the element exists", () => {
+    it("does nothing", async () => {
+      const key = newKey()
+      const member = randomUUID()
+      const score = randomInt(10)
+      await new ZAddCommand(key, { score, member }).exec(client)
+      const newScore = score + 1
+      const res = await new ZAddCommand(key, { nx: true }, { score: newScore, member }).exec(client)
+      expect(res).toBe(0)
+
+      const res2 = await new ZScoreCommand(key, member).exec(client)
+      expect(res2).toBe(score)
+    })
+  })
+  describe("when the element does not exist", () => {
+    it("creates element", async () => {
+      const key = newKey()
+      const member = randomUUID()
+      const score = randomInt(10)
+      const res = await new ZAddCommand(key, { nx: true }, { score, member }).exec(client)
+      expect(res).toBe(1)
+    })
+  })
+})
+
+describe("ch", () => {
+  it("returns the number of changed elements", async () => {
+    const key = newKey()
+    const member = randomUUID()
+    const score = randomInt(10)
+    await new ZAddCommand(key, { score, member }).exec(client)
+    const newScore = score + 1
+    const res = await new ZAddCommand(key, { ch: true }, { score: newScore, member }).exec(client)
+    expect(res).toBe(1)
+  })
+})
+
+describe("incr", () => {
+  it("returns the number of changed elements", async () => {
+    const key = newKey()
+    const member = randomUUID()
+    const score = randomInt(10)
+    await new ZAddCommand(key, { score, member }).exec(client)
+    const newScore = score + 1
+    const res = await new ZAddCommand(key, { ch: true }, { score: newScore, member }).exec(client)
+    expect(res).toBe(1)
+  })
+})

package/pkg/commands/zadd.ts

@@ -0,0 +1,64 @@
+import { Command } from "../command"
+
+export type ZAddCommandOptions = (
+  | {
+      nx: true
+      xx?: never
+    }
+  | {
+      nx?: never
+      xx: true
+    }
+  | { nx?: never; xx?: never }
+) & { ch?: true }
+
+export type ZAddCommandOptionsWithIncr = ZAddCommandOptions & {
+  incr: true
+}
+
+export type ScoreMember<TData> = {
+  score: number
+  member: TData
+}
+/**
+ * @see https://redis.io/commands/zadd
+ */
+export class ZAddCommand<TData = string> extends Command<number | null, number | null> {
+  constructor(
+    key: string,
+    scoreMember: ScoreMember<TData>,
+    ...scoreMemberPairs: ScoreMember<TData>[]
+  )
+  constructor(
+    key: string,
+    opts: ZAddCommandOptions | ZAddCommandOptionsWithIncr,
+    ...scoreMemberPairs: [ScoreMember<TData>, ...ScoreMember<TData>[]]
+  )
+  constructor(
+    key: string,
+    arg1: ScoreMember<TData> | ZAddCommandOptions | ZAddCommandOptionsWithIncr,
+    ...arg2: ScoreMember<TData>[]
+  ) {
+    const command: unknown[] = ["zadd", key]
+
+    if ("nx" in arg1 && arg1.nx) {
+      command.push("nx")
+    } else if ("xx" in arg1 && arg1.xx) {
+      command.push("xx")
+    }
+    if ("ch" in arg1 && arg1.ch) {
+      command.push("ch")
+    }
+    if ("incr" in arg1 && arg1.incr) {
+      command.push("incr")
+    }
+
+    if ("score" in arg1 && "member" in arg1) {
+      command.push(arg1.score, arg1.member)
+    }
+
+    command.push(...arg2.flatMap(({ score, member }) => [score, member]))
+
+    super(command)
+  }
+}

package/pkg/commands/zcard.test.ts

@@ -0,0 +1,15 @@
+import { keygen, newHttpClient } from "../test-utils"
+import { it, expect, afterAll } from "@jest/globals"
+import { ZAddCommand } from "./zadd"
+import { ZCardCommand } from "./zcard"
+const client = newHttpClient()
+
+const { newKey, cleanup } = keygen()
+afterAll(cleanup)
+
+it("returns the cardinality", async () => {
+  const key = newKey()
+  await new ZAddCommand(key, { score: 1, member: "member1" }).exec(client)
+  const res = await new ZCardCommand(key).exec(client)
+  expect(res).toBe(1)
+})

package/pkg/commands/zcard.ts

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

package/pkg/commands/zcount.test.ts

@@ -0,0 +1,15 @@
+import { keygen, newHttpClient } from "../test-utils"
+import { it, expect, afterAll } from "@jest/globals"
+import { ZAddCommand } from "./zadd"
+import { ZCountCommand } from "./zcount"
+const client = newHttpClient()
+
+const { newKey, cleanup } = keygen()
+afterAll(cleanup)
+
+it("returns the cardinality", async () => {
+  const key = newKey()
+  await new ZAddCommand(key, { score: 1, member: "member1" }).exec(client)
+  const res = await new ZCountCommand(key, 0, 2).exec(client)
+  expect(res).toBe(1)
+})

package/pkg/commands/zcount.ts

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

package/pkg/commands/zincrby.test.ts

@@ -0,0 +1,20 @@
+import { keygen, newHttpClient } from "../test-utils"
+import { it, expect, afterAll } from "@jest/globals"
+import { ZIncrByComand } from "./zincrby"
+import { ZAddCommand } from "./zadd"
+import { randomUUID } from "crypto"
+
+const client = newHttpClient()
+
+const { newKey, cleanup } = keygen()
+afterAll(cleanup)
+
+it("increments and existing value", async () => {
+  const key = newKey()
+  const score = 1
+  const member = randomUUID()
+  await new ZAddCommand(key, { score, member }).exec(client)
+  const res = await new ZIncrByComand(key, 2, member).exec(client)
+
+  expect(res).toEqual(3)
+})

package/pkg/commands/zincrby.ts

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