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

package/pkg/commands/lset.test.ts

@@ -1,40 +0,0 @@
-import { keygen, newHttpClient } from "../test-utils"
-import { randomUUID } from "crypto"
-import { describe, it, expect, afterAll } from "@jest/globals"
-import { LPushCommand } from "./lpush"
-import { LSetCommand } from "./lset"
-import { LPopCommand } from "./lpop"
-const client = newHttpClient()
-
-const { newKey, cleanup } = keygen()
-afterAll(cleanup)
-
-describe("when list exists", () => {
-  describe("when the index is in range", () => {
-    it("replaces the element at index", async () => {
-      const key = newKey()
-
-      const value = randomUUID()
-      const newValue = randomUUID()
-      await new LPushCommand(key, value).exec(client)
-      const res = await new LSetCommand(key, newValue, 0).exec(client)
-      expect(res).toEqual("OK")
-
-      const res2 = await new LPopCommand(key).exec(client)
-
-      expect(res2).toEqual(newValue)
-    })
-    describe("when the index is out of bounds", () => {
-      it("returns null", async () => {
-        const key = newKey()
-
-        const value = randomUUID()
-        const newValue = randomUUID()
-        await new LPushCommand(key, value).exec(client)
-        expect(
-          async () => await new LSetCommand(key, newValue, 1).exec(client),
-        ).rejects.toThrowErrorMatchingInlineSnapshot(`"ERR index out of range"`)
-      })
-    })
-  })
-})

package/pkg/commands/lset.ts

@@ -1,7 +0,0 @@
-import { Command } from "../command"
-
-export class LSetCommand<TData = string> extends Command<"OK", "OK"> {
-  constructor(key: string, value: TData, index: number) {
-    super(["lset", key, index, value])
-  }
-}

package/pkg/commands/ltrim.test.ts

@@ -1,29 +0,0 @@
-import { keygen, newHttpClient } from "../test-utils"
-import { randomUUID } from "crypto"
-import { describe, it, expect, afterAll } from "@jest/globals"
-import { LPushCommand } from "./lpush"
-import { LTrimCommand } from "./ltrim"
-const client = newHttpClient()
-
-const { newKey, cleanup } = keygen()
-afterAll(cleanup)
-
-describe("when the list exists", () => {
-  it("returns ok", async () => {
-    const key = newKey()
-    await new LPushCommand(key, randomUUID()).exec(client)
-    await new LPushCommand(key, randomUUID()).exec(client)
-    await new LPushCommand(key, randomUUID()).exec(client)
-    const res = await new LTrimCommand(key, 1, 2).exec(client)
-    expect(res).toEqual("OK")
-  })
-})
-
-describe("when the list does not exist", () => {
-  it("returns ok", async () => {
-    const key = newKey()
-
-    const res = await new LTrimCommand(key, 1, 2).exec(client)
-    expect(res).toEqual("OK")
-  })
-})

package/pkg/commands/ltrim.ts

@@ -1,7 +0,0 @@
-import { Command } from "../command"
-
-export class LTrimCommand extends Command<"OK", "OK"> {
-  constructor(key: string, start: number, end: number) {
-    super(["ltrim", key, start, end])
-  }
-}

package/pkg/commands/mget.test.ts

@@ -1,44 +0,0 @@
-import { keygen, newHttpClient } from "../test-utils"
-import { randomUUID } from "crypto"
-import { it, expect, afterAll } from "@jest/globals"
-import { MSetCommand } from "./mset"
-import { MGetCommand } from "./mget"
-
-import { SetCommand } from "./set"
-const client = newHttpClient()
-
-const { newKey, cleanup } = keygen()
-afterAll(cleanup)
-
-it("gets exiting values", async () => {
-  const key1 = newKey()
-  const value1 = randomUUID()
-  const key2 = newKey()
-  const value2 = randomUUID()
-
-  const kv: Record<string, string> = {}
-  kv[key1] = value1
-  kv[key2] = value2
-  const res = await new MSetCommand(kv).exec(client)
-
-  expect(res).toEqual("OK")
-  const res2 = await new MGetCommand<[string, string]>(key1, key2).exec(client)
-
-  expect(res2).toEqual([value1, value2])
-})
-
-it("gets a non-existing value", async () => {
-  const key = newKey()
-  const res = await new MGetCommand<[null]>(key).exec(client)
-
-  expect(res).toEqual([null])
-})
-
-it("gets an object", async () => {
-  const key = newKey()
-  const value = { v: randomUUID() }
-  await new SetCommand(key, value).exec(client)
-  const res = await new MGetCommand<[{ v: string }]>(key).exec(client)
-
-  expect(res).toEqual([value])
-})

