@upstash/redis 0.0.0-ci.bafaa360-20230119 → 0.0.0-ci.bb93ac2803c2e927dc8bf1a1b3c5aa2a14034eb6-20240930061920

package/platforms/nodejs.ts

@@ -0,0 +1,196 @@
+/* eslint-disable @typescript-eslint/ban-ts-comment */
+// deno-lint-ignore-file
+
+import type { Requester, RequesterConfig } from "../pkg/http";
+import { HttpClient } from "../pkg/http";
+
+import * as core from "../pkg/redis";
+import { VERSION } from "../version";
+
+/**
+ * Workaround for nodejs 14, where atob is not included in the standardlib
+ */
+if (typeof atob === "undefined") {
+  global.atob = (b64: string) => Buffer.from(b64, "base64").toString("utf8");
+}
+export * as errors from "../pkg/error";
+export type * from "../pkg/commands/types";
+
+/**
+ * Connection credentials for upstash redis.
+ * Get them from https://console.upstash.com/redis/<uuid>
+ */
+export type RedisConfigNodejs = {
+  /**
+   * UPSTASH_REDIS_REST_URL
+   */
+  url: string | undefined;
+  /**
+   * UPSTASH_REDIS_REST_TOKEN
+   */
+  token: string | undefined;
+
+  /**
+   * An agent allows you to reuse connections to reduce latency for multiple sequential requests.
+   *
+   * This is a node specific implementation and is not supported in various runtimes like Vercel
+   * edge functions.
+   *
+   * @example
+   * ```ts
+   * import https from "https"
+   *
+   * const options: RedisConfigNodejs = {
+   *  agent: new https.Agent({ keepAlive: true })
+   * }
+   * ```
+   */
+  /**
+   * The signal will allow aborting requests on the fly.
+   * For more check: https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal
+   */
+  signal?: AbortSignal;
+  latencyLogging?: boolean;
+  agent?: unknown;
+  keepAlive?: boolean;
+
+  /**
+   * When this flag is enabled, any subsequent commands issued by this client are guaranteed to observe the effects of all earlier writes submitted by the same client.
+   */
+  readYourWrites?: boolean;
+} & core.RedisOptions &
+  RequesterConfig;
+
+/**
+ * Serverless redis client for upstash.
+ */
+export class Redis extends core.Redis {
+  /**
+   * Create a new redis client by providing the url and token
+   *
+   * @example
+   * ```typescript
+   * const redis = new Redis({
+   *  url: "<UPSTASH_REDIS_REST_URL>",
+   *  token: "<UPSTASH_REDIS_REST_TOKEN>",
+   * });
+   * ```
+   */
+  constructor(config: RedisConfigNodejs);
+
+  /**
+   * Create a new redis client by providing a custom `Requester` implementation
+   *
+   * @example
+   * ```ts
+   *
+   * import { UpstashRequest, Requester, UpstashResponse, Redis } from "@upstash/redis"
+   *
+   *  const requester: Requester = {
+   *    request: <TResult>(req: UpstashRequest): Promise<UpstashResponse<TResult>> => {
+   *      // ...
+   *    }
+   *  }
+   *
+   * const redis = new Redis(requester)
+   * ```
+   */
+  constructor(configOrRequester: RedisConfigNodejs | Requester) {
+    if ("request" in configOrRequester) {
+      super(configOrRequester);
+      return;
+    }
+
+    if (!configOrRequester.url) {
+      throw new Error(
+        `[Upstash Redis] The 'url' property is missing or undefined in your Redis config.`
+      );
+    }
+
+    if (!configOrRequester.token) {
+      throw new Error(
+        `[Upstash Redis] The 'token' property is missing or undefined in your Redis config.`
+      );
+    }
+
+    if (
+      configOrRequester.url.startsWith(" ") ||
+      configOrRequester.url.endsWith(" ") ||
+      /\r|\n/.test(configOrRequester.url)
+    ) {
+      console.warn("The redis url contains whitespace or newline, which can cause errors!");
+    }
+    if (
+      configOrRequester.token.startsWith(" ") ||
+      configOrRequester.token.endsWith(" ") ||
+      /\r|\n/.test(configOrRequester.token)
+    ) {
+      console.warn("The redis token contains whitespace or newline, which can cause errors!");
+    }
+
+    const client = new HttpClient({
+      baseUrl: configOrRequester.url,
+      retry: configOrRequester.retry,
+      headers: { authorization: `Bearer ${configOrRequester.token}` },
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+      agent: configOrRequester.agent,
+      responseEncoding: configOrRequester.responseEncoding,
+      cache: configOrRequester.cache ?? "no-store",
+      signal: configOrRequester.signal,
+      keepAlive: configOrRequester.keepAlive,
+      readYourWrites: configOrRequester.readYourWrites,
+    });
+
+    super(client, {
+      automaticDeserialization: configOrRequester.automaticDeserialization,
+      enableTelemetry: !process.env.UPSTASH_DISABLE_TELEMETRY,
+      latencyLogging: configOrRequester.latencyLogging,
+      enableAutoPipelining: configOrRequester.enableAutoPipelining,
+    });
+
+    this.addTelemetry({
+      runtime:
+        // @ts-expect-error to silence compiler
+        typeof EdgeRuntime === "string" ? "edge-light" : `node@${process.version}`,
+      platform: process.env.VERCEL ? "vercel" : process.env.AWS_REGION ? "aws" : "unknown",
+      sdk: `@upstash/redis@${VERSION}`,
+    });
+
+    if (this.enableAutoPipelining) {
+      return this.autoPipeline();
+    }
+  }
+
+  /**
+   * Create a new Upstash Redis instance from environment variables.
+   *
+   * Use this to automatically load connection secrets from your environment
+   * variables. For instance when using the Vercel integration.
+   *
+   * This tries to load `UPSTASH_REDIS_REST_URL` and `UPSTASH_REDIS_REST_TOKEN` from
+   * your environment using `process.env`.
+   */
+  static fromEnv(config?: Omit<RedisConfigNodejs, "url" | "token">): Redis {
+    // @ts-ignore process will be defined in node
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+    if (process.env === undefined) {
+      throw new TypeError(
+        'Unable to get environment variables, `process.env` is undefined. If you are deploying to cloudflare, please import from "@upstash/redis/cloudflare" instead'
+      );
+    }
+    // @ts-ignore process will be defined in node
+    const url = process.env.UPSTASH_REDIS_REST_URL;
+    if (!url) {
+      throw new Error("Unable to find environment variable: `UPSTASH_REDIS_REST_URL`");
+    }
+    // @ts-ignore process will be defined in node
+    const token = process.env.UPSTASH_REDIS_REST_TOKEN;
+    if (!token) {
+      throw new Error("Unable to find environment variable: `UPSTASH_REDIS_REST_TOKEN`");
+    }
+    return new Redis({ ...config, url, token });
+  }
+}
+
+export { type Pipeline } from "../pkg/pipeline";
+export { type UpstashRequest, type UpstashResponse, type Requester } from "../pkg/http";

