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

package/pkg/commands/rpushx.ts

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

package/pkg/commands/sadd.test.ts

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

package/pkg/commands/sadd.ts

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

package/pkg/commands/scan.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 { SetCommand } from "./set"
-import { ScanCommand } from "./scan"
-const client = newHttpClient()
-
-const { newKey, cleanup } = keygen()
-afterAll(cleanup)
-describe("without options", () => {
-  it("returns cursor and keys", async () => {
-    const key = newKey()
-    const value = randomUUID()
-    await new SetCommand(key, value).exec(client)
-    const res = await new ScanCommand(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 keys", async () => {
-    const key = newKey()
-    const value = randomUUID()
-    await new SetCommand(key, value).exec(client)
-    const res = await new ScanCommand(0, { match: key }).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 keys", async () => {
-    const key = newKey()
-    const value = randomUUID()
-    await new SetCommand(key, value).exec(client)
-    const res = await new ScanCommand(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/scan.ts

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

package/pkg/commands/scard.test.ts

@@ -1,15 +0,0 @@
-import { keygen, newHttpClient } from "../test-utils"
-import { it, expect, afterAll } from "@jest/globals"
-import { SAddCommand } from "./sadd"
-import { SCardCommand } from "./scard"
-const client = newHttpClient()
-
-const { newKey, cleanup } = keygen()
-afterAll(cleanup)
-
-it("returns the cardinality", async () => {
-  const key = newKey()
-  await new SAddCommand(key, "member1").exec(client)
-  const res = await new SCardCommand(key).exec(client)
-  expect(res).toBe(1)
-})

package/pkg/commands/scard.ts

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

package/pkg/commands/sdiff.test.ts

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

package/pkg/commands/sdiff.ts

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

package/pkg/commands/sdiffstore.test.ts

@@ -1,21 +0,0 @@
-import { keygen, newHttpClient } from "../test-utils"
-import { randomUUID } from "crypto"
-import { it, expect, afterAll } from "@jest/globals"
-import { SAddCommand } from "./sadd"
-import { SDiffStoreCommand } from "./sdiffstore"
-const client = newHttpClient()
-
-const { newKey, cleanup } = keygen()
-afterAll(cleanup)
-
-it("returns the diff", async () => {
-  const key1 = newKey()
-  const member1 = randomUUID()
-  const key2 = newKey()
-  const member2 = randomUUID()
-  const destination = newKey()
-  await new SAddCommand(key1, member1).exec(client)
-  await new SAddCommand(key2, member2).exec(client)
-  const res = await new SDiffStoreCommand(destination, key1, key2).exec(client)
-  expect(res).toEqual(1)
-})

package/pkg/commands/sdiffstore.ts

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

package/pkg/commands/set.test.ts

@@ -1,112 +0,0 @@
-import { keygen, newHttpClient } from "../test-utils"
-import { randomUUID } from "crypto"
-import { describe, it, expect, afterAll } from "@jest/globals"
-import { GetCommand } from "./get"
-import { SetCommand } from "./set"
-
-const client = newHttpClient()
-
-const { newKey, cleanup } = keygen()
-afterAll(cleanup)
-describe("without options", () => {
-  it("sets value", async () => {
-    const key = newKey()
-    const value = randomUUID()
-
-    const res = await new SetCommand(key, value).exec(client)
-    expect(res).toEqual("OK")
-    const res2 = await new GetCommand(key).exec(client)
-    expect(res2).toEqual(value)
-  })
-})
-describe("ex", () => {
-  it("sets value", async () => {
-    const key = newKey()
-    const value = randomUUID()
-
-    const res = await new SetCommand(key, value, { ex: 1 }).exec(client)
-    expect(res).toEqual("OK")
-    const res2 = await new GetCommand(key).exec(client)
-    expect(res2).toEqual(value)
-    await new Promise((res) => setTimeout(res, 2000))
-
-    const res3 = await new GetCommand(key).exec(client)
-    expect(res3).toEqual(null)
-  })
-})
-describe("px", () => {
-  it("sets value", async () => {
-    const key = newKey()
-    const value = randomUUID()
-
-    const res = await new SetCommand(key, value, { px: 1000 }).exec(client)
-    expect(res).toEqual("OK")
-    const res2 = await new GetCommand(key).exec(client)
-    expect(res2).toEqual(value)
-    await new Promise((res) => setTimeout(res, 2000))
-
-    const res3 = await new GetCommand(key).exec(client)
-
-    expect(res3).toBeNull()
-  })
-})
-describe("nx", () => {
-  describe("when key exists", () => {
-    it("does nothing", async () => {
-      const key = newKey()
-      const value = randomUUID()
-      const newValue = randomUUID()
-
-      await new SetCommand(key, value).exec(client)
-      const res = await new SetCommand(key, newValue, {
-        nx: true,
-      }).exec(client)
-      expect(res).toBeNull()
-      const res2 = await new GetCommand(key).exec(client)
-      expect(res2).toEqual(value)
-    })
-  })
-  describe("when key does not exists", () => {
-    it("overwrites key", async () => {
-      const key = newKey()
-      const value = randomUUID()
-
-      const res = await new SetCommand(key, value, {
-        nx: true,
-      }).exec(client)
-      expect(res).toEqual("OK")
-      const res2 = await new GetCommand(key).exec(client)
-      expect(res2).toEqual(value)
-    })
-  })
-})
-describe("xx", () => {
-  describe("when key exists", () => {
-    it("overwrites key", async () => {
-      const key = newKey()
-      const value = randomUUID()
-      const newValue = randomUUID()
-
-      await new SetCommand(key, value).exec(client)
-      const res = await new SetCommand(key, newValue, {
-        xx: true,
-      }).exec(client)
-      expect(res).toEqual("OK")
-      const res2 = await new GetCommand(key).exec(client)
-      expect(res2).toEqual(newValue)
-    })
-  })
-  describe("when key does not exists", () => {
-    it("does nothing", async () => {
-      const key = newKey()
-      const value = randomUUID()
-
-      const res = await new SetCommand(key, value, {
-        xx: true,
-      }).exec(client)
-      expect(res).toBeNull()
-      const res2 = await new GetCommand(key).exec(client)
-      expect(res2).toBeNull()
-    })
-  })
-})

package/pkg/commands/set.ts

@@ -1,53 +0,0 @@
-import { Command } from "../command"
-
-export type SetCommandOptions = (
-  | {
-      ex: number
-      px?: never
-    }
-  | {
-      ex?: never
-      px: number
-    }
-  | {
-      ex?: never
-      px?: never
-    }
-) &
-  (
-    | {
-        nx: true
-        xx?: never
-      }
-    | {
-        xx: true
-        nx?: never
-      }
-    | {
-        xx?: never
-        nx?: never
-      }
-  )
-
-/**
- * @see https://redis.io/commands/set
- */
-export class SetCommand<TData, TResult = "OK"> extends Command<TData, TResult> {
-  constructor(key: string, value: TData, opts?: SetCommandOptions) {
-    const command: unknown[] = ["set", key, value]
-    if (opts) {
-      if ("ex" in opts && typeof opts.ex === "number") {
-        command.push("ex", opts.ex)
-      } else if ("px" in opts && typeof opts.px === "number") {
-        command.push("px", opts.px)
-      }
-
-      if ("nx" in opts && opts.nx) {
-        command.push("nx")
-      } else if ("xx" in opts && opts.xx) {
-        command.push("xx")
-      }
-    }
-    super(command)
-  }
-}

package/pkg/commands/setbit.test.ts

@@ -1,16 +0,0 @@
-import { keygen, newHttpClient } from "../test-utils"
-import { SetBitCommand } from "./setbit"
-import { it, expect, afterAll } from "@jest/globals"
-const client = newHttpClient()
-
-const { newKey, cleanup } = keygen()
-afterAll(cleanup)
-
-it("returns the original bit", async () => {
-  const key = newKey()
-  const res = await new SetBitCommand(key, 0, 1).exec(client)
-  expect(res).toBe(0)
-  const res2 = await new SetBitCommand(key, 0, 1).exec(client)
-
-  expect(res2).toBe(1)
-})

package/pkg/commands/setbit.ts

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

package/pkg/commands/setex.test.ts

@@ -1,22 +0,0 @@
-import { keygen, newHttpClient } from "../test-utils"
-import { randomUUID } from "crypto"
-import { it, expect, afterAll } from "@jest/globals"
-import { SetExCommand } from "./setex"
-import { GetCommand } from "./get"
-
-const client = newHttpClient()
-
-const { newKey, cleanup } = keygen()
-afterAll(cleanup)
-it("sets value", async () => {
-  const key = newKey()
-  const value = randomUUID()
-
-  const res = await new SetExCommand(key, 1, value).exec(client)
-
-  expect(res).toEqual("OK")
-  await new Promise((res) => setTimeout(res, 2000))
-  const res2 = await new GetCommand(key).exec(client)
-
-  expect(res2).toBeNull()
-})

package/pkg/commands/setex.ts

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

package/pkg/commands/setnx.test.ts

@@ -1,27 +0,0 @@
-import { keygen, newHttpClient } from "../test-utils"
-import { randomUUID } from "crypto"
-import { it, expect, afterAll } from "@jest/globals"
-import { SetCommand } from "./set"
-import { GetCommand } from "./get"
-import { SetNxCommand } from "./setnx"
-
-const client = newHttpClient()
-
-const { newKey, cleanup } = keygen()
-afterAll(cleanup)
-
-it("sets value", async () => {
-  const key = newKey()
-  const value = randomUUID()
-  const newValue = randomUUID()
-
-  const res = await new SetCommand(key, value).exec(client)
-
-  expect(res).toEqual("OK")
-  const res2 = await new SetNxCommand(key, newValue).exec(client)
-
-  expect(res2).toEqual(0)
-  const res3 = await new GetCommand(key).exec(client)
-
-  expect(res3).toEqual(value)
-})

package/pkg/commands/setnx.ts

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

package/pkg/commands/setrange.test.ts

@@ -1,25 +0,0 @@
-import { keygen, newHttpClient } from "../test-utils"
-import { it, expect, afterAll } from "@jest/globals"
-import { SetCommand } from "./set"
-import { SetRangeCommand } from "./setrange"
-import { GetCommand } from "./get"
-
-const client = newHttpClient()
-
-const { newKey, cleanup } = keygen()
-afterAll(cleanup)
-
-it("sets value", async () => {
-  const key = newKey()
-  const value = "originalValue"
-
-  const res = await new SetCommand(key, value).exec(client)
-
-  expect(res).toEqual("OK")
-  const res2 = await new SetRangeCommand(key, 4, "helloWorld").exec(client)
-
-  expect(res2).toEqual(14)
-  const res3 = await new GetCommand(key).exec(client)
-
-  expect(res3).toEqual("orighelloWorld")
-})

package/pkg/commands/setrange.ts

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

package/pkg/commands/sinter.test.ts

@@ -1,36 +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 { SInterCommand } from "./sinter"
-const client = newHttpClient()
-
-const { newKey, cleanup } = keygen()
-afterAll(cleanup)
-
-describe("with single set", () => {
-  it("returns the members of the set", async () => {
-    const key = newKey()
-    const value1 = { v: randomUUID() }
-    const value2 = { v: randomUUID() }
-    await new SAddCommand(key, value1, value2).exec(client)
-    const res = await new SInterCommand<{ v: string }>(key).exec(client)
-    expect(res).toHaveLength(2)
-    expect(res.map(({ v }) => v).includes(value1.v)).toBe(true)
-    expect(res.map(({ v }) => v).includes(value2.v)).toBe(true)
-  })
-})
-
-describe("with multiple sets", () => {
-  it("returns the members of the set", async () => {
-    const key1 = newKey()
-    const key2 = newKey()
-    const value1 = { v: randomUUID() }
-    const value2 = { v: randomUUID() }
-    const value3 = { v: randomUUID() }
-    await new SAddCommand(key1, value1, value2).exec(client)
-    await new SAddCommand(key2, value2, value3).exec(client)
-    const res = await new SInterCommand(key1, key2).exec(client)
-    expect(res).toEqual([value2])
-  })
-})

package/pkg/commands/sinter.ts

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

package/pkg/commands/sinterstore.test.ts

@@ -1,21 +0,0 @@
-import { keygen, newHttpClient } from "../test-utils"
-import { randomUUID } from "crypto"
-import { it, expect, afterAll } from "@jest/globals"
-import { SAddCommand } from "./sadd"
-import { SInterStoreCommand } from "./sinterstore"
-const client = newHttpClient()
-
-const { newKey, cleanup } = keygen()
-afterAll(cleanup)
-
-it("stores the intersection", async () => {
-  const key1 = newKey()
-  const member1 = randomUUID()
-  const key2 = newKey()
-  const member2 = member1
-  const destination = newKey()
-  await new SAddCommand(key1, member1).exec(client)
-  await new SAddCommand(key2, member2).exec(client)
-  const res = await new SInterStoreCommand(destination, key1, key2).exec(client)
-  expect(res).toEqual(1)
-})

package/pkg/commands/sinterstore.ts

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

package/pkg/commands/sismember.test.ts

@@ -1,30 +0,0 @@
-import { keygen, newHttpClient } from "../test-utils"
-import { randomUUID } from "crypto"
-import { SAddCommand } from "./sadd"
-import { SIsMemberCommand } from "./sismember"
-import { describe, it, expect, afterAll } from "@jest/globals"
-const client = newHttpClient()
-
-const { newKey, cleanup } = keygen()
-afterAll(cleanup)
-
-describe("when member exists", () => {
-  it("returns 1", async () => {
-    const key = newKey()
-    const value = randomUUID()
-    await new SAddCommand(key, value).exec(client)
-    const res = await new SIsMemberCommand(key, value).exec(client)
-    expect(res).toBe(1)
-  })
-})
-
-describe("when member exists", () => {
-  it("returns 1", async () => {
-    const key = newKey()
-    const value1 = randomUUID()
-    const value2 = randomUUID()
-    await new SAddCommand(key, value1).exec(client)
-    const res = await new SIsMemberCommand(key, value2).exec(client)
-    expect(res).toBe(0)
-  })
-})

package/pkg/commands/sismember.ts

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

package/pkg/commands/smembers.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 { SMembersCommand } from "./smembers"
-const client = newHttpClient()
-
-const { newKey, cleanup } = keygen()
-afterAll(cleanup)
-
-it("returns all members of the set", async () => {
-  const key = newKey()
-  const value1 = { v: randomUUID() }
-  const value2 = { v: randomUUID() }
-
-  await new SAddCommand(key, value1, value2).exec(client)
-  const res = await new SMembersCommand<{ v: string }>(key).exec(client)
-  expect(res).toBeDefined()
-  expect(res!.length).toBe(2)
-  expect(res!.map(({ v }) => v).includes(value1.v)).toBe(true)
-  expect(res!.map(({ v }) => v).includes(value2.v)).toBe(true)
-})

package/pkg/commands/smembers.ts

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