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

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])
-  }
-}

package/pkg/commands/getrange.test.ts

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

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

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

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

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

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

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

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