feat: improve typings for pipeline

Author: luin

bin/generateRedisCommander/overrides.js

@@ -33,7 +33,7 @@ module.exports = {
   exec: {
     overwrite: true,
     defs: [
-      "exec(callback?: Callback<[error: Error, result: unknown][] | null>): Promise<[error: Error, result: unknown][] | null>;",
+      "exec(callback?: Callback<[error: Error | null, result: unknown][] | null>): Promise<[error: Error | null, result: unknown][] | null>;",
     ],
   },
 };

bin/generateRedisCommander/template.ts

@@ -1,6 +1,7 @@
+import { Callback } from "../types";
+
 type RedisKey = string | Buffer;
 type RedisValue = string | Buffer | number;
-type Callback<T> = (err: Error | null | undefined, res?: T) => void;
 
 // Inspired by https://github.com/mmkal/handy-redis/blob/main/src/generated/interface.ts.
 // Should be fixed with https://github.com/Microsoft/TypeScript/issues/1213

bin/generateRedisCommander/typeMaps.js

@@ -18,7 +18,7 @@ module.exports = {
       : "string | Buffer",
   pattern: "string",
   number: (name) =>
-    ["seconds", "count", "start", "stop", "index"].some((pattern) =>
+    ["seconds", "count", "start", "stop", "end", "index"].some((pattern) =>
       name.toLowerCase().includes(pattern)
     )
       ? "number"

lib/Redis.ts

@@ -17,7 +17,7 @@ import {
 } from "./redis/RedisOptions";
 import { addTransactionSupport, Transaction } from "./transaction";
 import {
-  CallbackFunction,
+  Callback,
   CommandItem,
   NetStream,
   ScanStreamOptions,
@@ -182,7 +182,7 @@ class Redis extends Commander {
    * When calling this method manually, a Promise is returned, which will
    * be resolved when the connection status is ready.
    */
-  connect(callback?: CallbackFunction<void>): Promise<void> {
+  connect(callback?: Callback<void>): Promise<void> {
     const promise = new Promise<void>((resolve, reject) => {
       if (
         this.status === "connecting" ||
@@ -447,7 +447,7 @@ class Redis extends Commander {
    * });
    * ```
    */
-  monitor(callback: CallbackFunction<Redis>): Promise<Redis> {
+  monitor(callback: Callback<Redis>): Promise<Redis> {
     const monitorInstance = this.duplicate({
       monitor: true,
       lazyConnect: false,
@@ -734,7 +734,7 @@ class Redis extends Commander {
    * Check whether Redis has finished loading the persistent data and is able to
    * process commands.
    */
-  private _readyCheck(callback: CallbackFunction) {
+  private _readyCheck(callback: Callback) {
     const _this = this;
     this.info(function (err, res) {
       if (err) {

lib/cluster/index.ts

@@ -7,7 +7,7 @@ import Command from "../command";
 import ClusterAllFailedError from "../errors/ClusterAllFailedError";
 import Redis from "../Redis";
 import ScanStream from "../ScanStream";
-import { CallbackFunction, ScanStreamOptions, WriteableStream } from "../types";
+import { Callback, ScanStreamOptions, WriteableStream } from "../types";
 import {
   CONNECTION_CLOSED_ERROR_MSG,
   Debug,
@@ -74,7 +74,7 @@ class Cluster extends Commander {
   private isRefreshing = false;
   private _autoPipelines: Map<string, typeof Pipeline> = new Map();
   private _runningAutoPipelines: Set<string> = new Set();
-  private _readyDelayedCallbacks: CallbackFunction[] = [];
+  private _readyDelayedCallbacks: Callback[] = [];
 
   /**
    * Every time Cluster#connect() is called, this value will be
@@ -299,7 +299,7 @@ class Cluster extends Commander {
   /**
    * Quit the cluster gracefully.
    */
-  quit(callback?: CallbackFunction<"OK">): Promise<"OK"> {
+  quit(callback?: Callback<"OK">): Promise<"OK"> {
     const status = this.status;
     this.setStatus("disconnecting");
 
@@ -375,7 +375,7 @@ class Cluster extends Commander {
   }
 
   // This is needed in order not to install a listener for each auto pipeline
-  delayUntilReady(callback: CallbackFunction) {
+  delayUntilReady(callback: Callback) {
     this._readyDelayedCallbacks.push(callback);
   }
 
@@ -397,7 +397,7 @@ class Cluster extends Commander {
   /**
    * Refresh the slot cache
    */
-  refreshSlotsCache(callback?: CallbackFunction<void>): void {
+  refreshSlotsCache(callback?: Callback<void>): void {
     if (this.isRefreshing) {
       if (typeof callback === "function") {
         process.nextTick(callback);
@@ -872,7 +872,7 @@ class Cluster extends Commander {
   /**
    * Check whether Cluster is able to process commands
    */
-  private readyCheck(callback: CallbackFunction<void | "fail">): void {
+  private readyCheck(callback: Callback<void | "fail">): void {
     (this as any).cluster("info", function (err, res) {
       if (err) {
         return callback(err);

lib/command.ts

@@ -8,7 +8,7 @@ import {
   convertMapToArray,
   convertObjectToArray,
 } from "./utils";
-import { CallbackFunction, Respondable, CommandParameter } from "./types";
+import { Callback, Respondable, CommandParameter } from "./types";
 
 export type ArgumentType =
   | string
@@ -157,7 +157,7 @@ export default class Command implements Respondable {
   private replyEncoding: BufferEncoding | null;
   private errorStack: Error;
   private bufferMode: boolean;
-  private callback: CallbackFunction;
+  private callback: Callback;
   private transformed = false;
   private _commandTimeoutTimer?: NodeJS.Timeout;
 
@@ -176,7 +176,7 @@ export default class Command implements Respondable {
     public name: string,
     args: Array<ArgumentType> = [],
     options: CommandOptions = {},
-    callback?: CallbackFunction
+    callback?: Callback
   ) {
     this.replyEncoding = options.replyEncoding;
     this.errorStack = options.errorStack;

lib/pipeline.ts

@@ -4,7 +4,7 @@ import asCallback from "standard-as-callback";
 import { deprecate } from "util";
 import Redis, { Cluster } from ".";
 import Command from "./command";
-import { CallbackFunction, PipelineWriteableStream } from "./types";
+import { Callback, PipelineWriteableStream } from "./types";
 import { noop } from "./utils";
 import Commander from "./utils/Commander";
 
@@ -259,9 +259,7 @@ Pipeline.prototype.execBuffer = deprecate(function () {
 //
 // If a different promise instance were returned, that promise would cause its own unhandled promise rejection
 // errors, even if that promise unconditionally resolved to **the resolved value of** this.promise.
-Pipeline.prototype.exec = function (
-  callback: CallbackFunction
-): Promise<Array<any>> {
+Pipeline.prototype.exec = function (callback: Callback): Promise<Array<any>> {
   // Wait for the cluster to be connected, since we need nodes information before continuing
   if (this.isCluster && !this.redis.slots.length) {
     if (this.redis.status === "wait") this.redis.connect().catch(noop);

lib/script.ts

@@ -1,7 +1,7 @@
 import { createHash } from "crypto";
 import Command from "./command";
 import asCallback from "standard-as-callback";
-import { CallbackFunction } from "./types";
+import { Callback } from "./types";
 export default class Script {
   private sha: string;
   private Command: new (...args: any[]) => Command;
@@ -40,12 +40,7 @@ export default class Script {
     };
   }
 
-  execute(
-    container: any,
-    args: any[],
-    options: any,
-    callback?: CallbackFunction
-  ) {
+  execute(container: any, args: any[], options: any, callback?: Callback) {
     if (typeof this.numberOfKeys === "number") {
       args.unshift(this.numberOfKeys);
     }
@@ -56,11 +51,7 @@ export default class Script {
       options.readOnly = true;
     }
 
-    const evalsha = new this.Command(
-      "evalsha",
-      [this.sha, ...args],
-      options
-    );
+    const evalsha = new this.Command("evalsha", [this.sha, ...args], options);
     evalsha.isCustomCommand = true;
 
     evalsha.promise = evalsha.promise.catch((err: Error) => {
@@ -70,11 +61,7 @@ export default class Script {
 
       // Resend the same custom evalsha command that gets transformed to an eval
       // in case it's not loaded yet on the connectionDo an eval as fallback, redis will hash and load it
-      const resend = new this.Command(
-        "evalsha",
-        [this.sha, ...args],
-        options
-      );
+      const resend = new this.Command("evalsha", [this.sha, ...args], options);
       resend.isCustomCommand = true;
 
       const client = container.isPipeline ? container.redis : container;

lib/transaction.ts

@@ -1,20 +1,15 @@
 import { wrapMultiResult, noop } from "./utils";
 import asCallback from "standard-as-callback";
 import Pipeline from "./pipeline";
-import { CallbackFunction } from "./types";
+import { Callback } from "./types";
 import { ChainableCommander } from "./utils/RedisCommander";
 
-interface MultiOptions {
-  pipeline: boolean;
-}
-
 export interface Transaction {
   pipeline(commands?: [name: string, ...args: unknown[]][]): ChainableCommander;
-  multi(options?: MultiOptions): ChainableCommander;
-  multi(
-    commands?: [name: string, ...args: unknown[]][],
-    options?: MultiOptions
-  ): ChainableCommander;
+  multi(options: { pipeline: false }): Promise<"OK">;
+  multi(): ChainableCommander;
+  multi(options: { pipeline: true }): ChainableCommander;
+  multi(commands?: [name: string, ...args: unknown[]][]): ChainableCommander;
 }
 
 export function addTransactionSupport(redis) {
@@ -42,7 +37,7 @@ export function addTransactionSupport(redis) {
       pipeline.addBatch(commands);
     }
     const exec = pipeline.exec;
-    pipeline.exec = function (callback: CallbackFunction) {
+    pipeline.exec = function (callback: Callback) {
       // Wait for the cluster to be connected, since we need nodes information before continuing
       if (this.isCluster && !this.redis.slots.length) {
         if (this.redis.status === "wait") this.redis.connect().catch(noop);
@@ -97,7 +92,7 @@ export function addTransactionSupport(redis) {
     // @ts-expect-error
     const { execBuffer } = pipeline;
     // @ts-expect-error
-    pipeline.execBuffer = function (callback: CallbackFunction) {
+    pipeline.execBuffer = function (callback: Callback) {
       if (this._transactions > 0) {
         execBuffer.call(pipeline);
       }
@@ -107,7 +102,7 @@ export function addTransactionSupport(redis) {
   };
 
   const { exec } = redis;
-  redis.exec = function (callback: CallbackFunction): Promise<any[] | null> {
+  redis.exec = function (callback: Callback): Promise<any[] | null> {
     return asCallback(
       exec.call(this).then(function (results: any[] | null) {
         if (Array.isArray(results)) {

lib/types.ts

@@ -1,7 +1,7 @@
 import { Socket } from "net";
 import { TLSSocket } from "tls";
 
-export type CallbackFunction<T = any> = (err?: Error | null, result?: T) => void;
+export type Callback<T = any> = (err?: Error | null, result?: T) => void;
 export type NetStream = Socket | TLSSocket;
 
 export type CommandParameter = string | Buffer | number | any[];

lib/utils/Commander.ts

@@ -5,7 +5,7 @@ import {
 } from "../autoPipelining";
 import Command, { ArgumentType } from "../command";
 import Script from "../script";
-import { CallbackFunction, WriteableStream } from "../types";
+import { Callback, WriteableStream } from "../types";
 import RedisCommander, { ClientContext } from "./RedisCommander";
 
 export interface CommanderOptions {
@@ -129,9 +129,7 @@ function generateFunction(
     _commandName = null;
   }
 
-  return function (
-    ...args: ArgumentType[] | [...ArgumentType[], CallbackFunction]
-  ) {
+  return function (...args: ArgumentType[] | [...ArgumentType[], Callback]) {
     const commandName = (_commandName || args.shift()) as string;
     let callback = args[args.length - 1];
 
@@ -150,7 +148,7 @@ function generateFunction(
     if (this.options.dropBufferSupport && !_encoding) {
       return asCallback(
         Promise.reject(new Error(DROP_BUFFER_SUPPORT_ERROR)),
-        callback as CallbackFunction | undefined
+        callback as Callback | undefined
       );
     }
 

lib/utils/RedisCommander.ts

@@ -1,6 +1,6 @@
 import { parse as urllibParse } from "url";
 import { defaults, noop } from "./lodash";
-import { CallbackFunction } from "../types";
+import { Callback } from "../types";
 import Debug from "./debug";
 
 import TLSProfiles from "../constants/TLSProfiles";
@@ -106,7 +106,7 @@ export function packObject(array: any[]): Record<string, any> {
 /**
  * Return a callback with timeout
  */
-export function timeout(callback: CallbackFunction, timeout: number) {
+export function timeout(callback: Callback, timeout: number) {
   let timer: NodeJS.Timeout;
   const run = function () {
     if (timer) {

lib/utils/index.ts

@@ -5,6 +5,7 @@ const redis = new Redis();
 
 // GET
 expectType<Promise<string | null>>(redis.get("key"));
+expectType<Promise<Buffer | null>>(redis.getBuffer("key"));
 expectError(redis.get("key", "bar"));
 
 // SET
@@ -14,6 +15,11 @@ expectError(redis.set("key", "bar", "EX", "NX"));
 expectType<Promise<"OK" | null>>(redis.set("key", "bar", "EX", 100, "NX")); // NX can fail thus `null` is returned
 expectType<Promise<string | null>>(redis.set("key", "bar", "GET"));
 
+// DEL
+expectType<Promise<number>>(redis.del("key"));
+expectType<Promise<number>>(redis.del(["key1", "key2"]));
+expectType<Promise<number>>(redis.del("key1", "key2"));
+
 // INCR
 expectType<Promise<number>>(redis.incr("key"));
 expectType<Promise<number>>(redis.incrby("key", 42));
@@ -39,3 +45,32 @@ expectType<Promise<number[]>>(
 // ZADD
 expectType<Promise<number>>(redis.zadd("key", 1, "member"));
 expectType<Promise<number>>(redis.zadd("key", "CH", 1, "member"));
+
+// GETRANGE
+expectType<Promise<Buffer>>(redis.getrangeBuffer("foo", 0, 1));
+
+// Callbacks
+redis.getBuffer("foo", (err, res) => {
+  expectType<Error | null | undefined>(err);
+  expectType<Buffer | null | undefined>(res);
+});
+
+redis.set("foo", "bar", (err, res) => {
+  expectType<Error | null | undefined>(err);
+  expectType<"OK" | undefined>(res);
+});
+
+redis.set("foo", "bar", "GET", (err, res) => {
+  expectType<Error | null | undefined>(err);
+  expectType<string | null | undefined>(res);
+});
+
+redis.del("key1", "key2", (err, res) => {
+  expectType<Error | null | undefined>(err);
+  expectType<number | undefined>(res);
+});
+
+redis.del(["key1", "key2"], (err, res) => {
+  expectType<Error | null | undefined>(err);
+  expectType<number | undefined>(res);
+});

test-d/basic.test-d.ts test-d/commands.test-d.ts

@@ -0,0 +1,17 @@
+import { expectType } from "tsd";
+import Redis from "../built";
+
+const redis = new Redis();
+
+expectType<Promise<[Error | null, unknown][] | null>>(
+  redis.pipeline().set("foo", "bar").get("foo").exec()
+);
+
+expectType<Promise<[Error | null, unknown][] | null>>(
+  redis
+    .pipeline([
+      ["set", "foo", "bar"],
+      ["get", "foo"],
+    ])
+    .exec()
+);