@upstash/redis 1.16.1-rc.0 → 1.16.1-rc.2

package/README.md

@@ -81,24 +81,6 @@ data  = await redis.spop('animals', 1)
 console.log(data)
 ```
 
-### Upgrading to v1.4.0 **(ReferenceError: fetch is not defined)**
-
-If you are running on nodejs v17 and earlier, `fetch` will not be natively
-supported. Platforms like Vercel, Netlify, Deno, Fastly etc. provide a polyfill
-for you. But if you are running on bare node, you need to either specify a
-polyfill yourself or change the import path to:
-
-```typescript
-import { Redis } from "@upstash/redis/with-fetch";
-```
-
-### Upgrading from v0.2.0?
-
-Please read the
-[migration guide](https://docs.upstash.com/redis/sdks/javascriptsdk/migration).
-For further explanation we wrote a
-[blog post](https://blog.upstash.com/upstash-redis-sdk-v1).
-
 ## Docs
 
 See [the documentation](https://docs.upstash.com/features/javascriptsdk) for
@@ -118,6 +100,3 @@ the url and token
 ```sh
 UPSTASH_REDIS_REST_URL=".." UPSTASH_REDIS_REST_TOKEN=".." deno test -A
 ```
-
-```
-```

package/esm/pkg/http.js

@@ -1,6 +1,4 @@
 import { UpstashError } from "./error.js";
-import * as utf8 from "../deps/deno.land/std@0.82.0/encoding/utf8.js";
-import * as base64 from "../deps/deno.land/std@0.82.0/encoding/base64.js";
 export class HttpClient {
     constructor(config) {
         Object.defineProperty(this, "baseUrl", {
@@ -27,13 +25,19 @@ export class HttpClient {
             writable: true,
             value: void 0
         });
+        this.options = {
+            backend: config.options?.backend,
+            agent: config.agent,
+            responseEncoding: config.responseEncoding ?? "base64", // default to base64
+        };
         this.baseUrl = config.baseUrl.replace(/\/$/, "");
         this.headers = {
             "Content-Type": "application/json",
-            "Upstash-Encoding": "base64",
             ...config.headers,
         };
-        this.options = { backend: config.options?.backend, agent: config.agent };
+        if (this.options.responseEncoding === "base64") {
+            this.headers["Upstash-Encoding"] = "base64";
+        }
         if (typeof config?.retry === "boolean" && config?.retry === false) {
             this.retry = {
                 attempts: 1,
@@ -79,34 +83,35 @@ export class HttpClient {
         if (!res.ok) {
             throw new UpstashError(body.error);
         }
-        console.time("decode");
-        const resp = Array.isArray(body) ? body.map(decode) : decode(body);
-        console.timeEnd("decode");
-        return resp;
+        if (this.options?.responseEncoding === "base64") {
+            return Array.isArray(body) ? body.map(decode) : decode(body);
+        }
+        return body;
     }
 }
 function base64decode(b64) {
     let dec = "";
     try {
-        console.time("atob");
         /**
-         * THIS WORKS
+         * Using only atob() is not enough because it doesn't work with unicode characters
          */
-        const s = utf8.decode(base64.decode(b64));
-        console.timeEnd("atob");
-        console.time("escape");
-        console.timeEnd("escape");
-        dec = decodeURIComponent(s);
+        const binString = atob(b64);
+        const size = binString.length;
+        const bytes = new Uint8Array(size);
+        for (let i = 0; i < size; i++) {
+            bytes[i] = binString.charCodeAt(i);
+        }
+        dec = new TextDecoder().decode(bytes);
     }
     catch (e) {
-        console.warn(`Unable to decode base64 [${dec}]: ${e.message}`);
-        return dec;
+        console.warn(`Unable to decode base64 [${b64}]: ${e.message}`);
+        return b64;
     }
     try {
         return decodeURIComponent(dec);
     }
     catch (e) {
-        console.warn(`Unable to decode URI[${dec}]: ${e.message}`);
+        console.warn(`Unable to decode URIComponent [${dec}]: ${e.message}`);
         return dec;
     }
 }

package/esm/platforms/cloudflare.js

@@ -30,6 +30,7 @@ export class Redis extends core.Redis {
             retry: config.retry,
             baseUrl: config.url,
             headers: { authorization: `Bearer ${config.token}` },
+            responseEncoding: config.responseEncoding,
         });
         super(client, {
             automaticDeserialization: config.automaticDeserialization,

package/esm/platforms/fastly.js

@@ -32,6 +32,7 @@ export class Redis extends core.Redis {
             retry: config.retry,
             headers: { authorization: `Bearer ${config.token}` },
             options: { backend: config.backend },
+            responseEncoding: config.responseEncoding,
         });
         super(client, {
             automaticDeserialization: config.automaticDeserialization,

package/esm/platforms/node_with_fetch.js

@@ -25,7 +25,8 @@ export class Redis extends core.Redis {
             baseUrl: configOrRequester.url,
             retry: configOrRequester.retry,
             headers: { authorization: `Bearer ${configOrRequester.token}` },
-            // agent: configOrRequester.agent,
+            //  agent: configOrRequester.agent,
+            responseEncoding: configOrRequester.responseEncoding,
         });
         super(client, {
             automaticDeserialization: configOrRequester.automaticDeserialization,

package/esm/platforms/nodejs.js

@@ -25,6 +25,7 @@ export class Redis extends core.Redis {
             retry: configOrRequester.retry,
             headers: { authorization: `Bearer ${configOrRequester.token}` },
             agent: configOrRequester.agent,
+            responseEncoding: configOrRequester.responseEncoding,
         });
         super(client, {
             automaticDeserialization: configOrRequester.automaticDeserialization,

package/package.json

@@ -3,7 +3,7 @@
   "main": "./script/platforms/nodejs.js",
   "types": "./types/platforms/nodejs.d.ts",
   "name": "@upstash/redis",
-  "version": "v1.16.1-rc.0",
+  "version": "v1.16.1-rc.2",
   "description": "An HTTP/REST based Redis client built on top of Upstash REST API.",
   "repository": {
     "type": "git",

package/script/pkg/http.js

@@ -1,32 +1,7 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.HttpClient = void 0;
 const error_js_1 = require("./error.js");
-const utf8 = __importStar(require("../deps/deno.land/std@0.82.0/encoding/utf8.js"));
-const base64 = __importStar(require("../deps/deno.land/std@0.82.0/encoding/base64.js"));
 class HttpClient {
     constructor(config) {
         Object.defineProperty(this, "baseUrl", {
@@ -53,13 +28,19 @@ class HttpClient {
             writable: true,
             value: void 0
         });
+        this.options = {
+            backend: config.options?.backend,
+            agent: config.agent,
+            responseEncoding: config.responseEncoding ?? "base64", // default to base64
+        };
         this.baseUrl = config.baseUrl.replace(/\/$/, "");
         this.headers = {
             "Content-Type": "application/json",
-            "Upstash-Encoding": "base64",
             ...config.headers,
         };
-        this.options = { backend: config.options?.backend, agent: config.agent };
+        if (this.options.responseEncoding === "base64") {
+            this.headers["Upstash-Encoding"] = "base64";
+        }
         if (typeof config?.retry === "boolean" && config?.retry === false) {
             this.retry = {
                 attempts: 1,
@@ -105,35 +86,36 @@ class HttpClient {
         if (!res.ok) {
             throw new error_js_1.UpstashError(body.error);
         }
-        console.time("decode");
-        const resp = Array.isArray(body) ? body.map(decode) : decode(body);
-        console.timeEnd("decode");
-        return resp;
+        if (this.options?.responseEncoding === "base64") {
+            return Array.isArray(body) ? body.map(decode) : decode(body);
+        }
+        return body;
     }
 }
 exports.HttpClient = HttpClient;
 function base64decode(b64) {
     let dec = "";
     try {
-        console.time("atob");
         /**
-         * THIS WORKS
+         * Using only atob() is not enough because it doesn't work with unicode characters
          */
-        const s = utf8.decode(base64.decode(b64));
-        console.timeEnd("atob");
-        console.time("escape");
-        console.timeEnd("escape");
-        dec = decodeURIComponent(s);
+        const binString = atob(b64);
+        const size = binString.length;
+        const bytes = new Uint8Array(size);
+        for (let i = 0; i < size; i++) {
+            bytes[i] = binString.charCodeAt(i);
+        }
+        dec = new TextDecoder().decode(bytes);
     }
     catch (e) {
-        console.warn(`Unable to decode base64 [${dec}]: ${e.message}`);
-        return dec;
+        console.warn(`Unable to decode base64 [${b64}]: ${e.message}`);
+        return b64;
     }
     try {
         return decodeURIComponent(dec);
     }
     catch (e) {
-        console.warn(`Unable to decode URI[${dec}]: ${e.message}`);
+        console.warn(`Unable to decode URIComponent [${dec}]: ${e.message}`);
         return dec;
     }
 }

package/script/platforms/cloudflare.js

@@ -56,6 +56,7 @@ class Redis extends core.Redis {
             retry: config.retry,
             baseUrl: config.url,
             headers: { authorization: `Bearer ${config.token}` },
+            responseEncoding: config.responseEncoding,
         });
         super(client, {
             automaticDeserialization: config.automaticDeserialization,

package/script/platforms/fastly.js

@@ -58,6 +58,7 @@ class Redis extends core.Redis {
             retry: config.retry,
             headers: { authorization: `Bearer ${config.token}` },
             options: { backend: config.backend },
+            responseEncoding: config.responseEncoding,
         });
         super(client, {
             automaticDeserialization: config.automaticDeserialization,

package/script/platforms/node_with_fetch.js

@@ -51,7 +51,8 @@ class Redis extends core.Redis {
             baseUrl: configOrRequester.url,
             retry: configOrRequester.retry,
             headers: { authorization: `Bearer ${configOrRequester.token}` },
-            // agent: configOrRequester.agent,
+            //  agent: configOrRequester.agent,
+            responseEncoding: configOrRequester.responseEncoding,
         });
         super(client, {
             automaticDeserialization: configOrRequester.automaticDeserialization,

package/script/platforms/nodejs.js

@@ -51,6 +51,7 @@ class Redis extends core.Redis {
             retry: configOrRequester.retry,
             headers: { authorization: `Bearer ${configOrRequester.token}` },
             agent: configOrRequester.agent,
+            responseEncoding: configOrRequester.responseEncoding,
         });
         super(client, {
             automaticDeserialization: configOrRequester.automaticDeserialization,

package/types/pkg/http.d.ts

@@ -29,22 +29,52 @@ export declare type RetryConfig = false | {
      */
     backoff?: (retryCount: number) => number;
 };
-declare type Options = {
+export declare type Options = {
     backend?: string;
 };
+export declare type RequesterConfig = {
+    /**
+     * Configure the retry behaviour in case of network errors
+     */
+    retry?: RetryConfig;
+    /**
+     * Due to the nature of dynamic and custom data, it is possible to write data to redis that is not
+     * valid json and will therefore cause errors when deserializing. This used to happen very
+     * frequently with non-utf8 data, such as emojis.
+     *
+     * By default we will therefore encode the data as base64 on the server, before sending it to the
+     * client. The client will then decode the base64 data and parse it as utf8.
+     *
+     * For very large entries, this can add a few milliseconds, so if you are sure that your data is
+     * valid utf8, you can disable this behaviour by setting this option to false.
+     *
+     * Here's what the response body looks like:
+     *
+     * ```json
+     * {
+     *  result?: "base64-encoded",
+     *  error?: string
+     * }
+     * ```
+     *
+     * @default "base64"
+     */
+    responseEncoding?: false | "base64";
+};
 export declare type HttpClientConfig = {
     headers?: Record<string, string>;
     baseUrl: string;
     options?: Options;
     retry?: RetryConfig;
     agent?: any;
-};
+} & RequesterConfig;
 export declare class HttpClient implements Requester {
     baseUrl: string;
     headers: Record<string, string>;
-    readonly options?: {
+    readonly options: {
         backend?: string;
         agent: any;
+        responseEncoding?: false | "base64";
     };
     readonly retry: {
         attempts: number;
@@ -53,4 +83,3 @@ export declare class HttpClient implements Requester {
     constructor(config: HttpClientConfig);
     request<TResult>(req: UpstashRequest): Promise<UpstashResponse<TResult>>;
 }
-export {};

package/types/platforms/cloudflare.d.ts

@@ -1,5 +1,6 @@
 import * as core from "../pkg/redis.js";
-import type { Requester, RetryConfig, UpstashRequest, UpstashResponse } from "../pkg/http.js";
+import type { Requester, UpstashRequest, UpstashResponse } from "../pkg/http.js";
+import { RequesterConfig } from "../pkg/http.js";
 export type { Requester, UpstashRequest, UpstashResponse };
 /**
  * Connection credentials for upstash redis.
@@ -14,11 +15,7 @@ export declare type RedisConfigCloudflare = {
      * UPSTASH_REDIS_REST_TOKEN
      */
     token: string;
-    /**
-     * Configure the retry behaviour in case of network errors
-     */
-    retry?: RetryConfig;
-} & core.RedisOptions;
+} & core.RedisOptions & RequesterConfig;
 /**
  * Serverless redis client for upstash.
  */

package/types/platforms/fastly.d.ts

@@ -1,5 +1,5 @@
 import * as core from "../pkg/redis.js";
-import type { Requester, RetryConfig, UpstashRequest, UpstashResponse } from "../pkg/http.js";
+import type { Requester, RequesterConfig, UpstashRequest, UpstashResponse } from "../pkg/http.js";
 export type { Requester, UpstashRequest, UpstashResponse };
 /**
  * Connection credentials for upstash redis.
@@ -20,11 +20,7 @@ export declare type RedisConfigFastly = {
      * referenced by name.
      */
     backend: string;
-    /**
-     * Configure the retry behaviour in case of network errors
-     */
-    retry?: RetryConfig;
-} & core.RedisOptions;
+} & core.RedisOptions & RequesterConfig;
 /**
  * Serverless redis client for upstash.
  */

package/types/platforms/node_with_fetch.d.ts

@@ -1,5 +1,5 @@
 import * as core from "../pkg/redis.js";
-import { Requester, RetryConfig, UpstashRequest, UpstashResponse } from "../pkg/http.js";
+import { Requester, RequesterConfig, UpstashRequest, UpstashResponse } from "../pkg/http.js";
 import "isomorphic-fetch";
 export type { Requester, UpstashRequest, UpstashResponse };
 /**
@@ -15,26 +15,7 @@ export declare type RedisConfigNodejs = {
      * UPSTASH_REDIS_REST_TOKEN
      */
     token: string;
-    /**
-     * 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 })
-     * }
-     * ```
-     */
-    /**
-     * Configure the retry behaviour in case of network errors
-     */
-    retry?: RetryConfig;
-} & core.RedisOptions;
+} & core.RedisOptions & RequesterConfig;
 /**
  * Serverless redis client for upstash.
  */

