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

package/pkg/commands/append.test.ts

@@ -1,28 +0,0 @@
-import { AppendCommand } from "./append"
-import { keygen, newHttpClient } from "../test-utils"
-import { randomUUID } from "crypto"
-import { describe, it, expect, afterAll } from "@jest/globals"
-const client = newHttpClient()
-
-const { newKey, cleanup } = keygen()
-afterAll(cleanup)
-
-describe("when key is not set", () => {
-  it("appends to empty value", async () => {
-    const key = newKey()
-    const value = randomUUID()
-    const res = await new AppendCommand(key, value).exec(client)
-    expect(res).toEqual(value.length)
-  })
-})
-
-describe("when key is set", () => {
-  it("appends to existing value", async () => {
-    const key = newKey()
-    const value = randomUUID()
-    const res = await new AppendCommand(key, value).exec(client)
-    expect(res).toEqual(value.length)
-    const res2 = await new AppendCommand(key, "_").exec(client)
-    expect(res2).toEqual(value.length + 1)
-  })
-})

package/pkg/commands/append.ts

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

package/pkg/commands/bitcount.test.ts

@@ -1,36 +0,0 @@
-import { BitCountCommand } from "./bitcount"
-import { keygen, newHttpClient } from "../test-utils"
-import { describe, it, expect, afterAll } from "@jest/globals"
-import { SetCommand } from "./set"
-const client = newHttpClient()
-
-const { newKey, cleanup } = keygen()
-afterAll(cleanup)
-
-describe("when key is not set", () => {
-  it("returns 0", async () => {
-    const key = newKey()
-    const res = await new BitCountCommand(key).exec(client)
-    expect(res).toEqual(0)
-  })
-})
-
-describe("when key is set", () => {
-  it("returns bitcount", async () => {
-    const key = newKey()
-    const value = "Hello World"
-    await new SetCommand(key, value).exec(client)
-    const res = await new BitCountCommand(key).exec(client)
-    expect(res).toEqual(43)
-  })
-
-  describe("with start and end", () => {
-    it("returns bitcount", async () => {
-      const key = newKey()
-      const value = "Hello World"
-      await new SetCommand(key, value).exec(client)
-      const res = await new BitCountCommand(key, 4, 8).exec(client)
-      expect(res).toEqual(22)
-    })
-  })
-})

package/pkg/commands/bitcount.ts

@@ -1,19 +0,0 @@
-import { Command } from "../command"
-
-/**
- * @see https://redis.io/commands/bitcount
- */
-export class BitCountCommand extends Command<number, number> {
-  constructor(key: string, start?: never, end?: never)
-  constructor(key: string, start: number, end: number)
-  constructor(key: string, start?: number, end?: number) {
-    const command: unknown[] = ["bitcount", key]
-    if (typeof start === "number") {
-      command.push(start)
-    }
-    if (typeof end === "number") {
-      command.push(end)
-    }
-    super(command)
-  }
-}

package/pkg/commands/bitop.test.ts

@@ -1,44 +0,0 @@
-import { BitOpCommand } from "./bitop"
-import { keygen, newHttpClient } from "../test-utils"
-import { describe, it, expect, afterAll } from "@jest/globals"
-import { SetCommand } from "./set"
-const client = newHttpClient()
-
-const { newKey, cleanup } = keygen()
-afterAll(cleanup)
-
-describe("when key is not set", () => {
-  it("returns 0", async () => {
-    const source = newKey()
-    const dest = newKey()
-    const res = await new BitOpCommand("and", dest, source).exec(client)
-    expect(res).toEqual(0)
-  })
-})
-
-describe("when key is set", () => {
-  describe("not", () => {
-    it("inverts all bits", async () => {
-      const source = newKey()
-      const sourcevalue = "Hello World"
-      const dest = newKey()
-      const destValue = "foo: bar"
-      await new SetCommand(source, sourcevalue).exec(client)
-      await new SetCommand(dest, destValue).exec(client)
-      const res = await new BitOpCommand("not", dest, source).exec(client)
-      expect(res).toEqual(11)
-    })
-  })
-  describe("and", () => {
-    it("works", async () => {
-      const source = newKey()
-      const sourcevalue = "Hello World"
-      const dest = newKey()
-      const destValue = "foo: bar"
-      await new SetCommand(source, sourcevalue).exec(client)
-      await new SetCommand(dest, destValue).exec(client)
-      const res = await new BitOpCommand("and", dest, source).exec(client)
-      expect(res).toEqual(11)
-    })
-  })
-})

package/pkg/commands/bitop.ts

@@ -1,22 +0,0 @@
-import { Command } from "../command"
-
-/**
- * @see https://redis.io/commands/bitop
- */
-export class BitOpCommand extends Command<number, number> {
-  constructor(
-    op: "and" | "or" | "xor",
-    destinationKey: string,
-    sourceKey: string,
-    ...sourceKeys: string[]
-  )
-  constructor(op: "not", destinationKey: string, sourceKey: string)
-  constructor(
-    op: "and" | "or" | "xor" | "not",
-    destinationKey: string,
-    sourceKey: string,
-    ...sourceKeys: string[]
-  ) {
-    super(["bitop", op, destinationKey, sourceKey, ...sourceKeys])
-  }
-}

package/pkg/commands/bitpos.test.ts

@@ -1,26 +0,0 @@
-import { BitPosCommand } from "./bitpos"
-import { keygen, newHttpClient } from "../test-utils"
-import { describe, it, expect, afterAll } from "@jest/globals"
-import { SetCommand } from "./set"
-const client = newHttpClient()
-
-const { newKey, cleanup } = keygen()
-afterAll(cleanup)
-
-describe("when key is not set", () => {
-  it("returns 0", async () => {
-    const key = newKey()
-    const res = await new BitPosCommand(key, 1, 1).exec(client)
-    expect(res).toEqual(-1)
-  })
-})
-
-describe("when key is set", () => {
-  it("returns position of first set bit", async () => {
-    const key = newKey()
-    const value = "Hello World"
-    await new SetCommand(key, value).exec(client)
-    const res = await new BitPosCommand(key, 2, 3).exec(client)
-    expect(res).toEqual(24)
-  })
-})

package/pkg/commands/bitpos.ts

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

package/pkg/commands/dbsize.test.ts

@@ -1,17 +0,0 @@
-import { keygen, newHttpClient } from "../test-utils"
-import { randomUUID } from "crypto"
-import { it, expect, afterAll } from "@jest/globals"
-import { SetCommand } from "./set"
-import { DBSizeCommand } from "./dbsize"
-const client = newHttpClient()
-
-const { newKey, cleanup } = keygen()
-afterAll(cleanup)
-
-it("returns the db size", async () => {
-  const key = newKey()
-  const value = randomUUID()
-  await new SetCommand(key, value).exec(client)
-  const res = await new DBSizeCommand().exec(client)
-  expect(res).toBeGreaterThan(0)
-})

package/pkg/commands/dbsize.ts

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

package/pkg/commands/decr.test.ts

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

package/pkg/commands/decr.ts

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

package/pkg/commands/decrby.test.ts

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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