@upstash/redis 0.0.0-ci.b4d4a1cc → 0.0.0-ci.b8efaf97-20230119

package/script/platforms/fastly.js

@@ -25,7 +25,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
 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");
+const http_js_1 = require("../pkg/http.js");
 /**
  * Serverless redis client for upstash.
  */
@@ -53,10 +53,12 @@ class Redis extends core.Redis {
             /\r|\n/.test(config.token)) {
             console.warn("The redis token contains whitespace or newline, which can cause errors!");
         }
-        const client = defaultRequester({
+        const client = new http_js_1.HttpClient({
             baseUrl: config.url,
+            retry: config.retry,
             headers: { authorization: `Bearer ${config.token}` },
-            backend: config.backend,
+            options: { backend: config.backend },
+            responseEncoding: config.responseEncoding,
         });
         super(client, {
             automaticDeserialization: config.automaticDeserialization,
@@ -64,25 +66,3 @@ class Redis extends core.Redis {
     }
 }
 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-expect-error fastly requires `backend`
-                backend: config.backend,
-            });
-            const body = (await res.json());
-            if (!res.ok) {
-                throw new error_js_1.UpstashError(body.error);
-            }
-            return body;
-        },
-    };
-}

package/script/platforms/node_with_fetch.js

@@ -26,8 +26,22 @@ var __importStar = (this && this.__importStar) || function (mod) {
 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");
+const http_js_1 = require("../pkg/http.js");
+const version_js_1 = require("../version.js");
 require("isomorphic-fetch");
+// @ts-ignore Deno can't compile
+// import https from "https";
+// @ts-ignore Deno can't compile
+// import http from "http";
+// import "isomorphic-fetch";
+/**
+ * Workaround for nodejs 14, where atob is not included in the standardlib
+ */
+if (typeof atob === "undefined") {
+    global.atob = function (b64) {
+        return Buffer.from(b64, "base64").toString("utf-8");
+    };
+}
 /**
  * Serverless redis client for upstash.
  */
@@ -47,10 +61,23 @@ class Redis extends core.Redis {
             /\r|\n/.test(configOrRequester.token)) {
             console.warn("The redis token contains whitespace or newline, which can cause errors!");
         }
-        const client = defaultRequester({
+        const telemetry = {};
+        if (!process.env.UPSTASH_DISABLE_TELEMETRY) {
+            telemetry.runtime = `node@${process.version}`;
+            telemetry.platform = process.env.VERCEL
+                ? "vercel"
+                : process.env.AWS_REGION
+                    ? "aws"
+                    : "unknown";
+            telemetry.sdk = `@upstash/redis@${version_js_1.VERSION}`;
+        }
+        const client = new http_js_1.HttpClient({
             baseUrl: configOrRequester.url,
+            retry: configOrRequester.retry,
             headers: { authorization: `Bearer ${configOrRequester.token}` },
-            // agent: configOrRequester.agent,
+            //  agent: configOrRequester.agent,
+            responseEncoding: configOrRequester.responseEncoding,
+            telemetry,
         });
         super(client, {
             automaticDeserialization: configOrRequester.automaticDeserialization,
@@ -80,29 +107,7 @@ class Redis extends core.Redis {
         if (!token) {
             throw new Error("Unable to find environment variable: `UPSTASH_REDIS_REST_TOKEN`");
         }
-        return new Redis({ url, token, ...config });
+        return new Redis({ ...config, url, token });
     }
 }
 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/script/platforms/nodejs.js

@@ -26,7 +26,16 @@ var __importStar = (this && this.__importStar) || function (mod) {
 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");
+const http_js_1 = require("../pkg/http.js");
+const version_js_1 = require("../version.js");
+/**
+ * Workaround for nodejs 14, where atob is not included in the standardlib
+ */
+if (typeof atob === "undefined") {
+    global.atob = function (b64) {
+        return Buffer.from(b64, "base64").toString("utf-8");
+    };
+}
 /**
  * Serverless redis client for upstash.
  */
@@ -46,10 +55,23 @@ class Redis extends core.Redis {
             /\r|\n/.test(configOrRequester.token)) {
             console.warn("The redis token contains whitespace or newline, which can cause errors!");
         }
-        const client = defaultRequester({
+        const telemetry = {};
+        if (!process.env.UPSTASH_DISABLE_TELEMETRY) {
+            telemetry.runtime = `node@${process.version}`;
+            telemetry.platform = process.env.VERCEL
+                ? "vercel"
+                : process.env.AWS_REGION
+                    ? "aws"
+                    : "unknown";
+            telemetry.sdk = `@upstash/redis@${version_js_1.VERSION}`;
+        }
+        const client = new http_js_1.HttpClient({
             baseUrl: configOrRequester.url,
+            retry: configOrRequester.retry,
             headers: { authorization: `Bearer ${configOrRequester.token}` },
-            // agent: configOrRequester.agent,
+            agent: configOrRequester.agent,
+            responseEncoding: configOrRequester.responseEncoding,
+            telemetry,
         });
         super(client, {
             automaticDeserialization: configOrRequester.automaticDeserialization,
@@ -79,29 +101,7 @@ class Redis extends core.Redis {
         if (!token) {
             throw new Error("Unable to find environment variable: `UPSTASH_REDIS_REST_TOKEN`");
         }
-        return new Redis({ url, token, ...config });
+        return new Redis({ ...config, url, token });
     }
 }
 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/script/version.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VERSION = void 0;
+exports.VERSION = "v0.0.0-ci.b8efaf97-20230119";

package/types/deps/deno.land/x/base64@v0.2.1/base.d.ts

@@ -0,0 +1,5 @@
+export declare function init(lookup: string[], revLookup: number[], urlsafe?: boolean): {
+    byteLength(b64: string): number;
+    toUint8Array(b64: string): Uint8Array;
+    fromUint8Array(buf: Uint8Array): string;
+};

package/types/deps/deno.land/x/base64@v0.2.1/base64url.d.ts

@@ -0,0 +1 @@
+export declare const byteLength: (b64: string) => number, toUint8Array: (b64: string) => Uint8Array, fromUint8Array: (buf: Uint8Array) => string;

package/types/deps/deno.land/x/sha1@v1.0.3/deps.d.ts

@@ -0,0 +1 @@
+export { encode, decode } from "../../../denopkg.com/chiefbiiko/std-encoding@v1.0.0/mod.js";

package/types/deps/deno.land/x/sha1@v1.0.3/mod.d.ts

@@ -0,0 +1,26 @@
+/** Byte length of a SHA1 digest. */
+export declare const BYTES: number;
+/**  A class representation of the SHA1 algorithm. */
+export declare class SHA1 {
+    readonly hashSize: number;
+    private _buf;
+    private _bufIdx;
+    private _count;
+    private _K;
+    private _H;
+    private _finalized;
+    /** Creates a SHA1 instance. */
+    constructor();
+    /** Reduces the four input numbers to a single one. */
+    protected static F(t: number, b: number, c: number, d: number): number;
+    /** Initializes a hash instance. */
+    init(): SHA1;
+    /** Updates a hash with additional message data. */
+    update(msg: string | Uint8Array, inputEncoding?: string): SHA1;
+    /** Finalizes a hash with additional message data. */
+    digest(outputEncoding?: string): string | Uint8Array;
+    /** Performs one transformation cycle. */
+    private transform;
+}
+/** Generates a SHA1 hash of the input data. */
+export declare function sha1(msg: string | Uint8Array, inputEncoding?: string, outputEncoding?: string): string | Uint8Array;

package/types/deps/denopkg.com/chiefbiiko/std-encoding@v1.0.0/mod.d.ts

@@ -0,0 +1,3 @@
+/** Decodes a Uint8Array to utf8-, base64-, or hex-encoded string. */
+export declare function decode(buf: Uint8Array, encoding?: string): string;
+export declare function encode(str: string, encoding?: string): Uint8Array;

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

@@ -6,7 +6,6 @@ export declare class BitOpCommand extends Command<number, number> {
     constructor(cmd: [
         op: "and" | "or" | "xor",
         destinationKey: string,
-        sourceKey: string,
         ...sourceKeys: string[]
     ], opts?: CommandOptions<number, number>);
     constructor(cmd: [op: "not", destinationKey: string, sourceKey: string], opts?: CommandOptions<number, number>);

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

@@ -3,5 +3,5 @@ import { Command, CommandOptions } from "./command.js";
  * @see https://redis.io/commands/bitpos
  */
 export declare class BitPosCommand extends Command<number, number> {
-    constructor(cmd: [key: string, start: number, end: number], opts?: CommandOptions<number, number>);
+    constructor(cmd: [key: string, bit: 0 | 1, start?: number, end?: number], opts?: CommandOptions<number, number>);
 }

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

@@ -0,0 +1,7 @@
+import { Command, CommandOptions } from "./command.js";
+/**
+ * @see https://redis.io/commands/getdel
+ */
+export declare class GetDelCommand<TData = string> extends Command<unknown | null, TData | null> {
+    constructor(cmd: [key: string], opts?: CommandOptions<unknown | null, TData | null>);
+}

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

@@ -0,0 +1,9 @@
+import { Command, CommandOptions } from "./command.js";
+/**
+ * @see https://redis.io/commands/hrandfield
+ */
+export declare class HRandFieldCommand<TData extends string | string[] | Record<string, unknown>> extends Command<string | string[], TData> {
+    constructor(cmd: [key: string], opts?: CommandOptions<string, string>);
+    constructor(cmd: [key: string, count: number], opts?: CommandOptions<string[], string[]>);
+    constructor(cmd: [key: string, count: number, withValues: boolean], opts?: CommandOptions<string[], Partial<TData>>);
+}

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

@@ -0,0 +1,12 @@
+import { Command, CommandOptions } from "./command.js";
+/**
+ * @see https://redis.io/commands/lmove
+ */
+export declare class LMoveCommand<TData = string> extends Command<TData, TData> {
+    constructor(cmd: [
+        source: string,
+        destination: string,
+        whereFrom: "left" | "right",
+        whereTo: "left" | "right"
+    ], opts?: CommandOptions<TData, TData>);
+}

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

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

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

@@ -0,0 +1,15 @@
+import { Command, CommandOptions } from "./command.js";
+/**
+ * @see https://redis.io/commands/lpos
+ */
+export declare class LPosCommand<TData = number> extends Command<TData, TData> {
+    constructor(cmd: [
+        key: string,
+        element: unknown,
+        opts?: {
+            rank?: number;
+            count?: number;
+            maxLen?: number;
+        }
+    ], opts?: CommandOptions<TData, TData>);
+}

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

@@ -3,5 +3,5 @@ import { Command, CommandOptions } from "./command.js";
  * @see https://redis.io/commands/mget
  */
 export declare class MGetCommand<TData extends unknown[]> extends Command<(string | null)[], TData> {
-    constructor(cmd: [...keys: [string, ...string[]]], opts?: CommandOptions<(string | null)[], TData>);
+    constructor(cmd: [...keys: string[]], opts?: CommandOptions<(string | null)[], TData>);
 }

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

@@ -17,11 +17,13 @@ export * from "./flushall.js";
 export * from "./flushdb.js";
 export * from "./get.js";
 export * from "./getbit.js";
+export * from "./getdel.js";
 export * from "./getrange.js";
 export * from "./getset.js";
 export * from "./hdel.js";
 export * from "./hexists.js";
 export * from "./hget.js";
+export * from "./smismember.js";
 export * from "./hgetall.js";
 export * from "./hincrby.js";
 export * from "./hincrbyfloat.js";
@@ -29,6 +31,7 @@ export * from "./hkeys.js";
 export * from "./hlen.js";
 export * from "./hmget.js";
 export * from "./hmset.js";
+export * from "./hrandfield.js";
 export * from "./hscan.js";
 export * from "./hset.js";
 export * from "./hsetnx.js";
@@ -41,7 +44,9 @@ export * from "./keys.js";
 export * from "./lindex.js";
 export * from "./linsert.js";
 export * from "./llen.js";
+export * from "./lmove.js";
 export * from "./lpop.js";
+export * from "./lpos.js";
 export * from "./lpush.js";
 export * from "./lpushx.js";
 export * from "./lrange.js";

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

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

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

@@ -2,6 +2,7 @@ import { Command, CommandOptions } from "./command.js";
 export declare type ScanCommandOptions = {
     match?: string;
     count?: number;
+    type?: string;
 };
 /**
  * @see https://redis.io/commands/scan

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

@@ -1,6 +1,6 @@
 import { Command, CommandOptions } from "./command.js";
 /**
- * @see https://redis.io/commands/sdiffstpre
+ * @see https://redis.io/commands/sdiffstore
  */
 export declare class SDiffStoreCommand extends Command<number, number> {
     constructor(cmd: [destination: string, ...keys: string[]], opts?: CommandOptions<number, number>);

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

@@ -1,13 +1,42 @@
 import { Command, CommandOptions } from "./command.js";
-export declare type SetCommandOptions = ({
+export declare type SetCommandOptions = {
+    get: boolean;
+} | ({
     ex: number;
     px?: never;
+    exat?: never;
+    pxat?: never;
+    keepTtl?: never;
 } | {
     ex?: never;
     px: number;
+    exat?: never;
+    pxat?: never;
+    keepTtl?: never;
 } | {
     ex?: never;
     px?: never;
+    exat: number;
+    pxat?: never;
+    keepTtl?: never;
+} | {
+    ex?: never;
+    px?: never;
+    exat?: never;
+    pxat: number;
+    keepTtl?: never;
+} | {
+    ex?: never;
+    px?: never;
+    exat?: never;
+    pxat?: never;
+    keepTtl: true;
+} | {
+    ex?: never;
+    px?: never;
+    exat?: never;
+    pxat?: never;
+    keepTtl?: never;
 }) & ({
     nx: true;
     xx?: never;
@@ -21,6 +50,6 @@ export declare type SetCommandOptions = ({
 /**
  * @see https://redis.io/commands/set
  */
-export declare class SetCommand<TData, TResult = "OK"> extends Command<TResult, TData> {
+export declare class SetCommand<TData, TResult = TData | "OK" | null> extends Command<TResult, TData | "OK" | null> {
     constructor([key, value, opts]: [key: string, value: TData, opts?: SetCommandOptions], cmdOpts?: CommandOptions<TResult, TData>);
 }

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

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

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

@@ -0,0 +1,7 @@
+import { Command, CommandOptions } from "./command.js";
+/**
+ * @see https://redis.io/commands/smismember
+ */
+export declare class SMIsMemberCommand<TMembers extends unknown[]> extends Command<("0" | "1")[], (0 | 1)[]> {
+    constructor(cmd: [key: string, members: TMembers], opts?: CommandOptions<("0" | "1")[], (0 | 1)[]>);
+}

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> extends Command<string | null, TData | null> {
-    constructor([key, count]: [key: string, count?: number], opts?: CommandOptions<string | null, TData | null>);
+export declare class SPopCommand<TData> extends Command<string | string[] | null, TData | null> {
+    constructor([key, count]: [key: string, count?: number], opts?: CommandOptions<string | string[] | null, TData | null>);
 }

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

@@ -30,6 +30,6 @@ export declare class ZAddCommand<TData = string> extends Command<number | null,
     constructor(cmd: [
         key: string,
         opts: ZAddCommandOptions | ZAddCommandOptionsWithIncr,
-        ...scoreMemberPairs: [ScoreMember<TData>, ...ScoreMember<TData>[]]
+        ...scoreMemberPairs: ScoreMember<TData>[]
     ], opts?: CommandOptions<number | null, number | null>);
 }

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

@@ -0,0 +1,7 @@
+import { Command, CommandOptions } from "./command.js";
+/**
+ * @see https://redis.io/commands/zdiffstore
+ */
+export declare class ZDiffStoreCommand extends Command<number, number> {
+    constructor(cmd: [destination: string, numkeys: number, ...keys: string[]], opts?: CommandOptions<number, number>);
+}

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

@@ -0,0 +1,7 @@
+import { Command, CommandOptions } from "./command.js";
+/**
+ * @see https://redis.io/commands/zmscore
+ */
+export declare class ZMScoreCommand<TData> extends Command<string[] | null, number[] | null> {
+    constructor(cmd: [key: string, members: TData[]], opts?: CommandOptions<string[] | null, number[] | null>);
+}

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

@@ -1,6 +1,7 @@
 import { Command, CommandOptions } from "./command.js";
 export declare type ZRangeCommandOptions = {
     withScores?: boolean;
+    rev?: boolean;
 } & ({
     byScore: true;
     byLex?: never;
@@ -10,6 +11,12 @@ export declare type ZRangeCommandOptions = {
 } | {
     byScore?: never;
     byLex?: never;
+}) & ({
+    offset: number;
+    count: number;
+} | {
+    offset?: never;
+    count?: never;
 });
 /**
  * @see https://redis.io/commands/zrange

package/types/pkg/http.d.ts

@@ -1,3 +1,4 @@
+import { Telemetry } from "./types.js";
 export declare type UpstashRequest = {
     path?: string[];
     /**
@@ -12,19 +13,76 @@ export declare type UpstashResponse<TResult> = {
 export interface Requester {
     request: <TResult = unknown>(req: UpstashRequest) => Promise<UpstashResponse<TResult>>;
 }
+export declare type RetryConfig = false | {
+    /**
+     * The number of retries to attempt before giving up.
+     *
+     * @default 5
+     */
+    retries?: number;
+    /**
+     * A backoff function receives the current retry cound and returns a number in milliseconds to wait before retrying.
+     *
+     * @default
+     * ```ts
+     * Math.exp(retryCount) * 50
+     * ```
+     */
+    backoff?: (retryCount: number) => number;
+};
+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?: {
-        backend?: string;
-    };
-};
+    options?: Options;
+    retry?: RetryConfig;
+    agent?: any;
+    telemetry?: Telemetry;
+} & 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;
+        backoff: (retryCount: number) => number;
     };
     constructor(config: HttpClientConfig);
+    mergeTelemetry(telemetry: Telemetry): void;
     request<TResult>(req: UpstashRequest): Promise<UpstashResponse<TResult>>;
 }