package/types/platforms/nodejs.d.ts

@@ -1,5 +1,5 @@
 import * as core from "../pkg/redis.js";
-import { Requester, RetryConfig, UpstashRequest, UpstashResponse } from "../pkg/http.js";
+import { Requester, RequesterConfig, UpstashRequest, UpstashResponse } from "../pkg/http.js";
 export type { Requester, UpstashRequest, UpstashResponse };
 /**
  * Connection credentials for upstash redis.
@@ -30,11 +30,7 @@ export declare type RedisConfigNodejs = {
      * ```
      */
     agent?: any;
-    /**
-     * Configure the retry behaviour in case of network errors
-     */
-    retry?: RetryConfig;
-} & core.RedisOptions;
+} & core.RedisOptions & RequesterConfig;
 /**
  * Serverless redis client for upstash.
  */

package/esm/deps/deno.land/std@0.82.0/encoding/base64.js

@@ -1,54 +0,0 @@
-// Copyright 2018-2020 the Deno authors. All rights reserved. MIT license.
-// deno-fmt-ignore
-const base64abc = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L",
-    "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z", "a",
-    "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p",
-    "q", "r", "s", "t", "u", "v", "w", "x", "y", "z", "0", "1", "2", "3", "4",
-    "5", "6", "7", "8", "9", "+", "/"];
-/**
- * CREDIT: https://gist.github.com/enepomnyaschih/72c423f727d395eeaa09697058238727
- * Encodes a given Uint8Array, ArrayBuffer or string into RFC4648 base64 representation
- * @param data
- */
-export function encode(data) {
-    const uint8 = typeof data === "string"
-        ? new TextEncoder().encode(data)
-        : data instanceof Uint8Array
-            ? data
-            : new Uint8Array(data);
-    let result = "", i;
-    const l = uint8.length;
-    for (i = 2; i < l; i += 3) {
-        result += base64abc[uint8[i - 2] >> 2];
-        result += base64abc[((uint8[i - 2] & 0x03) << 4) | (uint8[i - 1] >> 4)];
-        result += base64abc[((uint8[i - 1] & 0x0f) << 2) | (uint8[i] >> 6)];
-        result += base64abc[uint8[i] & 0x3f];
-    }
-    if (i === l + 1) {
-        // 1 octet yet to write
-        result += base64abc[uint8[i - 2] >> 2];
-        result += base64abc[(uint8[i - 2] & 0x03) << 4];
-        result += "==";
-    }
-    if (i === l) {
-        // 2 octets yet to write
-        result += base64abc[uint8[i - 2] >> 2];
-        result += base64abc[((uint8[i - 2] & 0x03) << 4) | (uint8[i - 1] >> 4)];
-        result += base64abc[(uint8[i - 1] & 0x0f) << 2];
-        result += "=";
-    }
-    return result;
-}
-/**
- * Decodes a given RFC4648 base64 encoded string
- * @param b64
- */
-export function decode(b64) {
-    const binString = atob(b64);
-    const size = binString.length;
-    const bytes = new Uint8Array(size);
-    for (let i = 0; i < size; i++) {
-        bytes[i] = binString.charCodeAt(i);
-    }
-    return bytes;
-}

