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

package/pkg/commands/hincrby.test.ts

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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