@upstash/redis 1.4.0-next.1 → 1.5.0

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/pkg/commands/script_exists.js

@@ -5,16 +5,7 @@ import { Command } from "./command.js";
 export class ScriptExistsCommand extends Command {
     constructor(hashes, opts) {
         super(["script", "exists", ...hashes], {
-            deserialize: (result) => {
-                /**
-                 * This isn't very pretty but it does the job.
-                 * The user facing api is clean and will return a single `string` if they provided
-                 * a single script hash, and an array of strings of the same length when given an
-                 * array of hashes.
-                 */
-                const parsed = result;
-                return parsed.length === 1 ? parsed[0] : parsed;
-            },
+            deserialize: (result) => result,
             ...opts,
         });
     }

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

@@ -3,6 +3,7 @@
   "main": "./script/platforms/nodejs.js",
   "types": "./types/platforms/nodejs.d.ts",
   "name": "@upstash/redis",
+  "version": "v1.5.0",
   "description": "An HTTP/REST based Redis client built on top of Upstash REST API.",
   "repository": {
     "type": "git",
@@ -15,21 +16,27 @@
     "edge",
     "upstash"
   ],
-  "author": "Andreas Thomas <andreas.thomas@chronark.com>",
+  "author": "Andreas Thomas <dev@chronark.com>",
   "license": "MIT",
   "bugs": {
     "url": "https://github.com/upstash/upstash-redis/issues"
   },
   "homepage": "https://github.com/upstash/upstash-redis#readme",
-  "browser": {
-    "isomorphic-fetch": false,
-    "http": false,
-    "https": false
-  },
   "devDependencies": {
     "@size-limit/preset-small-lib": "latest",
     "size-limit": "latest"
   },
+  "dependencies": {
+    "isomorphic-fetch": "^3.0.0"
+  },
+  "typesVersions": {
+    "*": {
+      "nodejs": "./types/platforms/nodejs.d.ts",
+      "cloudflare": "./types/platforms/cloudflare.d.ts",
+      "fastly": "./types/platforms/fastly.d.ts",
+      "with-fetch": "./types/platforms/node_with_fetch.d.ts"
+    }
+  },
   "size-limit": [
     {
       "path": "esm/platforms/nodejs.js",
@@ -43,6 +50,10 @@
       "path": "esm/platforms/cloudflare.js",
       "limit": "5 KB"
     },
+    {
+      "path": "esm/platforms/node_with_fetch.js",
+      "limit": "15 KB"
+    },
     {
       "path": "script/platforms/nodejs.js",
       "limit": "10 KB"
@@ -54,6 +65,10 @@
     {
       "path": "script/platforms/cloudflare.js",
       "limit": "10 KB"
+    },
+    {
+      "path": "script/platforms/node_with_fetch.js",
+      "limit": "15 KB"
     }
   ],
   "exports": {
@@ -76,7 +91,11 @@
       "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"
+  }
 }

package/script/pkg/commands/script_exists.js

@@ -8,16 +8,7 @@ const command_js_1 = require("./command.js");
 class ScriptExistsCommand extends command_js_1.Command {
     constructor(hashes, opts) {
         super(["script", "exists", ...hashes], {
-            deserialize: (result) => {
-                /**
-                 * This isn't very pretty but it does the job.
-                 * The user facing api is clean and will return a single `string` if they provided
-                 * a single script hash, and an array of strings of the same length when given an
-                 * array of hashes.
-                 */
-                const parsed = result;
-                return parsed.length === 1 ? parsed[0] : parsed;
-            },
+            deserialize: (result) => result,
             ...opts,
         });
     }

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/pkg/commands/hmset.d.ts

@@ -2,8 +2,8 @@ import { Command, CommandOptions } from "./command.js";
 /**
  * @see https://redis.io/commands/hmset
  */
-export declare class HMSetCommand<TData> extends Command<number, number> {
+export declare class HMSetCommand<TData> extends Command<"OK", "OK"> {
     constructor([key, kv]: [key: string, kv: {
         [field: string]: TData;
-    }], opts?: CommandOptions<number, number>);
+    }], opts?: CommandOptions<"OK", "OK">);
 }

package/types/pkg/commands/script_exists.d.ts

@@ -1,9 +1,7 @@
 import { Command, CommandOptions } from "./command.js";
-declare type TupleOfLength<T, L extends number, R extends T[] = []> = R["length"] extends L ? R : TupleOfLength<T, L, [...R, T]>;
 /**
  * @see https://redis.io/commands/script-exists
  */
