@upstash/redis 1.3.2-alpha.0 → 1.3.2-alpha.1

package/README.md

@@ -34,10 +34,18 @@ further explanation we wrote a
 
 ### Install
 
+#### npm
+
 ```bash
 npm install @upstash/redis
 ```
 
+#### Deno
+
+```ts
+import { Redis } from "https://deno.land/x/upstash_redis/mod.ts";
+```
+
 ### Create database
 
 Create a new redis database on [upstash](https://console.upstash.com/)
@@ -127,6 +135,23 @@ const redis = new Redis({
 - [Code example](https://github.com/upstash/upstash-redis/tree/main/examples/fastly)
 - [Documentation](https://blog.upstash.com/fastly-compute-edge-with-redi)
 
+#### Deno
+
+Examples: [Deno Deploy](https://deno.com/deploy),
+[Netlify Edge](https://www.netlify.com/products/edge/)
+
+```ts
+import { Redis } from "https://deno.land/x/upstash_redis/mod.ts"
+
+const redis = new Redis({
+  url: <UPSTASH_REDIS_REST_URL>,
+  token: <UPSTASH_REDIS_REST_TOKEN>,
+})
+
+// or
+const redis = Redis.fromEnv();
+```
+
 ### Working with types
 
 Most commands allow you to provide a type to make working with typescript

package/esm/platforms/nodejs.js

@@ -46,8 +46,6 @@ export class Redis extends core.Redis {
     }
 }
 function defaultRequester(config) {
-    // @ts-ignore
-    console.log("process", process.release, { config });
     return {
         request: async function (req) {
             if (!req.path) {

package/esm/platforms/vercel.js

@@ -0,0 +1,68 @@
+// deno-lint-ignore-file
+import * as core from "../pkg/redis.js";
+import { UpstashError } from "../pkg/error.js";
+/**
+ * Serverless redis client for upstash.
+ */
+export class Redis extends core.Redis {
+    constructor(configOrRequester) {
+        if ("request" in configOrRequester) {
+            super(configOrRequester);
+            return;
+        }
+        const client = defaultRequester({
+            baseUrl: configOrRequester.url,
+            headers: { authorization: `Bearer ${configOrRequester.token}` },
+            agent: configOrRequester.agent,
+        });
+        super(client);
+    }
+    /**
+     * 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,7 +3,7 @@
   "main": "./script/platforms/nodejs.js",
   "types": "./types/platforms/nodejs.d.ts",
   "name": "@upstash/redis",
-  "version": "v1.3.2-alpha.0",
+  "version": "v1.3.2-alpha.1",
   "description": "An HTTP/REST based Redis client built on top of Upstash REST API.",
   "repository": {
     "type": "git",
@@ -71,6 +71,11 @@
       "require": "./script/platforms/nodejs.js",
       "types": "./types/platforms/nodejs.d.ts"
     },
+    "./vercel": {
+      "import": "./esm/platforms/vercel.js",
+      "require": "./script/platforms/vercel.js",
+      "types": "./types/platforms/vercel.d.ts"
+    },
     "./cloudflare": {
       "import": "./esm/platforms/cloudflare.js",
       "require": "./script/platforms/cloudflare.js",

package/script/platforms/nodejs.js

@@ -73,8 +73,6 @@ class Redis extends core.Redis {
 }
 exports.Redis = Redis;
 function defaultRequester(config) {
-    // @ts-ignore
-    console.log("process", process.release, { config });
     return {
         request: async function (req) {
             if (!req.path) {

package/script/platforms/vercel.js

@@ -0,0 +1,95 @@
+"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");
+/**
+ * Serverless redis client for upstash.
+ */
+class Redis extends core.Redis {
+    constructor(configOrRequester) {
+        if ("request" in configOrRequester) {
+            super(configOrRequester);
+            return;
+        }
+        const client = defaultRequester({
+            baseUrl: configOrRequester.url,
+            headers: { authorization: `Bearer ${configOrRequester.token}` },
+            agent: configOrRequester.agent,
+        });
+        super(client);
+    }
+    /**
+     * 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/vercel.d.ts

@@ -0,0 +1,80 @@
+import * as core from "../pkg/redis.js";
+import { Requester, UpstashRequest, UpstashResponse } from "../pkg/http.js";
+import https from "https";
+import http from "http";
+export type { Requester, UpstashRequest, UpstashResponse };
+/**
+ * Connection credentials for upstash redis.
+ * Get them from https://console.upstash.com/redis/<uuid>
+ */
+export declare type RedisConfigVercel = {
+    /**
+     * UPSTASH_REDIS_REST_URL
+     */
+    url: string;
+    /**
+     * 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: RedisConfigVercel = {
+     *  agent: new https.Agent({ keepAlive: true })
+     * }
+     * ```
+     */
+    agent?: http.Agent | https.Agent;
+};
+/**
+ * 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: RedisConfigVercel);
+    /**
+     * Create a new redis client by providing a custom `Requester` implementation
+     *
+     * @example
+     * ```ts
+     *
+     * import { UpstashRequest, Requester, UpstashResponse, Redis } from "@upstash/redis/vercel"
+     *
+     *  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<RedisConfigVercel, "url" | "token">): Redis;
+}