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

package/pkg/commands/hset.ts

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

package/pkg/commands/hsetnx.test.ts

@@ -1,37 +0,0 @@
-import { keygen, newHttpClient } from "../test-utils"
-import { randomUUID } from "crypto"
-import { describe, it, expect, afterAll } from "@jest/globals"
-import { HSetCommand } from "./hset"
-import { HGetCommand } from "./hget"
-import { HSetNXCommand } from "./hsetnx"
-const client = newHttpClient()
-
-const { newKey, cleanup } = keygen()
-afterAll(cleanup)
-
-describe("when hash exists already", () => {
-  it("returns 0", async () => {
-    const key = newKey()
-    const field = randomUUID()
-    const value = randomUUID()
-    const newValue = randomUUID()
-    await new HSetCommand(key, field, value).exec(client)
-    const res = await new HSetNXCommand(key, field, newValue).exec(client)
-    expect(res).toBe(0)
-    const res2 = await new HGetCommand(key, field).exec(client)
-
-    expect(res2).toEqual(value)
-  })
-})
-describe("when hash does not exist", () => {
-  it("returns 1", async () => {
-    const key = newKey()
-    const field = randomUUID()
-    const value = randomUUID()
-    const res = await new HSetNXCommand(key, field, value).exec(client)
-    expect(res).toBe(1)
-    const res2 = await new HGetCommand(key, field).exec(client)
-
-    expect(res2).toEqual(value)
-  })
-})

package/pkg/commands/hsetnx.ts

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

package/pkg/commands/hstrlen.test.ts

@@ -1,24 +0,0 @@
-import { keygen, newHttpClient } from "../test-utils"
-import { randomUUID } from "crypto"
-import { it, expect, afterAll } from "@jest/globals"
-
-import { HStrLenCommand } from "./hstrlen"
-import { HSetCommand } from "./hset"
-
-const client = newHttpClient()
-
-const { newKey, cleanup } = keygen()
-afterAll(cleanup)
-it("returns correct length", async () => {
-  const key = newKey()
-  const field = randomUUID()
-  const value = randomUUID()
-
-  const res = await new HStrLenCommand(key, field).exec(client)
-  expect(res).toBe(0)
-  await new HSetCommand(key, field, value).exec(client)
-
-  const res2 = await new HStrLenCommand(key, field).exec(client)
-
-  expect(res2).toBe(36)
-})

package/pkg/commands/hstrlen.ts

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

package/pkg/commands/hvals.test.ts

@@ -1,23 +0,0 @@
-import { keygen, newHttpClient } from "../test-utils"
-import { randomUUID } from "crypto"
-import { it, expect, afterAll } from "@jest/globals"
-import { HValsCommand } from "./hvals"
-import { HSetCommand } from "./hset"
-const client = newHttpClient()
-
-const { newKey, cleanup } = keygen()
-afterAll(cleanup)
-
-it("returns correct length", async () => {
-  const key = newKey()
-  const field = randomUUID()
-  const value = randomUUID()
-
-  const res = await new HValsCommand(key).exec(client)
-  expect(res).toEqual([])
-  await new HSetCommand(key, field, value).exec(client)
-
-  const res2 = await new HValsCommand(key).exec(client)
-
-  expect(res2).toEqual([value])
-})

package/pkg/commands/hvals.ts

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

package/pkg/commands/incr.test.ts

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

package/pkg/commands/incr.ts

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

package/pkg/commands/incrby.test.ts

@@ -1,23 +0,0 @@
-import { keygen, newHttpClient } from "../test-utils"
-import { it, expect, afterAll } from "@jest/globals"
-import { IncrByCommand } from "./incrby"
-import { SetCommand } from "./set"
-const client = newHttpClient()
-
-const { newKey, cleanup } = keygen()
-afterAll(cleanup)
-
-it("increments a non-existing value", async () => {
-  const key = newKey()
-  const res = await new IncrByCommand(key, 2).exec(client)
-
-  expect(res).toEqual(2)
-})
-
-it("increments and existing value", async () => {
-  const key = newKey()
-  await new SetCommand(key, 5).exec(client)
-  const res = await new IncrByCommand(key, 2).exec(client)
-
-  expect(res).toEqual(7)
-})

package/pkg/commands/incrby.ts

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

package/pkg/commands/incrbyfloat.test.ts

@@ -1,24 +0,0 @@
-import { keygen, newHttpClient } from "../test-utils"
-import { it, expect, afterAll } from "@jest/globals"
-import { SetCommand } from "./set"
-
-import { IncrByFloatCommand } from "./incrbyfloat"
-const client = newHttpClient()
-
-const { newKey, cleanup } = keygen()
-afterAll(cleanup)
-
-it("increments a non-existing value", async () => {
-  const key = newKey()
-  const res = await new IncrByFloatCommand(key, 2.5).exec(client)
-
-  expect(res).toEqual(2.5)
-})
-
-it("increments and existing value", async () => {
-  const key = newKey()
-  await new SetCommand(key, 5).exec(client)
-  const res = await new IncrByFloatCommand(key, 2.5).exec(client)
-
-  expect(res).toEqual(7.5)
-})