-export declare class ScriptExistsCommand<T extends [string, ...string[]]> extends Command<T extends [string] ? string : TupleOfLength<string, T["length"]>, TupleOfLength<string, T["length"]>> {
-    constructor(hashes: T, opts?: CommandOptions<T extends [string] ? string : TupleOfLength<string, T["length"]>, TupleOfLength<string, T["length"]>>);
+export declare class ScriptExistsCommand<T extends string[]> extends Command<string[], number[]> {
+    constructor(hashes: T, opts?: CommandOptions<string[], number[]>);
 }
-export {};

package/types/pkg/commands/sinterstore.d.ts

@@ -2,6 +2,6 @@ import { Command, CommandOptions } from "./command.js";
 /**
  * @see https://redis.io/commands/sinterstore
  */
-export declare class SInterStoreCommand<TData = string> extends Command<unknown[], TData[]> {
-    constructor(cmd: [destination: string, key: string, ...keys: string[]], opts?: CommandOptions<unknown[], TData[]>);
+export declare class SInterStoreCommand extends Command<number, number> {
+    constructor(cmd: [destination: string, key: string, ...keys: string[]], opts?: CommandOptions<number, number>);
 }

package/types/pkg/commands/spop.d.ts

@@ -2,6 +2,6 @@ import { Command, CommandOptions } from "./command.js";
 /**
  * @see https://redis.io/commands/spop
  */
-export declare class SPopCommand<TData = number> extends Command<string | null, TData | null> {
+export declare class SPopCommand<TData> extends Command<string | null, TData | null> {
     constructor([key, count]: [key: string, count?: number], opts?: CommandOptions<string | null, TData | null>);
 }

package/types/pkg/pipeline.d.ts

@@ -1,4 +1,4 @@
-import { DelCommand, ExistsCommand, FlushAllCommand, PingCommand, ScoreMember, SetCommandOptions, TouchCommand, UnlinkCommand, ZAddCommandOptions, ZAddCommandOptionsWithIncr, ZRangeCommandOptions } from "./commands/mod.js";
+import { DelCommand, ExistsCommand, FlushAllCommand, PingCommand, ScoreMember, ScriptExistsCommand, SetCommandOptions, TouchCommand, UnlinkCommand, ZAddCommandOptions, ZAddCommandOptionsWithIncr, ZRangeCommandOptions } from "./commands/mod.js";
 import { CommandOptions } from "./commands/command.js";
 import { Requester } from "./http.js";
 import { CommandArgs } from "./types.js";
@@ -349,7 +349,7 @@ export declare class Pipeline {
     /**
      * @see https://redis.io/commands/script-exists
      */
-    scriptExists: (args_0: string, ...args_1: string[]) => this;
+    scriptExists: (...args: CommandArgs<typeof ScriptExistsCommand>) => this;
     /**
      * @see https://redis.io/commands/script-flush
      */

package/types/pkg/redis.d.ts

@@ -1,4 +1,4 @@
-import { CommandOptions, DelCommand, ExistsCommand, FlushAllCommand, PingCommand, ScoreMember, SetCommandOptions, TouchCommand, UnlinkCommand, ZAddCommandOptions, ZAddCommandOptionsWithIncr, ZRangeCommandOptions } from "./commands/mod.js";
+import { CommandOptions, DelCommand, ExistsCommand, FlushAllCommand, PingCommand, ScoreMember, ScriptExistsCommand, SetCommandOptions, TouchCommand, UnlinkCommand, ZAddCommandOptions, ZAddCommandOptionsWithIncr, ZRangeCommandOptions } from "./commands/mod.js";
 import { Requester } from "./http.js";
 import { Pipeline } from "./pipeline.js";
 import type { CommandArgs } from "./types.js";
@@ -160,7 +160,7 @@ export declare class Redis {
      */
     hmset: <TData>(key: string, kv: {
         [field: string]: TData;
-    }) => Promise<number>;
+    }) => Promise<"OK">;
     /**
      * @see https://redis.io/commands/hscan
      */
@@ -322,7 +322,7 @@ export declare class Redis {
     /**
      * @see https://redis.io/commands/script-exists
      */
-    scriptExists: (args_0: string, ...args_1: string[]) => Promise<[]>;
+    scriptExists: (...args: CommandArgs<typeof ScriptExistsCommand>) => Promise<number[]>;
     /**
      * @see https://redis.io/commands/script-flush
      */
@@ -366,7 +366,7 @@ export declare class Redis {
     /**
      * @see https://redis.io/commands/sinterstore
      */
-    sinterstore: (destination: string, key: string, ...keys: string[]) => Promise<string[]>;
+    sinterstore: (destination: string, key: string, ...keys: string[]) => Promise<number>;
     /**
      * @see https://redis.io/commands/sismember
      */

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;
+}