@upstash/redis 1.16.0 → 1.16.1-rc.1

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

@@ -25,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,
@@ -77,23 +83,36 @@ export class HttpClient {
         if (!res.ok) {
             throw new UpstashError(body.error);
         }
-        return Array.isArray(body) ? body.map(decode) : decode(body);
+        if (this.options?.responseEncoding === "base64") {
+            console.log("decoding base64");
+            return Array.isArray(body) ? body.map(decode) : decode(body);
+        }
+        return body;
     }
 }
 function base64decode(b64) {
     let dec = "";
     try {
-        dec = atob(b64).split("").map((c) => "%" + ("00" + c.charCodeAt(0).toString(16)).slice(-2)).join("");
+        /**
+         * Using only atob() is not enough because it doesn't work with unicode characters
+         */
+        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;
+        return b64;
     }
     try {
         return decodeURIComponent(dec);
     }
     catch (e) {
-        console.warn(`Unable to decode URI [${dec}]: ${e.message}`);
+        console.warn(`Unable to decode URI[${dec}]: ${e.message}`);
         return dec;
     }
 }
@@ -102,10 +121,11 @@ function decode(raw) {
     switch (typeof raw.result) {
         case "undefined":
             return raw;
-        case "number":
+        case "number": {
             result = raw.result;
             break;
-        case "object":
+        }
+        case "object": {
             if (Array.isArray(raw.result)) {
                 result = raw.result.map((v) => typeof v === "string"
                     ? base64decode(v)
@@ -119,9 +139,11 @@ function decode(raw) {
                 result = null;
             }
             break;
-        case "string":
+        }
+        case "string": {
             result = raw.result === "OK" ? "OK" : base64decode(raw.result);
             break;
+        }
         default:
             break;
     }

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.0",
+  "version": "v1.16.1-rc.1",
   "description": "An HTTP/REST based Redis client built on top of Upstash REST API.",
   "repository": {
     "type": "git",

package/script/pkg/http.js

@@ -28,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,
@@ -80,24 +86,37 @@ class HttpClient {
         if (!res.ok) {
             throw new error_js_1.UpstashError(body.error);
         }
-        return Array.isArray(body) ? body.map(decode) : decode(body);
+        if (this.options?.responseEncoding === "base64") {
+            console.log("decoding base64");
+            return Array.isArray(body) ? body.map(decode) : decode(body);
+        }
+        return body;
     }
 }
 exports.HttpClient = HttpClient;
 function base64decode(b64) {
     let dec = "";
     try {
-        dec = atob(b64).split("").map((c) => "%" + ("00" + c.charCodeAt(0).toString(16)).slice(-2)).join("");
+        /**
+         * Using only atob() is not enough because it doesn't work with unicode characters
+         */
+        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;
+        return b64;
     }
     try {
         return decodeURIComponent(dec);
     }
     catch (e) {
-        console.warn(`Unable to decode URI [${dec}]: ${e.message}`);
+        console.warn(`Unable to decode URI[${dec}]: ${e.message}`);
         return dec;
     }
 }
@@ -106,10 +125,11 @@ function decode(raw) {
     switch (typeof raw.result) {
         case "undefined":
             return raw;
-        case "number":
+        case "number": {
             result = raw.result;
             break;
-        case "object":
+        }
+        case "object": {
             if (Array.isArray(raw.result)) {
                 result = raw.result.map((v) => typeof v === "string"
                     ? base64decode(v)
@@ -123,9 +143,11 @@ function decode(raw) {
                 result = null;
             }
             break;
-        case "string":
+        }
+        case "string": {
             result = raw.result === "OK" ? "OK" : base64decode(raw.result);
             break;
+        }
         default:
             break;
     }

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?: {
         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.
  */