@upstash/redis 1.0.0-alpha.2 → 1.0.0-alpha.7

package/pkg/commands/zadd.test.ts

@@ -1,177 +0,0 @@
-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

@@ -1,64 +0,0 @@
-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

@@ -1,15 +0,0 @@
-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

@@ -1,10 +0,0 @@
-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

@@ -1,15 +0,0 @@
-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

@@ -1,9 +0,0 @@
-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

@@ -1,20 +0,0 @@
-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

@@ -1,9 +0,0 @@
-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])
-  }
-}

package/pkg/commands/zinterstore.test.ts

@@ -1,239 +0,0 @@
-import { keygen, newHttpClient } from "../test-utils"
-import { randomUUID } from "crypto"
-import { describe, it, expect, afterAll } from "@jest/globals"
-import { ZInterStoreCommand } from "./zinterstore"
-import { ZAddCommand } from "./zadd"
-
-const client = newHttpClient()
-
-const { newKey, cleanup } = keygen()
-afterAll(cleanup)
-
-describe("command format", () => {
-  describe("without options", () => {
-    it("builds the correct command", () => {
-      expect(new ZInterStoreCommand("destination", 1, "key").command).toEqual([
-        "zinterstore",
-        "destination",
-        "1",
-        "key",
-      ])
-    })
-  })
-  describe("with multiple keys", () => {
-    it("builds the correct command", () => {
-      expect(new ZInterStoreCommand("destination", 2, ["key1", "key2"]).command).toEqual([
-        "zinterstore",
-        "destination",
-        "2",
-        "key1",
-        "key2",
-      ])
-    })
-  })
-  describe("with single weight", () => {
-    it("builds the correct command", () => {
-      expect(new ZInterStoreCommand("destination", 1, "key", { weight: 4 }).command).toEqual([
-        "zinterstore",
-        "destination",
-        "1",
-        "key",
-        "weights",
-        "4",
-      ])
-    })
-  })
-  describe("with multiple weights", () => {
-    it("builds the correct command", () => {
-      expect(
-        new ZInterStoreCommand("destination", 2, ["key1", "key2"], { weights: [2, 3] }).command,
-      ).toEqual(["zinterstore", "destination", "2", "key1", "key2", "weights", "2", "3"])
-    })
-    describe("with aggregate", () => {
-      describe("sum", () => {
-        it("builds the correct command", () => {
-          expect(
-            new ZInterStoreCommand("destination", 1, "key", { aggregate: "sum" }).command,
-          ).toEqual(["zinterstore", "destination", "1", "key", "aggregate", "sum"])
-        })
-      })
-      describe("min", () => {
-        it("builds the correct command", () => {
-          expect(
-            new ZInterStoreCommand("destination", 1, "key", { aggregate: "min" }).command,
-          ).toEqual(["zinterstore", "destination", "1", "key", "aggregate", "min"])
-        })
-      })
-      describe("max", () => {
-        it("builds the correct command", () => {
-          expect(
-            new ZInterStoreCommand("destination", 1, "key", { aggregate: "max" }).command,
-          ).toEqual(["zinterstore", "destination", "1", "key", "aggregate", "max"])
-        })
-      })
-    })
-    describe("complex", () => {
-      it("builds the correct command", () => {
-        expect(
-          new ZInterStoreCommand("destination", 2, ["key1", "key2"], {
-            weights: [4, 2],
-            aggregate: "max",
-          }).command,
-        ).toEqual([
-          "zinterstore",
-          "destination",
-          "2",
-          "key1",
-          "key2",
-          "weights",
-          "4",
-          "2",
-          "aggregate",
-          "max",
-        ])
-      })
-    })
-  })
-})
-
-describe("without options", () => {
-  it("returns the number of elements in the new set ", async () => {
-    const destination = newKey()
-    const key1 = newKey()
-    const key2 = newKey()
-    const score1 = 1
-    const member1 = randomUUID()
-    const score2 = 2
-    const member2 = randomUUID()
-
-    await new ZAddCommand(key1, { score: score1, member: member1 }).exec(client)
-    await new ZAddCommand(
-      key2,
-      { score: score1, member: member1 },
-      { score: score2, member: member2 },
-    ).exec(client)
-
-    const res = await new ZInterStoreCommand(destination, 2, [key1, key2]).exec(client)
-    expect(res).toBe(1)
-  })
-})
-
-describe("with weights", () => {
-  describe("single weight", () => {
-    it("returns the number of elements in the new set ", async () => {
-      const destination = newKey()
-      const key1 = newKey()
-      const key2 = newKey()
-      const score1 = 1
-      const member1 = randomUUID()
-      const score2 = 2
-      const member2 = randomUUID()
-
-      await new ZAddCommand(key1, { score: score1, member: member1 }).exec(client)
-      await new ZAddCommand(
-        key2,
-        { score: score1, member: member1 },
-        { score: score2, member: member2 },
-      ).exec(client)
-
-      const res = await new ZInterStoreCommand(destination, 2, [key1, key2], {
-        weights: [2, 3],
-      }).exec(client)
-      expect(res).toBe(1)
-    })
-  })
-  describe("multiple weight", () => {
-    it("returns the number of elements in the new set ", async () => {
-      const destination = newKey()
-      const key1 = newKey()
-      const key2 = newKey()
-      const score1 = 1
-      const member1 = randomUUID()
-      const score2 = 2
-      const member2 = randomUUID()
-
-      await new ZAddCommand(key1, { score: score1, member: member1 }).exec(client)
-      await new ZAddCommand(
-        key2,
-        { score: score1, member: member1 },
-        { score: score2, member: member2 },
-      ).exec(client)
-
-      const res = await new ZInterStoreCommand(destination, 2, [key1, key2], {
-        weights: [1, 2],
-      }).exec(client)
-      expect(res).toBe(1)
-    })
-  })
-})
-describe("aggregate", () => {
-  describe("sum", () => {
-    it("returns the number of elements in the new set ", async () => {
-      const destination = newKey()
-      const key1 = newKey()
-      const key2 = newKey()
-      const score1 = 1
-      const member1 = randomUUID()
-      const score2 = 2
-      const member2 = randomUUID()
-
-      await new ZAddCommand(key1, { score: score1, member: member1 }).exec(client)
-      await new ZAddCommand(
-        key2,
-        { score: score1, member: member1 },
-        { score: score2, member: member2 },
-      ).exec(client)
-
-      const res = await new ZInterStoreCommand(destination, 2, [key1, key2], {
-        aggregate: "sum",
-      }).exec(client)
-      expect(res).toBe(1)
-    })
-  })
-  describe("min", () => {
-    it("returns the number of elements in the new set ", async () => {
-      const destination = newKey()
-      const key1 = newKey()
-      const key2 = newKey()
-      const score1 = 1
-      const member1 = randomUUID()
-      const score2 = 2
-      const member2 = randomUUID()
-
-      await new ZAddCommand(key1, { score: score1, member: member1 }).exec(client)
-      await new ZAddCommand(
-        key2,
-        { score: score1, member: member1 },
-        { score: score2, member: member2 },
-      ).exec(client)
-
-      const res = await new ZInterStoreCommand(destination, 2, [key1, key2], {
-        aggregate: "min",
-      }).exec(client)
-      expect(res).toBe(1)
-    })
-  })
-  describe("max", () => {
-    it("returns the number of elements in the new set ", async () => {
-      const destination = newKey()
-      const key1 = newKey()
-      const key2 = newKey()
-      const score1 = 1
-      const member1 = randomUUID()
-      const score2 = 2
-      const member2 = randomUUID()
-
-      await new ZAddCommand(key1, { score: score1, member: member1 }).exec(client)
-      await new ZAddCommand(
-        key2,
-        { score: score1, member: member1 },
-        { score: score2, member: member2 },
-      ).exec(client)
-
-      const res = await new ZInterStoreCommand(destination, 2, [key1, key2], {
-        aggregate: "max",
-      }).exec(client)
-      expect(res).toBe(1)
-    })
-  })
-})