package/prettier.config.mjs

@@ -0,0 +1,13 @@
+/**
+ * @type {import('prettier').Config}
+ */
+const config = {
+  endOfLine: "lf",
+  singleQuote: false,
+  tabWidth: 2,
+  trailingComma: "es5",
+  printWidth: 100,
+  arrowParens: "always",
+};
+
+export default config;

package/tsconfig.json

@@ -0,0 +1,21 @@
+{
+  "compilerOptions": {
+    "lib": ["ESNext"],
+    "module": "esnext",
+    "target": "esnext",
+    "moduleResolution": "bundler",
+    "moduleDetection": "force",
+    "allowImportingTsExtensions": true,
+    "noEmit": true,
+    "strict": true,
+    "downlevelIteration": true,
+    "skipLibCheck": true,
+    "jsx": "react-jsx",
+    "allowSyntheticDefaultImports": true,
+    "forceConsistentCasingInFileNames": true,
+    "allowJs": true,
+    "types": [
+      "bun-types" // add Bun global
+    ]
+  }
+}

package/tsup.config.ts

@@ -0,0 +1,8 @@
+import { defineConfig } from "tsup";
+
+export default defineConfig({
+  entry: ["platforms/nodejs.ts", "platforms/cloudflare.ts", "platforms/fastly.ts"],
+  format: ["cjs", "esm"],
+  clean: true,
+  dts: true,
+});