package/pkg/commands/mget.ts

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

package/pkg/commands/mset.test.ts

@@ -1,24 +0,0 @@
-import { keygen, newHttpClient } from "../test-utils"
-import { randomUUID } from "crypto"
-import { it, expect, afterAll } from "@jest/globals"
-import { MSetCommand } from "./mset"
-import { MGetCommand } from "./mget"
-
-const client = newHttpClient()
-
-const { newKey, cleanup } = keygen()
-afterAll(cleanup)
-
-it("gets exiting values", async () => {
-  const key1 = newKey()
-  const key2 = newKey()
-  const kv = {
-    [key1]: randomUUID(),
-    [key2]: randomUUID(),
-  }
-  const res = await new MSetCommand(kv).exec(client)
-
-  expect(res).toEqual("OK")
-  const res2 = await new MGetCommand(key1, key2).exec(client)
-  expect(res2).toEqual(Object.values(kv))
-})

package/pkg/commands/mset.ts

@@ -1,10 +0,0 @@
-import { Command } from "../command"
-
-/**
- * @see https://redis.io/commands/mset
- */
-export class MSetCommand<TData> extends Command<"OK", "OK"> {
-  constructor(kv: { [key: string]: TData }) {
-    super(["mset", ...Object.entries(kv).flatMap(([key, value]) => [key, value])])
-  }
-}

package/pkg/commands/msetnx.test.ts

@@ -1,46 +0,0 @@
-import { keygen, newHttpClient } from "../test-utils"
-import { randomUUID } from "crypto"
-import { it, expect, afterAll } from "@jest/globals"
-import { MGetCommand } from "./mget"
-import { SetCommand } from "./set"
-import { GetCommand } from "./get"
-import { MSetNXCommand } from "./msetnx"
-const client = newHttpClient()
-
-const { newKey, cleanup } = keygen()
-afterAll(cleanup)
-
-it("sets values", async () => {
-  const key1 = newKey()
-  const value1 = randomUUID()
-  const key2 = newKey()
-  const value2 = randomUUID()
-
-  const kv: Record<string, string> = {}
-  kv[key1] = value1
-  kv[key2] = value2
-  const res = await new MSetNXCommand(kv).exec(client)
-
-  expect(res).toEqual(1)
-  const res2 = await new MGetCommand<[string, string]>(key1, key2).exec(client)
-
-  expect(res2).toEqual([value1, value2])
-})
-
-it("does not set values if one key already exists", async () => {
-  const key1 = newKey()
-  const value1 = randomUUID()
-  const key2 = newKey()
-  const value2 = randomUUID()
-  await new SetCommand(key1, value1).exec(client)
-  const kv: Record<string, string> = {}
-  kv[key1] = value1
-  kv[key2] = value2
-  const res = await new MSetNXCommand(kv).exec(client)
-
-  expect(res).toEqual(0)
-
-  const res2 = await new GetCommand(key2).exec(client)
-
-  expect(res2).toBeNull()
-})

package/pkg/commands/msetnx.ts

@@ -1,10 +0,0 @@
-import { Command } from "../command"
-
-/**
- * @see https://redis.io/commands/msetnx
- */
-export class MSetNXCommand<TData = string> extends Command<number, number> {
-  constructor(kv: { [key: string]: TData }) {
-    super(["msetnx", ...Object.entries(kv).flatMap((_) => _)])
-  }
-}

package/pkg/commands/persist.test.ts

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

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

@@ -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 { 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

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

@@ -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 { 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

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

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

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

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

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

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

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

@@ -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 { 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

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

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

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

@@ -1,32 +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 { 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

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

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

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

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

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

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