@upstash/redis 0.0.0-ci.b4d4a1cc → 0.0.0-ci.b984c0e9-20220826

package/script/pkg/script.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Script = void 0;
+const mod_js_1 = require("../deps/deno.land/x/sha1@v1.0.3/mod.js");
+/**
+ * Creates a new script.
+ *
+ * Scripts offer the ability to optimistically try to execute a script without having to send the
+ * entire script to the server. If the script is loaded on the server, it tries again by sending
+ * the entire script. Afterwards, the script is cached on the server.
+ *
+ * @example
+ * ```ts
+ * const redis = new Redis({...})
+ *
+ * const script = redis.createScript<string>("return ARGV[1];")
+ * const arg1 = await script.eval([], ["Hello World"])
+ * assertEquals(arg1, "Hello World")
+ * ```
+ */
+class Script {
+    constructor(redis, script) {
+        Object.defineProperty(this, "script", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "sha1", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "redis", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.redis = redis;
+        this.sha1 = this.digest(script);
+        this.script = script;
+    }
+    /**
+     * Send an `EVAL` command to redis.
+     */
+    async eval(keys, args) {
+        return await this.redis.eval(this.script, keys, args);
+    }
+    /**
+     * Calculates the sha1 hash of the script and then calls `EVALSHA`.
+     */
+    async evalsha(keys, args) {
+        return await this.redis.evalsha(this.sha1, keys, args);
+    }
+    /**
+     * Optimistically try to run `EVALSHA` first.
+     * If the script is not loaded in redis, it will fall back and try again with `EVAL`.
+     *
+     * Following calls will be able to use the cached script
+     */
+    async exec(keys, args) {
+        const res = await this.redis.evalsha(this.sha1, keys, args).catch(async (err) => {
+            if (err instanceof Error &&
+                err.message.toLowerCase().includes("noscript")) {
+                return await this.redis.eval(this.script, keys, args);
+            }
+            throw err;
+        });
+        return res;
+    }
+    /**
+     * Compute the sha1 hash of the script and return its hex representation.
+     */
+    digest(s) {
+        const hash = (0, mod_js_1.sha1)(s, "utf8", "hex");
+        return typeof hash === "string" ? hash : new TextDecoder().decode(hash);
+    }
+}
+exports.Script = Script;

package/script/platforms/cloudflare.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.
  */
@@ -52,7 +52,8 @@ 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({
+            retry: config.retry,
             baseUrl: config.url,
             headers: { authorization: `Bearer ${config.token}` },
         });
@@ -70,9 +71,8 @@ class Redis extends core.Redis {
      * ```ts
      * const redis = Redis.fromEnv(env)
      * ```
-     *
      */
-    static fromEnv(env) {
+    static fromEnv(env, opts) {
         // @ts-ignore These will be defined by cloudflare
         const url = env?.UPSTASH_REDIS_REST_URL ?? UPSTASH_REDIS_REST_URL;
         // @ts-ignore These will be defined by cloudflare
@@ -83,27 +83,7 @@ class Redis extends core.Redis {
         if (!token) {
             throw new Error("Unable to find environment variable: `UPSTASH_REDIS_REST_TOKEN`. Please add it via `wrangler secret put UPSTASH_REDIS_REST_TOKEN`");
         }
-        return new Redis({ url, token });
+        return new Redis({ ...opts, 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,
-            });
-            const body = (await res.json());
-            if (!res.ok) {
-                throw new error_js_1.UpstashError(body.error);
-            }
-            return body;
-        },
-    };
-}

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,11 @@ 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 },
         });
         super(client, {
             automaticDeserialization: config.automaticDeserialization,
@@ -64,25 +65,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,7 +26,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");
 require("isomorphic-fetch");
 /**
  * Serverless redis client for upstash.
@@ -47,8 +47,9 @@ 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 client = new http_js_1.HttpClient({
             baseUrl: configOrRequester.url,
+            retry: configOrRequester.retry,
             headers: { authorization: `Bearer ${configOrRequester.token}` },
             // agent: configOrRequester.agent,
         });
@@ -80,29 +81,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,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.
  */
@@ -46,8 +46,9 @@ 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 client = new http_js_1.HttpClient({
             baseUrl: configOrRequester.url,
+            retry: configOrRequester.retry,
             headers: { authorization: `Bearer ${configOrRequester.token}` },
             // agent: configOrRequester.agent,
         });
@@ -65,43 +66,30 @@ class Redis extends core.Redis {
      * your environment using `process.env`.
      */
     static fromEnv(config) {
+        let url = undefined;
+        let token = undefined;
         // @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');
+        if (typeof process !== "undefined") {
+            // @ts-ignore process will be defined in node
+            url = process?.env["UPSTASH_REDIS_REST_URL"];
+            // @ts-ignore process will be defined in node
+            token = process?.env["UPSTASH_REDIS_REST_TOKEN"];
+        }
+        // fallback for Vite https://vitejs.dev/guide/env-and-mode.html
+        if (!url) {
+            url = import.meta.env["VITE_UPSTASH_REDIS_REST_URL"];
         }
-        // @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"];
+        // fallback for Vite https://vitejs.dev/guide/env-and-mode.html
+        if (!token) {
+            token = import.meta.env.VITE_UPSTASH_REDIS_REST_TOKEN;
+        }
         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/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/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

@@ -42,6 +42,7 @@ export * from "./lindex.js";
 export * from "./linsert.js";
 export * from "./llen.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/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/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

@@ -12,12 +12,31 @@ 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;
+};
+declare type Options = {
+    backend?: string;
+};
 export declare type HttpClientConfig = {
     headers?: Record<string, string>;
     baseUrl: string;
-    options?: {
-        backend?: string;
-    };
+    options?: Options;
+    retry?: RetryConfig;
 };
 export declare class HttpClient implements Requester {
     baseUrl: string;
@@ -25,6 +44,11 @@ export declare class HttpClient implements Requester {
     readonly options?: {
         backend?: string;
     };
+    readonly retry: {
+        attempts: number;
+        backoff: (retryCount: number) => number;
+    };
     constructor(config: HttpClientConfig);
     request<TResult>(req: UpstashRequest): Promise<UpstashResponse<TResult>>;
 }
+export {};

package/types/pkg/pipeline.d.ts

@@ -1,4 +1,4 @@
-import { DelCommand, ExistsCommand, FlushAllCommand, PingCommand, ScoreMember, ScriptExistsCommand, SetCommandOptions, TouchCommand, UnlinkCommand, ZAddCommandOptions, ZAddCommandOptionsWithIncr, ZRangeCommandOptions } from "./commands/mod.js";
+import { DelCommand, ExistsCommand, FlushAllCommand, MGetCommand, 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";
@@ -79,7 +79,7 @@ export declare class Pipeline {
     /**
      * @see https://redis.io/commands/bitpos
      */
-    bitpos: (key: string, start: number, end: number) => this;
+    bitpos: (key: string, bit: 0 | 1, start?: number | undefined, end?: number | undefined) => this;
     /**
      * @see https://redis.io/commands/dbsize
      */
@@ -241,7 +241,15 @@ export declare class Pipeline {
     /**
      * @see https://redis.io/commands/lpop
      */
-    lpop: <TData>(key: string) => this;
+    lpop: <TData>(key: string, count?: number | undefined) => this;
+    /**
+     * @see https://redis.io/commands/lpos
+     */
+    lpos: <TData>(key: string, element: unknown, opts?: {
+        rank?: number | undefined;
+        count?: number | undefined;
+        maxLen?: number | undefined;
+    } | undefined) => this;
     /**
      * @see https://redis.io/commands/lpush
      */
@@ -269,7 +277,7 @@ export declare class Pipeline {
     /**
      * @see https://redis.io/commands/mget
      */
-    mget: <TData extends unknown[]>(args_0: string, ...args_1: string[]) => this;
+    mget: <TData extends unknown[]>(...args: CommandArgs<typeof MGetCommand>) => this;
     /**
      * @see https://redis.io/commands/mset
      */
@@ -325,7 +333,7 @@ export declare class Pipeline {
     /**
      * @see https://redis.io/commands/rpop
      */
-    rpop: <TData = string>(key: string) => this;
+    rpop: <TData = string>(key: string, count?: number | undefined) => this;
     /**
      * @see https://redis.io/commands/rpush
      */
@@ -366,7 +374,7 @@ export declare class Pipeline {
     /**
      * @see https://redis.io/commands/set
      */
-    set: <TData>(key: string, value: TData, opts?: SetCommandOptions | undefined) => this;
+    set: <TData>(key: string, value: TData, opts?: SetCommandOptions) => this;
     /**
      * @see https://redis.io/commands/setbit
      */