package/version.ts

@@ -0,0 +1 @@
+export const VERSION = "v1.30.2";

package/.releaserc

@@ -1,14 +0,0 @@
-{
-  "branches": [
-    {
-      "name": "release"
-    },
-    {
-      "name": "main",
-      "channel": "next",
-      "prerelease": "next"
-    }
-  ],
-  "dryRun": false,
-  "ci": true
-}

package/esm/deps/deno.land/x/base64@v0.2.1/base.js

@@ -1,100 +0,0 @@
-function getLengths(b64) {
-    const len = b64.length;
-    // if (len % 4 > 0) {
-    //   throw new TypeError("Invalid string. Length must be a multiple of 4");
-    // }
-    // Trim off extra bytes after placeholder bytes are found
-    // See: https://github.com/beatgammit/base64-js/issues/42
-    let validLen = b64.indexOf("=");
-    if (validLen === -1) {
-        validLen = len;
-    }
-    const placeHoldersLen = validLen === len ? 0 : 4 - (validLen % 4);
-    return [validLen, placeHoldersLen];
-}
-export function init(lookup, revLookup, urlsafe = false) {
-    function _byteLength(validLen, placeHoldersLen) {
-        return Math.floor(((validLen + placeHoldersLen) * 3) / 4 - placeHoldersLen);
-    }
-    function tripletToBase64(num) {
-        return (lookup[(num >> 18) & 0x3f] +
-            lookup[(num >> 12) & 0x3f] +
-            lookup[(num >> 6) & 0x3f] +
-            lookup[num & 0x3f]);
-    }
-    function encodeChunk(buf, start, end) {
-        const out = new Array((end - start) / 3);
-        for (let i = start, curTriplet = 0; i < end; i += 3) {
-            out[curTriplet++] = tripletToBase64((buf[i] << 16) + (buf[i + 1] << 8) + buf[i + 2]);
-        }
-        return out.join("");
-    }
-    return {
-        // base64 is 4/3 + up to two characters of the original data
-        byteLength(b64) {
-            return _byteLength.apply(null, getLengths(b64));
-        },
-        toUint8Array(b64) {
-            const [validLen, placeHoldersLen] = getLengths(b64);
-            const buf = new Uint8Array(_byteLength(validLen, placeHoldersLen));
-            // If there are placeholders, only get up to the last complete 4 chars
-            const len = placeHoldersLen ? validLen - 4 : validLen;
-            let tmp;
-            let curByte = 0;
-            let i;
-            for (i = 0; i < len; i += 4) {
-                tmp = (revLookup[b64.charCodeAt(i)] << 18) |
-                    (revLookup[b64.charCodeAt(i + 1)] << 12) |
-                    (revLookup[b64.charCodeAt(i + 2)] << 6) |
-                    revLookup[b64.charCodeAt(i + 3)];
-                buf[curByte++] = (tmp >> 16) & 0xff;
-                buf[curByte++] = (tmp >> 8) & 0xff;
-                buf[curByte++] = tmp & 0xff;
-            }
-            if (placeHoldersLen === 2) {
-                tmp = (revLookup[b64.charCodeAt(i)] << 2) |
-                    (revLookup[b64.charCodeAt(i + 1)] >> 4);
-                buf[curByte++] = tmp & 0xff;
-            }
-            else if (placeHoldersLen === 1) {
-                tmp = (revLookup[b64.charCodeAt(i)] << 10) |
-                    (revLookup[b64.charCodeAt(i + 1)] << 4) |
-                    (revLookup[b64.charCodeAt(i + 2)] >> 2);
-                buf[curByte++] = (tmp >> 8) & 0xff;
-                buf[curByte++] = tmp & 0xff;
-            }
-            return buf;
-        },
-        fromUint8Array(buf) {
-            const maxChunkLength = 16383; // Must be multiple of 3
-            const len = buf.length;
-            const extraBytes = len % 3; // If we have 1 byte left, pad 2 bytes
-            const len2 = len - extraBytes;
-            const parts = new Array(Math.ceil(len2 / maxChunkLength) + (extraBytes ? 1 : 0));
-            let curChunk = 0;
-            let chunkEnd;
-            // Go through the array every three bytes, we'll deal with trailing stuff later
-            for (let i = 0; i < len2; i += maxChunkLength) {
-                chunkEnd = i + maxChunkLength;
-                parts[curChunk++] = encodeChunk(buf, i, chunkEnd > len2 ? len2 : chunkEnd);
-            }
-            let tmp;
-            // Pad the end with zeros, but make sure to not forget the extra bytes
-            if (extraBytes === 1) {
-                tmp = buf[len2];
-                parts[curChunk] = lookup[tmp >> 2] + lookup[(tmp << 4) & 0x3f];
-                if (!urlsafe)
-                    parts[curChunk] += "==";
-            }
-            else if (extraBytes === 2) {
-                tmp = (buf[len2] << 8) | (buf[len2 + 1] & 0xff);
-                parts[curChunk] = lookup[tmp >> 10] +
-                    lookup[(tmp >> 4) & 0x3f] +
-                    lookup[(tmp << 2) & 0x3f];
-                if (!urlsafe)
-                    parts[curChunk] += "=";
-            }
-            return parts.join("");
-        },
-    };
-}

