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

package/pkg/commands/zremrangebyrank.test.ts

@@ -1,27 +0,0 @@
-import { keygen, newHttpClient } from "../test-utils"
-import { randomUUID } from "crypto"
-import { it, expect, afterAll } from "@jest/globals"
-import { ZAddCommand } from "./zadd"
-import { ZRemRangeByRankCommand } from "./zremrangebyrank"
-const client = newHttpClient()
-
-const { newKey, cleanup } = keygen()
-afterAll(cleanup)
-
-it("returns the number of removed elements", async () => {
-  const key = newKey()
-  const score1 = 1
-  const member1 = randomUUID()
-  const score2 = 2
-  const member2 = randomUUID()
-  const score3 = 3
-  const member3 = randomUUID()
-  await new ZAddCommand(
-    key,
-    { score: score1, member: member1 },
-    { score: score2, member: member2 },
-    { score: score3, member: member3 },
-  ).exec(client)
-  const res = await new ZRemRangeByRankCommand(key, 1, 2).exec(client)
-  expect(res).toBe(2)
-})

package/pkg/commands/zremrangebyrank.ts

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

package/pkg/commands/zremrangebyscore.test.ts

@@ -1,24 +0,0 @@
-import { keygen, newHttpClient } from "../test-utils"
-import { randomUUID } from "crypto"
-import { ZAddCommand } from "./zadd"
-import { it, expect, afterAll } from "@jest/globals"
-import { ZRemRangeByScoreCommand } from "./zremrangebyscore"
-const client = newHttpClient()
-
-const { newKey, cleanup } = keygen()
-afterAll(cleanup)
-
-it("returns the number of removed elements", async () => {
-  const key = newKey()
-  const member1 = randomUUID()
-  const member2 = randomUUID()
-  const member3 = randomUUID()
-  await new ZAddCommand(
-    key,
-    { score: 1, member: member1 },
-    { score: 2, member: member2 },
-    { score: 3, member: member3 },
-  ).exec(client)
-  const res = await new ZRemRangeByScoreCommand(key, 1, 2).exec(client)
-  expect(res).toBe(2)
-})

package/pkg/commands/zremrangebyscore.ts

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

package/pkg/commands/zrevrank.test.ts

@@ -1,22 +0,0 @@
-import { keygen, newHttpClient } from "../test-utils"
-import { it, expect, afterAll } from "@jest/globals"
-import { ZAddCommand } from "./zadd"
-import { ZRevRankCommand } from "./zrevrank"
-const client = newHttpClient()
-
-const { newKey, cleanup } = keygen()
-afterAll(cleanup)
-
-it("returns the rank", async () => {
-  const key = newKey()
-
-  await new ZAddCommand(
-    key,
-    { score: 1, member: "member1" },
-    { score: 2, member: "member2" },
-    { score: 3, member: "member3" },
-  ).exec(client)
-
-  const res = await new ZRevRankCommand(key, "member2").exec(client)
-  expect(res).toBe(1)
-})

package/pkg/commands/zrevrank.ts

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

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

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

@@ -1,18 +0,0 @@
-import { keygen, newHttpClient } from "../test-utils"
-import { randomInt, randomUUID } from "crypto"
-import { it, expect, afterAll } from "@jest/globals"
-import { ZAddCommand } from "./zadd"
-import { ZScoreCommand } from "./zscore"
-const client = newHttpClient()
-
-const { newKey, cleanup } = keygen()
-afterAll(cleanup)
-
-it("returns the score", async () => {
-  const key = newKey()
-  const member = randomUUID()
-  const score = randomInt(10)
-  await new ZAddCommand(key, { score, member }).exec(client)
-  const res = await new ZScoreCommand(key, member).exec(client)
-  expect(res).toBe(score)
-})

package/pkg/commands/zscore.ts

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

package/pkg/commands/zunionstore.test.ts

