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

package/pkg/commands/smove.test.ts

@@ -1,18 +0,0 @@
-import { keygen, newHttpClient } from "../test-utils"
-import { randomUUID } from "crypto"
-import { it, expect, afterAll } from "@jest/globals"
-import { SAddCommand } from "./sadd"
-import { SMoveCommand } from "./smove"
-const client = newHttpClient()
-
-const { newKey, cleanup } = keygen()
-afterAll(cleanup)
-
-it("moves the member", async () => {
-  const source = newKey()
-  const destination = newKey()
-  const member = randomUUID()
-  await new SAddCommand(source, member).exec(client)
-  const res = await new SMoveCommand(source, destination, member).exec(client)
-  expect(res).toBe(1)
-})

package/pkg/commands/smove.ts

@@ -1,9 +0,0 @@
-import { Command } from "../command"
-/**
- * @see https://redis.io/commands/smove
- */
-export class SMoveCommand<TData> extends Command<0 | 1, "0" | "1"> {
-  constructor(source: string, destination: string, member: TData) {
-    super(["smove", source, destination, member])
-  }
-}

package/pkg/commands/spop.test.ts

@@ -1,35 +0,0 @@
-import { keygen, newHttpClient } from "../test-utils"
-import { randomUUID } from "crypto"
-import { describe, it, expect, afterAll } from "@jest/globals"
-import { SAddCommand } from "./sadd"
-import { SPopCommand } from "./spop"
-const client = newHttpClient()
-
-const { newKey, cleanup } = keygen()
-afterAll(cleanup)
-
-describe("without count", () => {
-  it("returns the first element", async () => {
-    const key = newKey()
-    const member = randomUUID()
-    await new SAddCommand(key, member).exec(client)
-    const res = await new SPopCommand(key).exec(client)
-    expect(res).toBe(member)
-  })
-})
-
-describe("with count", () => {
-  it("returns the first n elements", async () => {
-    const key = newKey()
-    const member1 = randomUUID()
-    const member2 = randomUUID()
-    const member3 = randomUUID()
-    const member4 = randomUUID()
-    await new SAddCommand(key, member1, member2, member3, member4).exec(client)
-    const res = await new SPopCommand<string[]>(key, 2).exec(client)
-    expect(res).not.toBeNull()
-    expect(res!).toHaveLength(2)
-    expect([member1, member2, member3, member4].includes(res![0])).toBe(true)
-    expect([member1, member2, member3, member4].includes(res![1])).toBe(true)
-  })
-})

package/pkg/commands/spop.ts

@@ -1,13 +0,0 @@
-import { Command } from "../command"
-/**
- * @see https://redis.io/commands/spop
- */
-export class SPopCommand<TData = number> extends Command<TData | null, string | null> {
-  constructor(key: string, count?: number) {
-    const command: unknown[] = ["spop", key]
-    if (typeof count === "number") {
-      command.push(count)
-    }
-    super(command)
-  }
-}

package/pkg/commands/srandmember.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 { SAddCommand } from "./sadd"
-import { SRandMemberCommand } from "./srandmember"
-const client = newHttpClient()
-
-const { newKey, cleanup } = keygen()
-afterAll(cleanup)
-
-describe("without opts", () => {
-  it("returns a random key", async () => {
-    const key = newKey()
-    const member = randomUUID()
-    await new SAddCommand(key, member).exec(client)
-    const res = await new SRandMemberCommand(key).exec(client)
-    expect(res).toBeDefined()
-    expect(res).toBe(member)
-  })
-})
-
-describe("with count", () => {
-  it("returns a random key", async () => {
-    const key = newKey()
-    const member1 = randomUUID()
-    const member2 = randomUUID()
-    await new SAddCommand(key, member1, member2).exec(client)
-    const res = await new SRandMemberCommand(key, 2).exec(client)
-    expect(res).toBeDefined()
-    expect(res).toHaveLength(2)
-  })
-})

package/pkg/commands/srandmember.ts

@@ -1,13 +0,0 @@
-import { Command } from "../command"
-/**
- * @see https://redis.io/commands/srandmember
- */
-export class SRandMemberCommand<TData> extends Command<TData | null, string | null> {
-  constructor(key: string, count?: number) {
-    const command: unknown[] = ["srandmember", key]
-    if (typeof count === "number") {
-      command.push(count)
-    }
-    super(command)
-  }
-}

