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

package/pkg/commands/getrange.test.ts

@@ -1,25 +0,0 @@
-import { keygen, newHttpClient } from "../test-utils"
-import { it, expect, afterAll } from "@jest/globals"
-import { GetRangeCommand } from "./getrange"
-import { SetCommand } from "./set"
-const client = newHttpClient()
-
-const { newKey, cleanup } = keygen()
-afterAll(cleanup)
-
-it("gets an exiting value", async () => {
-  const key = newKey()
-  const value = "Hello World"
-  await new SetCommand(key, value).exec(client)
-  const res = await new GetRangeCommand(key, 2, 4).exec(client)
-
-  expect(res).toBeDefined()
-  expect(res!).toEqual(value.slice(2, 5))
-})
-
-it("gets a non-existing value", async () => {
-  const key = newKey()
-  const res = await new GetRangeCommand(key, 10, 24).exec(client)
-
-  expect(res).toEqual("")
-})

package/pkg/commands/getrange.ts

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

package/pkg/commands/getset.test.ts

@@ -1,33 +0,0 @@
-import { keygen, newHttpClient } from "../test-utils"
-import { randomUUID } from "crypto"
-import { it, expect, afterAll } from "@jest/globals"
-import { GetSetCommand } from "./getset"
-import { SetCommand } from "./set"
-import { GetCommand } from "./get"
-const client = newHttpClient()
-
-const { newKey, cleanup } = keygen()
-afterAll(cleanup)
-
-it("overwrites the original value", async () => {
-  const key = newKey()
-  const value = randomUUID()
-  const newValue = randomUUID()
-  await new SetCommand(key, value).exec(client)
-  const res = await new GetSetCommand(key, newValue).exec(client)
-
-  expect(res).toEqual(value)
-  const res2 = await new GetCommand(key).exec(client)
-
-  expect(res2).toEqual(newValue)
-})
-it("sets a new value if empty", async () => {
-  const key = newKey()
-  const newValue = randomUUID()
-  const res = await new GetSetCommand(key, newValue).exec(client)
-
-  expect(res).toBeNull()
-  const res2 = await new GetCommand(key).exec(client)
-
-  expect(res2).toEqual(newValue)
-})

package/pkg/commands/getset.ts

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

package/pkg/commands/hdel.test.ts

@@ -1,30 +0,0 @@
-import { keygen, newHttpClient } from "../test-utils"
-import { randomUUID } from "crypto"
-import { it, expect, afterAll } from "@jest/globals"
-import { HDelCommand } from "./hdel"
-import { HSetCommand } from "./hset"
-import { HGetCommand } from "./hget"
-const client = newHttpClient()
-
-const { newKey, cleanup } = keygen()
-afterAll(cleanup)
-
-it("deletes a hash that does not exist", async () => {
-  const key = newKey()
-  const field = randomUUID()
-  const res = await new HDelCommand(key, field).exec(client)
-
-  expect(res).toEqual(0)
-})
-
-it("deletes a field that exists", async () => {
-  const key = newKey()
-  const field = randomUUID()
-  await new HSetCommand(key, field, randomUUID()).exec(client)
-  const res = await new HDelCommand(key, field).exec(client)
-
-  expect(res).toEqual(1)
-  const res2 = await new HGetCommand(key, field).exec(client)
-
-  expect(res2).toEqual(null)
-})

package/pkg/commands/hdel.ts

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

package/pkg/commands/hexists.test.ts

@@ -1,31 +0,0 @@
-import { keygen, newHttpClient } from "../test-utils"
-import { randomUUID } from "crypto"
-import { it, expect, afterAll } from "@jest/globals"
-import { HSetCommand } from "./hset"
-import { HExistsCommand } from "./hexists"
-
-const client = newHttpClient()
-
-const { newKey, cleanup } = keygen()
-afterAll(cleanup)
-
-it("returns 1 for an existing field", async () => {
-  const key = newKey()
-  const field = randomUUID()
-  await new HSetCommand(key, field, randomUUID()).exec(client)
-  const res = await new HExistsCommand(key, field).exec(client)
-  expect(res).toEqual(1)
-})
-it("returns 0 if field does not exist", async () => {
-  const key = newKey()
-  await new HSetCommand(key, randomUUID(), randomUUID()).exec(client)
-
-  const res = await new HExistsCommand(key, "not-existing-field").exec(client)
-  expect(res).toEqual(0)
-})
-it("returns 0 if hash does not exist", async () => {
-  const key = newKey()
-  const field = randomUUID()
-  const res = await new HExistsCommand(key, field).exec(client)
-  expect(res).toEqual(0)
-})

package/pkg/commands/hexists.ts

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

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