package/esm/deps/deno.land/x/base64@v0.2.1/base64url.js

@@ -1,9 +0,0 @@
-import { init } from "./base.js";
-const lookup = [];
-const revLookup = [];
-const code = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
-for (let i = 0, l = code.length; i < l; ++i) {
-    lookup[i] = code[i];
-    revLookup[code.charCodeAt(i)] = i;
-}
-export const { byteLength, toUint8Array, fromUint8Array } = init(lookup, revLookup, true);

package/esm/deps/deno.land/x/sha1@v1.0.3/deps.js

@@ -1 +0,0 @@
-export { encode, decode } from "../../../denopkg.com/chiefbiiko/std-encoding@v1.0.0/mod.js";

package/esm/deps/deno.land/x/sha1@v1.0.3/mod.js

@@ -1,191 +0,0 @@
-import { encode, decode } from "./deps.js";
-function rotl(x, n) {
-    return (x << n) | (x >>> (32 - n));
-}
-/** Byte length of a SHA1 digest. */
-export const BYTES = 20;
-/**  A class representation of the SHA1 algorithm. */
-export class SHA1 {
-    /** Creates a SHA1 instance. */
-    constructor() {
-        Object.defineProperty(this, "hashSize", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: BYTES
-        });
-        Object.defineProperty(this, "_buf", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: new Uint8Array(64)
-        });
-        Object.defineProperty(this, "_bufIdx", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "_count", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "_K", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: new Uint32Array([0x5a827999, 0x6ed9eba1, 0x8f1bbcdc, 0xca62c1d6])
-        });
-        Object.defineProperty(this, "_H", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "_finalized", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        this.init();
-    }
-    /** Reduces the four input numbers to a single one. */
-    static F(t, b, c, d) {
-        if (t <= 19) {
-            return (b & c) | (~b & d);
-        }
-        else if (t <= 39) {
-            return b ^ c ^ d;
-        }
-        else if (t <= 59) {
-            return (b & c) | (b & d) | (c & d);
-        }
-        else {
-            return b ^ c ^ d;
-        }
-    }
-    /** Initializes a hash instance. */
-    init() {
-        // prettier-ignore
-        this._H = new Uint32Array([
-            0x67452301, 0xEFCDAB89, 0x98BADCFE, 0x10325476, 0xC3D2E1F0
-        ]);
-        this._bufIdx = 0;
-        this._count = new Uint32Array(2);
-        this._buf.fill(0);
-        this._finalized = false;
-        return this;
-    }
-    /** Updates a hash with additional message data. */
-    update(msg, inputEncoding) {
-        if (msg === null) {
-            throw new TypeError("msg must be a string or Uint8Array.");
-        }
-        else if (typeof msg === "string") {
-            msg = encode(msg, inputEncoding);
-        }
-        // process the msg as many times as possible, the rest is stored in the buffer
-        // message is processed in 512 bit (64 byte chunks)
-        for (let i = 0; i < msg.length; i++) {
-            this._buf[this._bufIdx++] = msg[i];
-            if (this._bufIdx === 64) {
-                this.transform();
-                this._bufIdx = 0;
-            }
-        }
-        // counter update (number of message bits)
-        const c = this._count;
-        if ((c[0] += msg.length << 3) < msg.length << 3) {
-            c[1]++;
-        }
-        c[1] += msg.length >>> 29;
-        return this;
-    }
-    /** Finalizes a hash with additional message data. */
-    digest(outputEncoding) {
-        if (this._finalized) {
-            throw new Error("digest has already been called.");
-        }
-        this._finalized = true;
-        // append '1'
-        const b = this._buf;
-        let idx = this._bufIdx;
-        b[idx++] = 0x80;
-        // zeropad up to byte pos 56
-        while (idx !== 56) {
-            if (idx === 64) {
-                this.transform();
-                idx = 0;
-            }
-            b[idx++] = 0;
-        }
-        // append length in bits
-        const c = this._count;
-        b[56] = (c[1] >>> 24) & 0xff;
-        b[57] = (c[1] >>> 16) & 0xff;
-        b[58] = (c[1] >>> 8) & 0xff;
-        b[59] = (c[1] >>> 0) & 0xff;
-        b[60] = (c[0] >>> 24) & 0xff;
-        b[61] = (c[0] >>> 16) & 0xff;
-        b[62] = (c[0] >>> 8) & 0xff;
-        b[63] = (c[0] >>> 0) & 0xff;
-        this.transform();
-        // return the hash as byte array (20 bytes)
-        const hash = new Uint8Array(BYTES);
-        for (let i = 0; i < 5; i++) {
-            hash[(i << 2) + 0] = (this._H[i] >>> 24) & 0xff;
-            hash[(i << 2) + 1] = (this._H[i] >>> 16) & 0xff;
-            hash[(i << 2) + 2] = (this._H[i] >>> 8) & 0xff;
-            hash[(i << 2) + 3] = (this._H[i] >>> 0) & 0xff;
-        }
-        // clear internal states and prepare for new hash
-        this.init();
-        return outputEncoding ? decode(hash, outputEncoding) : hash;
-    }
-    /** Performs one transformation cycle. */
-    transform() {
-        const h = this._H;
-        let a = h[0];
-        let b = h[1];
-        let c = h[2];
-        let d = h[3];
-        let e = h[4];
-        // convert byte buffer to words
-        const w = new Uint32Array(80);
-        for (let i = 0; i < 16; i++) {
-            w[i] =
-                this._buf[(i << 2) + 3] |
-                    (this._buf[(i << 2) + 2] << 8) |
-                    (this._buf[(i << 2) + 1] << 16) |
-                    (this._buf[i << 2] << 24);
-        }
-        for (let t = 0; t < 80; t++) {
-            if (t >= 16) {
-                w[t] = rotl(w[t - 3] ^ w[t - 8] ^ w[t - 14] ^ w[t - 16], 1);
-            }
-            const tmp = (rotl(a, 5) +
-                SHA1.F(t, b, c, d) +
-                e +
-                w[t] +
-                this._K[Math.floor(t / 20)]) |
-                0;
-            e = d;
-            d = c;
-            c = rotl(b, 30);
-            b = a;
-            a = tmp;
-        }
-        h[0] = (h[0] + a) | 0;
-        h[1] = (h[1] + b) | 0;
-        h[2] = (h[2] + c) | 0;
-        h[3] = (h[3] + d) | 0;
-        h[4] = (h[4] + e) | 0;
-    }
-}
-/** Generates a SHA1 hash of the input data. */
-export function sha1(msg, inputEncoding, outputEncoding) {
-    return new SHA1().update(msg, inputEncoding).digest(outputEncoding);
-}