package/pkg/commands/srem.test.ts

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

package/pkg/commands/srem.ts

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

package/pkg/commands/sscan.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 { SAddCommand } from "./sadd"
-import { SScanCommand } from "./sscan"
-const client = newHttpClient()
-
-const { newKey, cleanup } = keygen()
-afterAll(cleanup)
-describe("without options", () => {
-  it("returns cursor and members", async () => {
-    const key = newKey()
-    const member = randomUUID()
-    await new SAddCommand(key, member).exec(client)
-    const res = await new SScanCommand(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()
-    const member = randomUUID()
-    await new SAddCommand(key, member).exec(client)
-    const res = await new SScanCommand(key, 0, { match: member }).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()
-    const member = randomUUID()
-    await new SAddCommand(key, member).exec(client)
-    const res = await new SScanCommand(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/sscan.ts

@@ -1,22 +0,0 @@
-import { ScanCommandOptions } from "./scan"
-import { Command } from "../command"
-
-/**
- * @see https://redis.io/commands/sscan
- */
-export class SScanCommand extends Command<
-  [number, (string | number)[]],
-  [number, (string | number)[]]
-> {
-  constructor(key: string, cursor: number, opts?: ScanCommandOptions) {
-    const command = ["sscan", 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/strlen.test.ts

@@ -1,16 +0,0 @@
-import { keygen, newHttpClient } from "../test-utils"
-import { it, expect, afterAll } from "@jest/globals"
-import { SetCommand } from "./set"
-import { StrLenCommand } from "./strlen"
-const client = newHttpClient()
-
-const { newKey, cleanup } = keygen()
-afterAll(cleanup)
-
-it("returns the correct length", async () => {
-  const key = newKey()
-  const value = "abcd"
-  await new SetCommand(key, value).exec(client)
-  const res = await new StrLenCommand(key).exec(client)
-  expect(res).toBe(value.length)
-})

package/pkg/commands/strlen.ts

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

package/pkg/commands/sunion.test.ts

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

package/pkg/commands/sunion.ts

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

package/pkg/commands/sunionstore.test.ts

@@ -1,29 +0,0 @@
-import { keygen, newHttpClient } from "../test-utils"
-import { randomUUID } from "crypto"
-import { it, expect, afterAll } from "@jest/globals"
-import { SAddCommand } from "./sadd"
-import { SUnionStoreCommand } from "./sunionstore"
-import { SMembersCommand } from "./smembers"
-const client = newHttpClient()
-
-const { newKey, cleanup } = keygen()
-afterAll(cleanup)
-
-it("writes the union to destination", async () => {
-  const key1 = newKey()
-  const key2 = newKey()
-  const dest = newKey()
-
-  const member1 = randomUUID()
-  const member2 = randomUUID()
-
-  await new SAddCommand(key1, member1).exec(client)
-  await new SAddCommand(key2, member2).exec(client)
-  const res = await new SUnionStoreCommand(dest, key1, key2).exec(client)
-  expect(res).toBe(2)
-
-  const res2 = await new SMembersCommand(dest).exec(client)
-
-  expect(res2).toBeDefined()
-  expect(res2!.sort()).toEqual([member1, member2].sort())
-})

package/pkg/commands/sunionstore.ts

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

package/pkg/commands/time.test.ts

@@ -1,11 +0,0 @@
-import { newHttpClient } from "../test-utils"
-import { it, expect } from "@jest/globals"
-import { TimeCommand } from "./time"
-const client = newHttpClient()
-
-it("returns the time", async () => {
-  const res = await new TimeCommand().exec(client)
-  expect(res).toBeDefined()
-  expect(typeof res[0]).toBe("number")
-  expect(typeof res[1]).toBe("number")
-})

package/pkg/commands/time.ts

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

package/pkg/commands/touch.test.ts

@@ -1,20 +0,0 @@
-import { keygen, newHttpClient } from "../test-utils"
-import { randomUUID } from "crypto"
-import { it, expect, afterAll } from "@jest/globals"
-import { MSetCommand } from "./mset"
-import { TouchCommand } from "./touch"
-const client = newHttpClient()
-
-const { newKey, cleanup } = keygen()
-afterAll(cleanup)
-
-it("returns the number of touched keys", async () => {
-  const key1 = newKey()
-  const key2 = newKey()
-  const kv: Record<string, string> = {}
-  kv[key1] = randomUUID()
-  kv[key2] = randomUUID()
-  await new MSetCommand(kv).exec(client)
-  const res = await new TouchCommand(key1, key2).exec(client)
-  expect(res).toBe(2)
-})

package/pkg/commands/touch.ts

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

package/pkg/commands/ttl.test.ts

@@ -1,17 +0,0 @@
-import { keygen, newHttpClient } from "../test-utils"
-
-import { it, expect, afterAll } from "@jest/globals"
-import { SetExCommand } from "./setex"
-import { TtlCommand } from "./ttl"
-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 TtlCommand(key).exec(client)
-  expect(res).toBeLessThanOrEqual(ttl)
-})

package/pkg/commands/ttl.ts

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

package/pkg/commands/type.test.ts

@@ -1,72 +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 { TypeCommand } from "./type"
-import { LPushCommand } from "./lpush"
-import { HSetCommand } from "./hset"
-import { SAddCommand } from "./sadd"
-import { ZAddCommand } from "./zadd"
-const client = newHttpClient()
-
-const { newKey, cleanup } = keygen()
-afterAll(cleanup)
-
-describe("string", () => {
-  it("returns the correct type", async () => {
-    const key = newKey()
-    const value = randomUUID()
-    await new SetCommand(key, value).exec(client)
-    const res = await new TypeCommand(key).exec(client)
-    expect(res).toEqual("string")
-  })
-})
-
-describe("list", () => {
-  it("returns the correct type", async () => {
-    const key = newKey()
-    const value = randomUUID()
-    await new LPushCommand(key, value).exec(client)
-    const res = await new TypeCommand(key).exec(client)
-    expect(res).toEqual("list")
-  })
-})
-
-describe("set", () => {
-  it("returns the correct type", async () => {
-    const key = newKey()
-    const value = randomUUID()
-    await new SAddCommand(key, value).exec(client)
-    const res = await new TypeCommand(key).exec(client)
-    expect(res).toEqual("set")
-  })
-})
-
-describe("hash", () => {
-  it("returns the correct type", async () => {
-    const key = newKey()
-    const field = randomUUID()
-    const value = randomUUID()
-    await new HSetCommand(key, field, value).exec(client)
-    const res = await new TypeCommand(key).exec(client)
-    expect(res).toEqual("hash")
-  })
-})
-
-describe("zset", () => {
-  it("returns the correct type", async () => {
-    const key = newKey()
-    const member = randomUUID()
-    await new ZAddCommand(key, { score: 0, member }).exec(client)
-    const res = await new TypeCommand(key).exec(client)
-    expect(res).toEqual("zset")
-  })
-})
-
-describe("none", () => {
-  it("returns the correct type", async () => {
-    const key = newKey()
-    const res = await new TypeCommand(key).exec(client)
-    expect(res).toEqual("none")
-  })
-})

package/pkg/commands/type.ts

@@ -1,11 +0,0 @@
-import { Command } from "../command"
-
-export type Type = "string" | "list" | "set" | "zset" | "hash" | "none"
-/**
- * @see https://redis.io/commands/type
- */
-export class TypeCommand extends Command<Type, Type> {
-  constructor(key: string) {
-    super(["type", key])
-  }
-}

package/pkg/commands/unlink.test.ts

@@ -1,21 +0,0 @@
-import { keygen, newHttpClient } from "../test-utils"
-import { randomUUID } from "crypto"
-import { it, expect, afterAll } from "@jest/globals"
-import { MSetCommand } from "./mset"
-import { UnlinkCommand } from "./unlink"
-const client = newHttpClient()
-
-const { newKey, cleanup } = keygen()
-afterAll(cleanup)
-
-it("unlinks the keys", async () => {
-  const key1 = newKey()
-  const key2 = newKey()
-  const key3 = newKey()
-  const kv: Record<string, string> = {}
-  kv[key1] = randomUUID()
-  kv[key2] = randomUUID()
-  await new MSetCommand(kv).exec(client)
-  const res = await new UnlinkCommand(key1, key2, key3).exec(client)
-  expect(res).toEqual(2)
-})

package/pkg/commands/unlink.ts

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