package/esm/deps/deno.land/std@0.82.0/encoding/utf8.js

@@ -1,13 +0,0 @@
-// Copyright 2018-2020 the Deno authors. All rights reserved. MIT license.
-/** A default TextEncoder instance */
-export const encoder = new TextEncoder();
-/** Shorthand for new TextEncoder().encode() */
-export function encode(input) {
-    return encoder.encode(input);
-}
-/** A default TextDecoder instance */
-export const decoder = new TextDecoder();
-/** Shorthand for new TextDecoder().decode() */
-export function decode(input) {
-    return decoder.decode(input);
-}

package/script/deps/deno.land/std@0.82.0/encoding/base64.js

@@ -1,59 +0,0 @@
-"use strict";
-// Copyright 2018-2020 the Deno authors. All rights reserved. MIT license.
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.decode = exports.encode = void 0;
-// deno-fmt-ignore
-const base64abc = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L",
-    "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z", "a",
-    "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p",
-    "q", "r", "s", "t", "u", "v", "w", "x", "y", "z", "0", "1", "2", "3", "4",
-    "5", "6", "7", "8", "9", "+", "/"];
-/**
- * CREDIT: https://gist.github.com/enepomnyaschih/72c423f727d395eeaa09697058238727
- * Encodes a given Uint8Array, ArrayBuffer or string into RFC4648 base64 representation
- * @param data
- */
-function encode(data) {
-    const uint8 = typeof data === "string"
-        ? new TextEncoder().encode(data)
-        : data instanceof Uint8Array
-            ? data
-            : new Uint8Array(data);
-    let result = "", i;
-    const l = uint8.length;
-    for (i = 2; i < l; i += 3) {
-        result += base64abc[uint8[i - 2] >> 2];
-        result += base64abc[((uint8[i - 2] & 0x03) << 4) | (uint8[i - 1] >> 4)];
-        result += base64abc[((uint8[i - 1] & 0x0f) << 2) | (uint8[i] >> 6)];
-        result += base64abc[uint8[i] & 0x3f];
-    }
-    if (i === l + 1) {
-        // 1 octet yet to write
-        result += base64abc[uint8[i - 2] >> 2];
-        result += base64abc[(uint8[i - 2] & 0x03) << 4];
-        result += "==";
-    }
-    if (i === l) {
-        // 2 octets yet to write
-        result += base64abc[uint8[i - 2] >> 2];
-        result += base64abc[((uint8[i - 2] & 0x03) << 4) | (uint8[i - 1] >> 4)];
-        result += base64abc[(uint8[i - 1] & 0x0f) << 2];
-        result += "=";
-    }
-    return result;
-}
-exports.encode = encode;
-/**
- * Decodes a given RFC4648 base64 encoded string
- * @param b64
- */
-function decode(b64) {
-    const binString = atob(b64);
-    const size = binString.length;
-    const bytes = new Uint8Array(size);
-    for (let i = 0; i < size; i++) {
-        bytes[i] = binString.charCodeAt(i);
-    }
-    return bytes;
-}
-exports.decode = decode;

