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

package/pkg/commands/hget.test.ts

@@ -1,47 +0,0 @@
-import { keygen, newHttpClient } from "../test-utils"
-import { randomUUID } from "crypto"
-import { it, expect, afterAll } from "@jest/globals"
-import { HSetCommand } from "./hset"
-import { HGetCommand } from "./hget"
-
-const client = newHttpClient()
-
-const { newKey, cleanup } = keygen()
-afterAll(cleanup)
-
-it("gets an exiting value", async () => {
-  const key = newKey()
-  const field = randomUUID()
-  const value = randomUUID()
-  await new HSetCommand(key, field, value).exec(client)
-  const res = await new HGetCommand(key, field).exec(client)
-
-  expect(res).toEqual(value)
-})
-
-it("gets a non-existing hash", async () => {
-  const key = newKey()
-  const field = randomUUID()
-  const res = await new HGetCommand(key, field).exec(client)
-
-  expect(res).toBeNull()
-})
-
-it("gets a non-existing field", async () => {
-  const key = newKey()
-  const field = randomUUID()
-  await new HSetCommand(key, randomUUID(), randomUUID()).exec(client)
-  const res = await new HGetCommand(key, field).exec(client)
-
-  expect(res).toBeNull()
-})
-
-it("gets an object", async () => {
-  const key = newKey()
-  const field = randomUUID()
-  const value = { v: randomUUID() }
-  await new HSetCommand(key, field, value).exec(client)
-  const res = await new HGetCommand(key, field).exec(client)
-
-  expect(res).toEqual(value)
-})

package/pkg/commands/hget.ts

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

package/pkg/commands/hgetall.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 { HSetCommand } from "./hset"
-import { HGetAllCommand } from "./hgetall"
-
-const client = newHttpClient()
-
-const { newKey, cleanup } = keygen()
-afterAll(cleanup)
-it("returns all fields", async () => {
-  const key = newKey()
-  const field2 = randomUUID()
-  const field1 = randomUUID()
-  const value1 = false
-  const value2 = randomUUID()
-  await new HSetCommand(key, field1, value1).exec(client)
-  await new HSetCommand(key, field2, value2).exec(client)
-  const res = await new HGetAllCommand(key).exec(client)
-
-  const obj = {
-    [field1]: value1,
-    [field2]: value2,
-  }
-  expect(res).toEqual(obj)
-})
-describe("when hash does not exist", () => {
-  it("it returns null", async () => {
-    const res = await new HGetAllCommand(randomUUID()).exec(client)
-    expect(res).toBeNull()
-  })
-})

package/pkg/commands/hgetall.ts

@@ -1,35 +0,0 @@
-import { Command } from "../command"
-
-/**
- *
- * @param result De
- * @returns
- */
-function deserialize<TData extends Record<string, unknown>>(result: string[]): TData | null {
-  if (result.length === 0) {
-    return null
-  }
-  const obj: Record<string, unknown> = {}
-  while (result.length >= 2) {
-    const key = result.shift()!
-    const value = result.shift()!
-    try {
-      obj[key] = JSON.parse(value)
-    } catch {
-      obj[key] = value
-    }
-  }
-  return obj as TData
-}
-
-/**
- * @see https://redis.io/commands/hgetall
- */
-export class HGetAllCommand<TData extends Record<string, unknown>> extends Command<
-  TData | null,
-  unknown | null
-> {
-  constructor(key: string) {
-    super(["hgetall", key], { deserialize: (result) => deserialize<TData>(result as string[]) })
-  }
-}

package/pkg/commands/hincrby.test.ts