package/pkg/commands/zinterstore.ts

@@ -1,55 +0,0 @@
-import { Command } from "../command"
-
-export type ZInterStoreCommandOptions = {
-  aggregate?: "sum" | "min" | "max"
-} & (
-  | {
-      weight: number
-      weights?: never
-    }
-  | {
-      weight?: never
-      weights: number[]
-    }
-  | {
-      weight?: never
-      weights?: never
-    }
-)
-
-/**
- * @see https://redis.io/commands/zInterstore
- */
-export class ZInterStoreCommand extends Command<number, number> {
-  constructor(destination: string, numKeys: 1, key: string, opts?: ZInterStoreCommandOptions)
-  constructor(
-    destination: string,
-    numKeys: number,
-    keys: string[],
-    opts?: ZInterStoreCommandOptions,
-  )
-  constructor(
-    destination: string,
-    numKeys: number,
-    keyOrKeys: string | string[],
-    opts?: ZInterStoreCommandOptions,
-  ) {
-    const command: unknown[] = ["zinterstore", destination, numKeys]
-    if (Array.isArray(keyOrKeys)) {
-      command.push(...keyOrKeys)
-    } else {
-      command.push(keyOrKeys)
-    }
-    if (opts) {
-      if ("weights" in opts && opts.weights) {
-        command.push("weights", ...opts.weights)
-      } else if ("weight" in opts && typeof opts.weight === "number") {
-        command.push("weights", opts.weight)
-      }
-      if ("aggregate" in opts) {
-        command.push("aggregate", opts.aggregate)
-      }
-    }
-    super(command)
-  }
-}

package/pkg/commands/zlexcount.test.ts

@@ -1,22 +0,0 @@
-import { keygen, newHttpClient } from "../test-utils"
-import { it, expect, afterAll } from "@jest/globals"
-import { ZAddCommand } from "./zadd"
-import { ZLexCountCommand } from "./zlexcount"
-const client = newHttpClient()
-
-const { newKey, cleanup } = keygen()
-afterAll(cleanup)
-
-it("returns the number of elements in the specified score range", async () => {
-  const key = newKey()
-  await new ZAddCommand(
-    key,
-    { score: 0, member: "a" },
-    { score: 0, member: "b" },
-    { score: 0, member: "c" },
-    { score: 0, member: "d" },
-    { score: 0, member: "e" },
-  ).exec(client)
-  const res = await new ZLexCountCommand(key, "[b", "[f").exec(client)
-  expect(res).toBe(4)
-})

package/pkg/commands/zlexcount.ts

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