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

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

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