@@ -1,215 +0,0 @@
-import { keygen, newHttpClient } from "../test-utils"
-import { randomUUID } from "crypto"
-import { describe, it, expect, afterAll } from "@jest/globals"
-import { ZUnionStoreCommand } from "./zunionstore"
-import { ZAddCommand } from "./zadd"
-
-const client = newHttpClient()
-
-const { newKey, cleanup } = keygen()
-afterAll(cleanup)
-
-describe("command format", () => {
-  describe("without options", () => {
-    it("builds the correct command", () => {
-      expect(new ZUnionStoreCommand("destination", 1, "key").command).toEqual([
-        "zunionstore",
-        "destination",
-        "1",
-        "key",
-      ])
-    })
-  })
-  describe("with multiple keys", () => {
-    it("builds the correct command", () => {
-      expect(new ZUnionStoreCommand("destination", 2, ["key1", "key2"]).command).toEqual([
-        "zunionstore",
-        "destination",
-        "2",
-        "key1",
-        "key2",
-      ])
-    })
-  })
-  describe("with single weight", () => {
-    it("builds the correct command", () => {
-      expect(new ZUnionStoreCommand("destination", 1, "key", { weight: 4 }).command).toEqual([
-        "zunionstore",
-        "destination",
-        "1",
-        "key",
-        "weights",
-        "4",
-      ])
-    })
-  })
-  describe("with multiple weights", () => {
-    it("builds the correct command", () => {
-      expect(
-        new ZUnionStoreCommand("destination", 2, ["key1", "key2"], { weights: [2, 3] }).command,
-      ).toEqual(["zunionstore", "destination", "2", "key1", "key2", "weights", "2", "3"])
-    })
-    describe("with aggregate", () => {
-      describe("sum", () => {
-        it("builds the correct command", () => {
-          expect(
-            new ZUnionStoreCommand("destination", 1, "key", { aggregate: "sum" }).command,
-          ).toEqual(["zunionstore", "destination", "1", "key", "aggregate", "sum"])
-        })
-      })
-      describe("min", () => {
-        it("builds the correct command", () => {
-          expect(
-            new ZUnionStoreCommand("destination", 1, "key", { aggregate: "min" }).command,
-          ).toEqual(["zunionstore", "destination", "1", "key", "aggregate", "min"])
-        })
-      })
-      describe("max", () => {
-        it("builds the correct command", () => {
-          expect(
-            new ZUnionStoreCommand("destination", 1, "key", { aggregate: "max" }).command,
-          ).toEqual(["zunionstore", "destination", "1", "key", "aggregate", "max"])
-        })
-      })
-    })
-    describe("complex", () => {
-      it("builds the correct command", () => {
-        expect(
-          new ZUnionStoreCommand("destination", 2, ["key1", "key2"], {
-            weights: [4, 2],
-            aggregate: "max",
-          }).command,
-        ).toEqual([
-          "zunionstore",
-          "destination",
-          "2",
-          "key1",
-          "key2",
-          "weights",
-          "4",
-          "2",
-          "aggregate",
-          "max",
-        ])
-      })
-    })
-  })
-})
-
-describe("without options", () => {
-  it("returns the number of elements in the new set ", async () => {
-    const destination = newKey()
-    const key1 = newKey()
-    const key2 = newKey()
-    const score1 = 1
-    const member1 = randomUUID()
-    const score2 = 2
-    const member2 = randomUUID()
-
-    await new ZAddCommand(key1, { score: score1, member: member1 }).exec(client)
-    await new ZAddCommand(key2, { score: score2, member: member2 }).exec(client)
-
-    const res = await new ZUnionStoreCommand(destination, 2, [key1, key2]).exec(client)
-    expect(res).toBe(2)
-  })
-})
-
-describe("with weights", () => {
-  describe("single weight", () => {
-    it("returns the number of elements in the new set ", async () => {
-      const destination = newKey()
-      const key1 = newKey()
-      const key2 = newKey()
-      const score1 = 1
-      const member1 = randomUUID()
-      const score2 = 2
-      const member2 = randomUUID()
-
-      await new ZAddCommand(key1, { score: score1, member: member1 }).exec(client)
-      await new ZAddCommand(key2, { score: score2, member: member2 }).exec(client)
-
-      const res = await new ZUnionStoreCommand(destination, 2, [key1, key2], {
-        weights: [2, 3],
-      }).exec(client)
-      expect(res).toBe(2)
-    })
-  })
-  describe("multiple weight", () => {
-    it("returns the number of elements in the new set ", async () => {
-      const destination = newKey()
-      const key1 = newKey()
-      const key2 = newKey()
-      const score1 = 1
-      const member1 = randomUUID()
-      const score2 = 2
-      const member2 = randomUUID()
-
-      await new ZAddCommand(key1, { score: score1, member: member1 }).exec(client)
-      await new ZAddCommand(key2, { score: score2, member: member2 }).exec(client)
-
-      const res = await new ZUnionStoreCommand(destination, 2, [key1, key2], {
-        weights: [1, 2],
-      }).exec(client)
-      expect(res).toBe(2)
-    })
-  })
-})
-describe("aggregate", () => {
-  describe("sum", () => {
-    it("returns the number of elements in the new set ", async () => {
-      const destination = newKey()
-      const key1 = newKey()
-      const key2 = newKey()
-      const score1 = 1
-      const member1 = randomUUID()
-      const score2 = 2
-      const member2 = randomUUID()
-
-      await new ZAddCommand(key1, { score: score1, member: member1 }).exec(client)
-      await new ZAddCommand(key2, { score: score2, member: member2 }).exec(client)
-
-      const res = await new ZUnionStoreCommand(destination, 2, [key1, key2], {
-        aggregate: "sum",
-      }).exec(client)
-      expect(res).toBe(2)
-    })
-  })
-  describe("min", () => {
-    it("returns the number of elements in the new set ", async () => {
-      const destination = newKey()
-      const key1 = newKey()
-      const key2 = newKey()
-      const score1 = 1
-      const member1 = randomUUID()
-      const score2 = 2
-      const member2 = randomUUID()
-
-      await new ZAddCommand(key1, { score: score1, member: member1 }).exec(client)
-      await new ZAddCommand(key2, { score: score2, member: member2 }).exec(client)
-
-      const res = await new ZUnionStoreCommand(destination, 2, [key1, key2], {
-        aggregate: "min",
-      }).exec(client)
-      expect(res).toBe(2)
-    })
-  })
-  describe("max", () => {
-    it("returns the number of elements in the new set ", async () => {
-      const destination = newKey()
-      const key1 = newKey()
-      const key2 = newKey()
-      const score1 = 1
-      const member1 = randomUUID()
-      const score2 = 2
-      const member2 = randomUUID()
-
-      await new ZAddCommand(key1, { score: score1, member: member1 }).exec(client)
-      await new ZAddCommand(key2, { score: score2, member: member2 }).exec(client)
-
-      const res = await new ZUnionStoreCommand(destination, 2, [key1, key2], {
-        aggregate: "max",
-      }).exec(client)
-      expect(res).toBe(2)
-    })
-  })
-})

