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

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

package/pkg/commands/rpushx.ts

@@ -1,11 +0,0 @@
-import { NonEmptyArray } from "../types"
-import { Command } from "../command"
-
-/**
- * @see https://redis.io/commands/rpushx
- */
-export class RPushXCommand<TData = string> extends Command<number, number> {
-  constructor(key: string, ...elements: NonEmptyArray<TData>) {
-    super(["rpushx", key, ...elements])
-  }
-}

package/pkg/commands/sadd.test.ts

@@ -1,16 +0,0 @@
-import { keygen, newHttpClient } from "../test-utils"
-import { randomUUID } from "crypto"
-import { it, expect, afterAll } from "@jest/globals"
-import { SAddCommand } from "./sadd"
-const client = newHttpClient()
-
-const { newKey, cleanup } = keygen()
-afterAll(cleanup)
-
-it("returns the number of added members", async () => {
-  const key = newKey()
-  const value1 = randomUUID()
-  const value2 = randomUUID()
-  const res = await new SAddCommand(key, value1, value2).exec(client)
-  expect(res).toBe(2)
-})

package/pkg/commands/sadd.ts

@@ -1,11 +0,0 @@
-import { NonEmptyArray } from "../types"
-import { Command } from "../command"
-
-/**
- * @see https://redis.io/commands/sadd
- */
-export class SAddCommand<TData = string> extends Command<number, number> {
-  constructor(key: string, ...members: NonEmptyArray<TData>) {
-    super(["sadd", key, ...members])
-  }
-}

package/pkg/commands/scan.test.ts

@@ -1,50 +0,0 @@
-import { keygen, newHttpClient } from "../test-utils"
-import { randomUUID } from "crypto"
-import { it, describe, expect, afterAll } from "@jest/globals"
-import { SetCommand } from "./set"
-import { ScanCommand } from "./scan"
-const client = newHttpClient()
-
-const { newKey, cleanup } = keygen()
-afterAll(cleanup)
-describe("without options", () => {
-  it("returns cursor and keys", async () => {
-    const key = newKey()
-    const value = randomUUID()
-    await new SetCommand(key, value).exec(client)
-    const res = await new ScanCommand(0).exec(client)
-
-    expect(res).toBeDefined()
-    expect(res.length).toBe(2)
-    expect(typeof res[0]).toBe("number")
-    expect(res![1].length).toBeGreaterThan(0)
-  })
-})
-
-describe("with match", () => {
-  it("returns cursor and keys", async () => {
-    const key = newKey()
-    const value = randomUUID()
-    await new SetCommand(key, value).exec(client)
-    const res = await new ScanCommand(0, { match: key }).exec(client)
-
-    expect(res).toBeDefined()
-    expect(res.length).toBe(2)
-    expect(typeof res[0]).toBe("number")
-    expect(res![1].length).toBeGreaterThan(0)
-  })
-})
-
-describe("with count", () => {
-  it("returns cursor and keys", async () => {
-    const key = newKey()
-    const value = randomUUID()
-    await new SetCommand(key, value).exec(client)
-    const res = await new ScanCommand(0, { count: 1 }).exec(client)
-
-    expect(res).toBeDefined()
-    expect(res.length).toBe(2)
-    expect(typeof res[0]).toBe("number")
-    expect(res![1].length).toBeGreaterThan(0)
-  })
-})

package/pkg/commands/scan.ts

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

package/pkg/commands/scard.test.ts

@@ -1,15 +0,0 @@
-import { keygen, newHttpClient } from "../test-utils"
-import { it, expect, afterAll } from "@jest/globals"
-import { SAddCommand } from "./sadd"
-import { SCardCommand } from "./scard"
-const client = newHttpClient()
-
-const { newKey, cleanup } = keygen()
-afterAll(cleanup)
-
-it("returns the cardinality", async () => {
-  const key = newKey()
-  await new SAddCommand(key, "member1").exec(client)
-  const res = await new SCardCommand(key).exec(client)
-  expect(res).toBe(1)
-})

package/pkg/commands/scard.ts

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

package/pkg/commands/sdiff.test.ts

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

package/pkg/commands/sdiff.ts

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