package/pkg/commands/incrbyfloat.ts

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

package/pkg/commands/index.ts

@@ -1,107 +0,0 @@
-export * from "./append"
-export * from "./bitcount"
-export * from "./bitop"
-export * from "./bitpos"
-export * from "./dbsize"
-export * from "./decr"
-export * from "./decrby"
-export * from "./del"
-export * from "./echo"
-export * from "./exists"
-export * from "./expire"
-export * from "./expireat"
-export * from "./flushall"
-export * from "./flushdb"
-export * from "./get"
-export * from "./getbit"
-export * from "./getrange"
-export * from "./getset"
-export * from "./hdel"
-export * from "./hexists"
-export * from "./hget"
-export * from "./hgetall"
-export * from "./hincrby"
-export * from "./hincrbyfloat"
-export * from "./hkeys"
-export * from "./hlen"
-export * from "./hmget"
-export * from "./hmset"
-export * from "./hscan"
-export * from "./hset"
-export * from "./hsetnx"
-export * from "./hstrlen"
-export * from "./hvals"
-export * from "./incr"
-export * from "./incrby"
-export * from "./incrbyfloat"
-export * from "./keys"
-export * from "./lindex"
-export * from "./linsert"
-export * from "./llen"
-export * from "./lpop"
-export * from "./lpush"
-export * from "./lpushx"
-export * from "./lrange"
-export * from "./lrem"
-export * from "./lset"
-export * from "./ltrim"
-export * from "./mget"
-export * from "./mset"
-export * from "./msetnx"
-export * from "./persist"
-export * from "./pexpire"
-export * from "./pexpireat"
-export * from "./ping"
-export * from "./psetex"
-export * from "./pttl"
-export * from "./randomkey"
-export * from "./rename"
-export * from "./renamenx"
-export * from "./rpop"
-export * from "./rpush"
-export * from "./rpushx"
-export * from "./sadd"
-export * from "./scan"
-export * from "./scard"
-export * from "./sdiff"
-export * from "./sdiffstore"
-export * from "./set"
-export * from "./setbit"
-export * from "./setex"
-export * from "./setnx"
-export * from "./setrange"
-export * from "./sinter"
-export * from "./sinterstore"
-export * from "./sismember"
-export * from "./smembers"
-export * from "./smove"
-export * from "./spop"
-export * from "./srandmember"
-export * from "./srem"
-export * from "./sscan"
-export * from "./strlen"
-export * from "./sunion"
-export * from "./sunionstore"
-export * from "./time"
-export * from "./touch"
-export * from "./ttl"
-export * from "./type"
-export * from "./unlink"
-export * from "./zadd"
-export * from "./zcard"
-export * from "./zcount"
-export * from "./zincrby"
-export * from "./zinterstore"
-export * from "./zlexcount"
-export * from "./zpopmax"
-export * from "./zpopmin"
-export * from "./zrange"
-export * from "./zrank"
-export * from "./zrem"
-export * from "./zremrangebylex"
-export * from "./zremrangebyrank"
-export * from "./zremrangebyscore"
-export * from "./zrevrank"
-export * from "./zscan"
-export * from "./zscore"
-export * from "./zunionstore"

package/pkg/commands/keys.test.ts

@@ -1,17 +0,0 @@
-import { keygen, newHttpClient } from "../test-utils"
-import { describe, it, expect, afterAll } from "@jest/globals"
-import { SetCommand } from "./set"
-import { KeysCommand } from "./keys"
-const client = newHttpClient()
-
-const { newKey, cleanup } = keygen()
-afterAll(cleanup)
-
-describe("when keys are found", () => {
-  it("returns keys", async () => {
-    const key = newKey()
-    await new SetCommand(key, "value").exec(client)
-    const res = await new KeysCommand(key).exec(client)
-    expect(res).toEqual([key])
-  })
-})

package/pkg/commands/keys.ts

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

package/pkg/commands/lindex.test.ts

@@ -1,33 +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 { LIndexCommand } from "./lindex"
-
-const client = newHttpClient()
-
-const { newKey, cleanup } = keygen()
-afterAll(cleanup)
-
-describe("when list exists", () => {
-  describe("when the index is in range", () => {
-    it("returns the element at index", async () => {
-      const key = newKey()
-
-      const value = randomUUID()
-      await new LPushCommand(key, value).exec(client)
-      const res = await new LIndexCommand(key, 0).exec(client)
-      expect(res).toEqual(value)
-    })
-    describe("when the index is out of bounds", () => {
-      it("returns null", async () => {
-        const key = newKey()
-
-        const value = randomUUID()
-        await new LPushCommand(key, value).exec(client)
-        const res = await new LIndexCommand(key, 1).exec(client)
-        expect(res).toBeNull()
-      })
-    })
-  })
-})

package/pkg/commands/lindex.ts