package/script/deps/deno.land/std@0.82.0/encoding/utf8.js

@@ -1,18 +0,0 @@
-"use strict";
-// Copyright 2018-2020 the Deno authors. All rights reserved. MIT license.
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.decode = exports.decoder = exports.encode = exports.encoder = void 0;
-/** A default TextEncoder instance */
-exports.encoder = new TextEncoder();
-/** Shorthand for new TextEncoder().encode() */
-function encode(input) {
-    return exports.encoder.encode(input);
-}
-exports.encode = encode;
-/** A default TextDecoder instance */
-exports.decoder = new TextDecoder();
-/** Shorthand for new TextDecoder().decode() */
-function decode(input) {
-    return exports.decoder.decode(input);
-}
-exports.decode = decode;

package/types/deps/deno.land/std@0.82.0/encoding/base64.d.ts

@@ -1,11 +0,0 @@
-/**
- * CREDIT: https://gist.github.com/enepomnyaschih/72c423f727d395eeaa09697058238727
- * Encodes a given Uint8Array, ArrayBuffer or string into RFC4648 base64 representation
- * @param data
- */
-export declare function encode(data: ArrayBuffer | string): string;
-/**
- * Decodes a given RFC4648 base64 encoded string
- * @param b64
- */
-export declare function decode(b64: string): Uint8Array;

package/types/deps/deno.land/std@0.82.0/encoding/utf8.d.ts

@@ -1,8 +0,0 @@
-/** A default TextEncoder instance */
-export declare const encoder: any;
-/** Shorthand for new TextEncoder().encode() */
-export declare function encode(input?: string): Uint8Array;
-/** A default TextDecoder instance */
-export declare const decoder: any;
-/** Shorthand for new TextDecoder().decode() */
-export declare function decode(input?: Uint8Array): string;