@@ -1,27 +0,0 @@
-import { keygen, newHttpClient } from "../test-utils"
-import { randomUUID } from "crypto"
-import { it, expect, afterAll } from "@jest/globals"
-
-import { HSetCommand } from "./hset"
-import { HIncrByCommand } from "./hincrby"
-const client = newHttpClient()
-
-const { newKey, cleanup } = keygen()
-afterAll(cleanup)
-
-it("increments a non-existing value", async () => {
-  const key = newKey()
-  const field = randomUUID()
-  const res = await new HIncrByCommand(key, field, 2).exec(client)
-
-  expect(res).toEqual(2)
-})
-
-it("increments and existing value", async () => {
-  const key = newKey()
-  const field = randomUUID()
-  await new HSetCommand(key, field, 5).exec(client)
-  const res = await new HIncrByCommand(key, field, 2).exec(client)
-
-  expect(res).toEqual(7)
-})

package/pkg/commands/hincrby.ts

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

package/pkg/commands/hincrbyfloat.test.ts

@@ -1,25 +0,0 @@
-import { keygen, newHttpClient } from "../test-utils"
-import { randomUUID } from "crypto"
-import { it, expect, afterAll } from "@jest/globals"
-import { HIncrByFloatCommand } from "./hincrbyfloat"
-import { HSetCommand } from "./hset"
-const client = newHttpClient()
-
-const { newKey, cleanup } = keygen()
-afterAll(cleanup)
-it("increments a non-existing value", async () => {
-  const key = newKey()
-  const field = randomUUID()
-  const res = await new HIncrByFloatCommand(key, field, 2.5).exec(client)
-
-  expect(res).toEqual(2.5)
-})
-
-it("increments and existing value", async () => {
-  const key = newKey()
-  const field = randomUUID()
-  await new HSetCommand(key, field, 5).exec(client)
-  const res = await new HIncrByFloatCommand(key, field, 2.5).exec(client)
-
-  expect(res).toEqual(7.5)
-})

package/pkg/commands/hincrbyfloat.ts

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

package/pkg/commands/hkeys.test.ts

@@ -1,22 +0,0 @@
-import { keygen, newHttpClient } from "../test-utils"
-import { randomUUID } from "crypto"
-import { describe, it, expect, afterAll } from "@jest/globals"
-import { HMSetCommand } from "./hmset"
-import { HKeysCommand } from "./hkeys"
-const client = newHttpClient()
-
-const { newKey, cleanup } = keygen()
-afterAll(cleanup)
-
-describe("with existing hash", () => {
-  it("returns all keys", async () => {
-    const key = newKey()
-    const kv = {
-      [randomUUID()]: randomUUID(),
-      [randomUUID()]: randomUUID(),
-    }
-    await new HMSetCommand(key, kv).exec(client)
-    const res = await new HKeysCommand(key).exec(client)
-    expect(res.sort()).toEqual(Object.keys(kv).sort())
-  })
-})

package/pkg/commands/hkeys.ts

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

package/pkg/commands/hlen.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 { HMSetCommand } from "./hmset"
-import { HLenCommand } from "./hlen"
-const client = newHttpClient()
-
-const { newKey, cleanup } = keygen()
-afterAll(cleanup)
-
-describe("with existing hash", () => {
-  it("returns correct number of keys", async () => {
-    const key = newKey()
-    const field1 = randomUUID()
-    const field2 = randomUUID()
-
-    const kv: Record<string, string> = {}
-    kv[field1] = randomUUID()
-    kv[field2] = randomUUID()
-    await new HMSetCommand(key, kv).exec(client)
-    const res = await new HLenCommand(key).exec(client)
-    expect(res).toEqual(2)
-  })
-})

package/pkg/commands/hlen.ts

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

package/pkg/commands/hmget.test.ts