@@ -1,7 +0,0 @@
-import { Command } from "../command"
-
-export class LIndexCommand<TData = string> extends Command<TData | null, unknown | null> {
-  constructor(key: string, index: number) {
-    super(["lindex", key, index])
-  }
-}

package/pkg/commands/linsert.test.ts

@@ -1,19 +0,0 @@
-import { keygen, newHttpClient } from "../test-utils"
-import { randomUUID } from "crypto"
-import { it, expect, afterAll } from "@jest/globals"
-import { LInsertCommand } from "./linsert"
-import { LPushCommand } from "./lpush"
-const client = newHttpClient()
-
-const { newKey, cleanup } = keygen()
-afterAll(cleanup)
-
-it("adds the element", async () => {
-  const key = newKey()
-  const value1 = randomUUID()
-  const value2 = randomUUID()
-
-  await new LPushCommand(key, value1).exec(client)
-  const res = await new LInsertCommand(key, "before", value1, value2).exec(client)
-  expect(res).toBe(2)
-})

package/pkg/commands/linsert.ts

@@ -1,6 +0,0 @@
-import { Command } from "../command"
-export class LInsertCommand<TData = string> extends Command<number, number> {
-  constructor(key: string, direction: "before" | "after", pivot: TData, value: TData) {
-    super(["linsert", key, direction, pivot, value])
-  }
-}

package/pkg/commands/llen.test.ts

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

package/pkg/commands/llen.ts

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

package/pkg/commands/lpop.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 { LPopCommand } from "./lpop"
-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 LPopCommand(key).exec(client)
-    expect(res).toEqual(value)
-  })
-})
-
-describe("when list does not exist", () => {
-  it("returns null", async () => {
-    const key = newKey()
-    const res = await new LPopCommand(key).exec(client)
-    expect(res).toBeNull()
-  })
-})

package/pkg/commands/lpop.ts

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

package/pkg/commands/lpush.test.ts

@@ -1,17 +0,0 @@
-import { keygen, newHttpClient } from "../test-utils"
-import { randomUUID } from "crypto"
-import { it, expect, afterAll } from "@jest/globals"
-import { LPushCommand } from "./lpush"
-const client = newHttpClient()
-
-const { newKey, cleanup } = keygen()
-afterAll(cleanup)
-
-it("returns the length after command", async () => {
-  const key = newKey()
-  const res = await new LPushCommand(key, randomUUID()).exec(client)
-  expect(res).toEqual(1)
-  const res2 = await new LPushCommand(key, randomUUID(), randomUUID()).exec(client)
-
-  expect(res2).toEqual(3)
-})

package/pkg/commands/lpush.ts

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

package/pkg/commands/lpushx.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 { LPushXCommand } from "./lpushx"
-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 LPushXCommand(key, randomUUID()).exec(client)
-    expect(res).toEqual(2)
-    const res2 = await new LPushXCommand(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 LPushXCommand(key, randomUUID()).exec(client)
-    expect(res).toEqual(0)
-  })
-})

package/pkg/commands/lpushx.ts

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

package/pkg/commands/lrange.test.ts

@@ -1,22 +0,0 @@
-import { keygen, newHttpClient } from "../test-utils"
-import { randomUUID } from "crypto"
-import { it, expect, afterAll } from "@jest/globals"
-import { RPushCommand } from "./rpush"
-import { LRangeCommand } from "./lrange"
-const client = newHttpClient()
-
-const { newKey, cleanup } = keygen()
-afterAll(cleanup)
-
-it("returns the correct range", async () => {
-  const key = newKey()
-  const value1 = randomUUID()
-  const value2 = randomUUID()
-  const value3 = randomUUID()
-  await new RPushCommand(key, value1, value2, value3).exec(client)
-  const res = await new LRangeCommand(key, 1, 2).exec(client)
-  expect(res).toBeDefined()
-  expect(res!.length).toEqual(2)
-  expect(res![0]).toEqual(value2)
-  expect(res![1]).toEqual(value3)
-})

package/pkg/commands/lrange.ts

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

package/pkg/commands/lrem.test.ts

@@ -1,19 +0,0 @@
-import { keygen, newHttpClient } from "../test-utils"
-import { it, expect, afterAll } from "@jest/globals"
-
-import { LPushCommand } from "./lpush"
-import { LRemCommand } from "./lrem"
-const client = newHttpClient()
-
-const { newKey, cleanup } = keygen()
-afterAll(cleanup)
-
-it("returns the number of deleted elements", async () => {
-  const key = newKey()
-  await new LPushCommand(key, "element").exec(client)
-  await new LPushCommand(key, "element").exec(client)
-  await new LPushCommand(key, "something else").exec(client)
-
-  const res = await new LRemCommand(key, 2, "element").exec(client)
-  expect(res).toBe(2)
-})

package/pkg/commands/lrem.ts

@@ -1,6 +0,0 @@
-import { Command } from "../command"
-export class LRemCommand<TData> extends Command<number, number> {
-  constructor(key: string, count: number, value: TData) {
-    super(["lrem", key, count, value])
-  }
-}