package/esm/deps/denopkg.com/chiefbiiko/std-encoding@v1.0.0/mod.js

@@ -1,50 +0,0 @@
-import { toUint8Array, fromUint8Array } from "../../../deno.land/x/base64@v0.2.1/base64url.js";
-const decoder = new TextDecoder();
-const encoder = new TextEncoder();
-/** Serializes a Uint8Array to a hexadecimal string. */
-function toHexString(buf) {
-    return buf.reduce((hex, byte) => `${hex}${byte < 16 ? "0" : ""}${byte.toString(16)}`, "");
-}
-/** Deserializes a Uint8Array from a hexadecimal string. */
-function fromHexString(hex) {
-    const len = hex.length;
-    if (len % 2 || !/^[0-9a-fA-F]+$/.test(hex)) {
-        throw new TypeError("Invalid hex string.");
-    }
-    hex = hex.toLowerCase();
-    const buf = new Uint8Array(Math.floor(len / 2));
-    const end = len / 2;
-    for (let i = 0; i < end; ++i) {
-        buf[i] = parseInt(hex.substr(i * 2, 2), 16);
-    }
-    return buf;
-}
-/** Decodes a Uint8Array to utf8-, base64-, or hex-encoded string. */
-export function decode(buf, encoding = "utf8") {
-    if (/^utf-?8$/i.test(encoding)) {
-        return decoder.decode(buf);
-    }
-    else if (/^base64$/i.test(encoding)) {
-        return fromUint8Array(buf);
-    }
-    else if (/^hex(?:adecimal)?$/i.test(encoding)) {
-        return toHexString(buf);
-    }
-    else {
-        throw new TypeError("Unsupported string encoding.");
-    }
-}
-export function encode(str, encoding = "utf8") {
-    if (/^utf-?8$/i.test(encoding)) {
-        return encoder.encode(str);
-    }
-    else if (/^base64$/i.test(encoding)) {
-        return toUint8Array(str);
-    }
-    else if (/^hex(?:adecimal)?$/i.test(encoding)) {
-        return fromHexString(str);
-    }
-    else {
-        throw new TypeError("Unsupported string encoding.");
-    }
-}