package/pkg/commands/zunionstore.ts

@@ -1,55 +0,0 @@
-import { Command } from "../command"
-
-export type ZUnionStoreCommandOptions = {
-  aggregate?: "sum" | "min" | "max"
-} & (
-  | {
-      weight: number
-      weights?: never
-    }
-  | {
-      weight?: never
-      weights: number[]
-    }
-  | {
-      weight?: never
-      weights?: never
-    }
-)
-
-/**
- * @see https://redis.io/commands/zunionstore
- */
-export class ZUnionStoreCommand extends Command<number, number> {
-  constructor(destination: string, numKeys: 1, key: string, opts?: ZUnionStoreCommandOptions)
-  constructor(
-    destination: string,
-    numKeys: number,
-    keys: string[],
-    opts?: ZUnionStoreCommandOptions,
-  )
-  constructor(
-    destination: string,
-    numKeys: number,
-    keyOrKeys: string | string[],
-    opts?: ZUnionStoreCommandOptions,
-  ) {
-    const command: unknown[] = ["zunionstore", destination, numKeys]
-    if (Array.isArray(keyOrKeys)) {
-      command.push(...keyOrKeys)
-    } else {
-      command.push(keyOrKeys)
-    }
-    if (opts) {
-      if ("weights" in opts && opts.weights) {
-        command.push("weights", ...opts.weights)
-      } else if ("weight" in opts && typeof opts.weight === "number") {
-        command.push("weights", opts.weight)
-      }
-      if ("aggregate" in opts) {
-        command.push("aggregate", opts.aggregate)
-      }
-    }
-    super(command)
-  }
-}

package/pkg/commands/zz.ts

@@ -1 +0,0 @@
-export const x = 1

package/pkg/error.ts

