@upstash/redis 1.4.0-next.1 → 1.4.0-next.2

package/README.md

@@ -25,21 +25,15 @@ supported.
 
 ## Upgrading to v1.4.0 **(ReferenceError: fetch is not defined)**
 
-If you are running on nodejs v17 and earlier, you need to manually provide a
-`fetch` polyfill. The simplest way is using `isomorphic-fetch`
-
-```bash
-npm install isomorphic-fetch
-```
+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 "isomorphic-fetch";
-import { Redis } from "@upstash/redis";
+import { Redis } from "@upstash/redis/with-fetch";
 ```
 
-`fetch` is natively supported in node18 as well as all major platforms: Vercel,
-Netlify, Deno, Fastly etc. and you do not need to do anything.
-
 ## Upgrading from v0.2.0?
 
 Please read the
@@ -93,6 +87,15 @@ const redis = new Redis({
 const redis = Redis.fromEnv()
 ```
 
+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";
+```
+
 - [Code example](https://github.com/upstash/upstash-redis/blob/main/examples/nodejs)
 
 #### Cloudflare Workers

package/esm/platforms/node_with_fetch.js

@@ -0,0 +1,81 @@
+// deno-lint-ignore-file
+import * as core from "../pkg/redis.js";
+import { UpstashError } from "../pkg/error.js";
+import "isomorphic-fetch";
+/**
+ * Serverless redis client for upstash.
+ */
+export class Redis extends core.Redis {
+    constructor(configOrRequester) {
+        if ("request" in configOrRequester) {
+            super(configOrRequester);
+            return;
+        }
+        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 = defaultRequester({
+            baseUrl: configOrRequester.url,
+            headers: { authorization: `Bearer ${configOrRequester.token}` },
+            // agent: configOrRequester.agent,
+        });
+        super(client, {
+            automaticDeserialization: configOrRequester.automaticDeserialization,
+        });
+    }
+    /**
+     * 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) {
+        // @ts-ignore process will be defined in node
+        if (typeof process?.env === "undefined") {
+            throw new Error('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({ url, token, ...config });
+    }
+}
+function defaultRequester(config) {
+    return {
+        request: async function (req) {
+            if (!req.path) {
+                req.path = [];
+            }
+            const res = await fetch([config.baseUrl, ...req.path].join("/"), {
+                method: "POST",
+                headers: { "Content-Type": "application/json", ...config.headers },
+                body: JSON.stringify(req.body),
+                keepalive: true,
+                // @ts-ignore
+                agent: config.agent,
+            });
+            const body = (await res.json());
+            if (!res.ok) {
+                throw new UpstashError(body.error);
+            }
+            return body;
+        },
+    };
+}

package/package.json

@@ -20,6 +20,9 @@
   "bugs": {
     "url": "https://github.com/upstash/upstash-redis/issues"
   },
+  "dependencies": {
+    "isomorphic-fetch": "^3.0.0"
+  },
   "homepage": "https://github.com/upstash/upstash-redis#readme",
   "browser": {
     "isomorphic-fetch": false,
@@ -76,7 +79,12 @@
       "import": "./esm/platforms/fastly.js",
       "require": "./script/platforms/fastly.js",
       "types": "./types/platforms/fastly.d.ts"
+    },
+    "./with-fetch": {
+      "import": "./esm/platforms/node_with_fetch.js",
+      "require": "./script/platforms/node_with_fetch.js",
+      "types": "./types/platforms/node_with_fetch.d.ts"
     }
   },
-  "version": "1.4.0-next.1"
+  "version": "1.4.0-next.2"
 }

package/script/platforms/node_with_fetch.js

@@ -0,0 +1,108 @@
+"use strict";
+// deno-lint-ignore-file
+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.Redis = void 0;
+const core = __importStar(require("../pkg/redis.js"));
+const error_js_1 = require("../pkg/error.js");
+require("isomorphic-fetch");
+/**
+ * Serverless redis client for upstash.
+ */
+class Redis extends core.Redis {
+    constructor(configOrRequester) {
+        if ("request" in configOrRequester) {
+            super(configOrRequester);
+            return;
+        }
+        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 = defaultRequester({
+            baseUrl: configOrRequester.url,
+            headers: { authorization: `Bearer ${configOrRequester.token}` },
+            // agent: configOrRequester.agent,
+        });
+        super(client, {
+            automaticDeserialization: configOrRequester.automaticDeserialization,
+        });
+    }
+    /**
+     * 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) {
+        // @ts-ignore process will be defined in node
+        if (typeof process?.env === "undefined") {
+            throw new Error('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({ url, token, ...config });
+    }
+}
+exports.Redis = Redis;
+function defaultRequester(config) {
+    return {
+        request: async function (req) {
+            if (!req.path) {
+                req.path = [];
+            }
+            const res = await fetch([config.baseUrl, ...req.path].join("/"), {
+                method: "POST",
+                headers: { "Content-Type": "application/json", ...config.headers },
+                body: JSON.stringify(req.body),
+                keepalive: true,
+                // @ts-ignore
+                agent: config.agent,
+            });
+            const body = (await res.json());
+            if (!res.ok) {
+                throw new error_js_1.UpstashError(body.error);
+            }
+            return body;
+        },
+    };
+}

package/types/platforms/node_with_fetch.d.ts

@@ -0,0 +1,63 @@
+import * as core from "../pkg/redis.js";
+import { Requester, UpstashRequest, UpstashResponse } from "../pkg/http.js";
+import "isomorphic-fetch";
+export type { Requester, UpstashRequest, UpstashResponse };
+/**
+ * Connection credentials for upstash redis.
+ * Get them from https://console.upstash.com/redis/<uuid>
+ */
+export declare type RedisConfigNodejs = {
+    /**
+     * UPSTASH_REDIS_REST_URL
+     */
+    url: string;
+    /**
+     * UPSTASH_REDIS_REST_TOKEN
+     */
+    token: string;
+} & core.RedisOptions;
+/**
+ * Serverless redis client for upstash.
+ */
+export declare 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(requesters: Requester);
+    /**
+     * 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;
+}