package/esm/package.json

@@ -1,3 +0,0 @@
-{
-  "type": "module"
-}

package/esm/pkg/commands/append.js

@@ -1,9 +0,0 @@
-import { Command } from "./command.js";
-/**
- * @see https://redis.io/commands/append
- */
-export class AppendCommand extends Command {
-    constructor(cmd, opts) {
-        super(["append", ...cmd], opts);
-    }
-}

package/esm/pkg/commands/bitcount.js

@@ -1,16 +0,0 @@
-import { Command } from "./command.js";
-/**
- * @see https://redis.io/commands/bitcount
- */
-export class BitCountCommand extends Command {
-    constructor([key, start, end], opts) {
-        const command = ["bitcount", key];
-        if (typeof start === "number") {
-            command.push(start);
-        }
-        if (typeof end === "number") {
-            command.push(end);
-        }
-        super(command, opts);
-    }
-}

package/esm/pkg/commands/bitop.js

@@ -1,9 +0,0 @@
-import { Command } from "./command.js";
-/**
- * @see https://redis.io/commands/bitop
- */
-export class BitOpCommand extends Command {
-    constructor(cmd, opts) {
-        super(["bitop", ...cmd], opts);
-    }
-}

package/esm/pkg/commands/bitpos.js

@@ -1,9 +0,0 @@
-import { Command } from "./command.js";
-/**
- * @see https://redis.io/commands/bitpos
- */
-export class BitPosCommand extends Command {
-    constructor(cmd, opts) {
-        super(["bitpos", ...cmd], opts);
-    }
-}