@@ -1,9 +0,0 @@
-/**
- * Result of a bad request to upstash
- */
-export class UpstashError extends Error {
-  constructor(message: string) {
-    super(message)
-    this.name = "UpstashError"
-  }
-}

package/pkg/fastly.ts

@@ -1,54 +0,0 @@
-import * as core from "./redis"
-import { HttpClient } from "./http"
-
-/**
- * Connection credentials for upstash redis.
- * Get them from https://console.upstash.com/redis/<uuid>
- */
-export type RedisConfigFastly = {
-  /**
-   * UPSTASH_REDIS_REST_URL
-   */
-  url: string
-
-  /**
-   * UPSTASH_REDIS_REST_TOKEN
-   */
-  token: string
-
-  /**
-   * A Request can be forwarded to any backend defined on your service. Backends
-   * can be created via the Fastly CLI, API, or web interface, and are
-   * referenced by name.
-   */
-  backend: string
-}
-
-/**
- * Serverless redis client for upstash.
- */
-export class Redis extends core.Redis {
-  /**
-   * Create a new redis client
-   *
-   * @example
-   * ```typescript
-   *    const redis = new Redis({
-   *        url: "<UPSTASH_REDIS_REST_URL>",
-   *        token: "<UPSTASH_REDIS_REST_TOKEN>",
-   *        backend: "upstash-db",
-   *    });
-   * ```
-   */
-  constructor(config: RedisConfigFastly) {
-    const client = new HttpClient({
-      baseUrl: config.url,
-      headers: {
-        authorization: `Bearer ${config.token}`,
-      },
-      options: { backend: config.backend },
-    })
-
-    super(client)
-  }
-}

package/pkg/http.test.ts

@@ -1,34 +0,0 @@
-import { HttpClient } from "./http"
-
-import { describe, expect, it } from "@jest/globals"
-import { newHttpClient } from "./test-utils"
-it("remove trailing slash from urls", () => {
-  const client = new HttpClient({
-    baseUrl: "https://example.com/",
-  })
-
-  expect(client.baseUrl).toBe("https://example.com")
-})
-
-describe("when the request is invalid", () => {
-  it("throws", async () => {
-    const client = newHttpClient()
-    expect(() =>
-      client.request({
-        body: ["get", "1", "2"],
-      }),
-    ).rejects.toThrowErrorMatchingInlineSnapshot()
-  })
-})
-
-describe("whithout authorization", () => {
-  it("throws", async () => {
-    const client = newHttpClient()
-    client.headers = {}
-    expect(() =>
-      client.request({
-        body: ["get", "1", "2"],
-      }),
-    ).rejects.toThrowErrorMatchingInlineSnapshot()
-  })
-})

package/pkg/http.ts

@@ -1,62 +0,0 @@
-import "isomorphic-fetch"
-import { UpstashError } from "./error"
-
-export type HttpRequest = {
-  path?: string[]
-  /**
-   * Request body will be serialized to json
-   */
-  body?: unknown
-}
-
-export type UpstashResponse<TResult> = {
-  result?: TResult
-  error?: string
-}
-
-export type HttpClientConfig = {
-  headers?: Record<string, string>
-  baseUrl: string
-  options?: {
-    backend?: string
-  }
-}
-
-export class HttpClient {
-  public baseUrl: string
-  public headers: Record<string, string>
-  public readonly options?: { backend?: string }
-
-  public constructor(config: HttpClientConfig) {
-    this.baseUrl = config.baseUrl.replace(/\/$/, "")
-
-    this.headers = {
-      "Content-Type": "application/json",
-      ...config.headers,
-    }
-
-    this.options = config.options
-  }
-
-  public async request<TResponse>(req: HttpRequest): Promise<TResponse> {
-    if (!req.path) {
-      req.path = []
-    }
-
-    // fetch is defined by isomorphic fetch
-    // eslint-disable-next-line no-undef
-    const res = await fetch([this.baseUrl, ...req.path].join("/"), {
-      method: "POST",
-      headers: this.headers,
-      body: JSON.stringify(req.body),
-      // @ts-expect-error
-      backend: this.options?.backend,
-    })
-    const body = await res.json()
-    if (!res.ok) {
-      throw new UpstashError(body.error)
-    }
-
-    return body as TResponse
-  }
-}

package/pkg/index.ts

@@ -1,2 +0,0 @@
-export * from "./nodejs"
-export * from "./error"