@@ -1,48 +0,0 @@
-import { keygen, newHttpClient } from "../test-utils"
-import { randomUUID } from "crypto"
-import { it, expect, describe, afterAll } from "@jest/globals"
-
-import { HMSetCommand } from "./hmset"
-import { HMGetCommand } from "./hmget"
-import { HSetCommand } from "./hset"
-const client = newHttpClient()
-
-const { newKey, cleanup } = keygen()
-afterAll(cleanup)
-
-it("gets exiting values", async () => {
-  const key = newKey()
-  const field1 = randomUUID()
-  const value1 = randomUUID()
-  const field2 = randomUUID()
-  const value2 = randomUUID()
-  const kv: Record<string, string> = {
-    [field1]: value1,
-    [field2]: value2,
-  }
-  const res = await new HMSetCommand(key, kv).exec(client)
-
-  expect(res).toEqual("OK")
-  const res2 = await new HMGetCommand(key, field1, field2).exec(client)
-
-  expect(res2).toEqual(kv)
-})
-
-describe("when the hash does not exist", () => {
-  it("returns null", async () => {
-    const key = newKey()
-    const res = await new HMGetCommand(key, randomUUID()).exec(client)
-
-    expect(res).toBeNull()
-  })
-})
-
-it("gets an object", async () => {
-  const key = newKey()
-  const field = randomUUID()
-  const value = { v: randomUUID() }
-  await new HSetCommand(key, field, value).exec(client)
-  const cmd = new HMGetCommand(key, field)
-  const res = await cmd.exec(client)
-  expect(res).toEqual({ [field]: value })
-})

package/pkg/commands/hmget.ts

@@ -1,41 +0,0 @@
-import { Command } from "../command"
-
-function deserialize<TData extends Record<string, unknown>>(
-  fields: string[],
-  result: (string | null)[],
-): TData | null {
-  if (result.length === 0 || result.every((field) => field === null)) {
-    return null
-  }
-  const obj: Record<string, unknown> = {}
-  for (let i = 0; i < fields.length; i++) {
-    try {
-      obj[fields[i]] = JSON.parse(result[i]!)
-    } catch {
-      obj[fields[i]] = result[i]
-    }
-  }
-  return obj as TData
-}
-
-/**
- * hmget returns an object of all requested fields from a hash
- * The field values are returned as an object like this:
- * ```ts
- * {[fieldName: string]: T | null}
- * ```
- *
- * In case the hash does not exist or all fields are empty `null` is returned
- *
- * @see https://redis.io/commands/hmget
- */
-export class HMGetCommand<TData extends Record<string, unknown>> extends Command<
-  TData | null,
-  (string | null)[]
-> {
-  constructor(key: string, ...fields: string[]) {
-    super(["hmget", key, ...fields], {
-      deserialize: (result) => deserialize<TData>(fields, result),
-    })
-  }
-}

package/pkg/commands/hmset.test.ts

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

package/pkg/commands/hmset.ts

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

package/pkg/commands/hscan.test.ts

@@ -1,46 +0,0 @@
-import { keygen, newHttpClient } from "../test-utils"
-import { it, describe, expect, afterAll } from "@jest/globals"
-import { HSetCommand } from "./hset"
-import { HScanCommand } from "./hscan"
-const client = newHttpClient()
-
-const { newKey, cleanup } = keygen()
-afterAll(cleanup)
-describe("without options", () => {
-  it("returns cursor and members", async () => {
-    const key = newKey()
-    await new HSetCommand(key, "field", "value").exec(client)
-    const res = await new HScanCommand(key, 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 members", async () => {
-    const key = newKey()
-    await new HSetCommand(key, "field", "value").exec(client)
-    const res = await new HScanCommand(key, 0, { match: "field" }).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 members", async () => {
-    const key = newKey()
-    await new HSetCommand(key, "field", "value").exec(client)
-    const res = await new HScanCommand(key, 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/hscan.ts

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

package/pkg/commands/hset.test.ts

@@ -1,21 +0,0 @@
-import { keygen, newHttpClient } from "../test-utils"
-import { randomUUID } from "crypto"
-import { it, expect, afterAll } from "@jest/globals"
-import { HSetCommand } from "./hset"
-import { HGetCommand } from "./hget"
-const client = newHttpClient()
-
-const { newKey, cleanup } = keygen()
-afterAll(cleanup)
-it("sets value", async () => {
-  const key = newKey()
-  const field = randomUUID()
-  const value = randomUUID()
-
-  const res = await new HSetCommand(key, field, value).exec(client)
-
-  expect(res).toEqual(1)
-  const res2 = await new HGetCommand(key, field).exec(client)
-
-  expect(res2).toEqual(value)
-})

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