Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
75 changes: 74 additions & 1 deletion lib/cluster/index.ts
Original file line number Diff line number Diff line change
Expand Up @@ -1457,7 +1457,80 @@ class Cluster<

// eslint-disable-next-line @typescript-eslint/no-unused-vars
interface Cluster<ReplyMapping extends "legacy" | "resp3" = "legacy">
extends EventEmitter {}
extends EventEmitter {
on(event: "message", cb: (channel: string, message: string) => void): this;
once(event: "message", cb: (channel: string, message: string) => void): this;

on(
event: "messageBuffer",
cb: (channel: Buffer, message: Buffer) => void
): this;
once(
event: "messageBuffer",
cb: (channel: Buffer, message: Buffer) => void
): this;

on(
event: "pmessage",
cb: (pattern: string, channel: string, message: string) => void
): this;
once(
event: "pmessage",
cb: (pattern: string, channel: string, message: string) => void
): this;

on(
event: "pmessageBuffer",
cb: (pattern: string, channel: Buffer, message: Buffer) => void
): this;
once(
event: "pmessageBuffer",
cb: (pattern: string, channel: Buffer, message: Buffer) => void
): this;

on(event: "smessage", cb: (channel: string, message: string) => void): this;
once(event: "smessage", cb: (channel: string, message: string) => void): this;

on(
event: "smessageBuffer",
cb: (channel: Buffer, message: Buffer) => void
): this;
once(
event: "smessageBuffer",
cb: (channel: Buffer, message: Buffer) => void
): this;

on(event: "error", cb: (error: Error) => void): this;
once(event: "error", cb: (error: Error) => void): this;

on(event: "+node", cb: (node: Redis) => void): this;
once(event: "+node", cb: (node: Redis) => void): this;

on(event: "-node", cb: (node: Redis, nodeKey?: string) => void): this;
once(event: "-node", cb: (node: Redis, nodeKey?: string) => void): this;

on(event: "node error", cb: (error: Error, nodeKey: string) => void): this;
once(event: "node error", cb: (error: Error, nodeKey: string) => void): this;

on(event: "nodeError", cb: (error: Error, nodeKey: string) => void): this;
once(event: "nodeError", cb: (error: Error, nodeKey: string) => void): this;

on(
event: "+subscriber" | "-subscriber" | "subscribersReady" | "refresh",
cb: () => void
): this;
once(
event: "+subscriber" | "-subscriber" | "subscribersReady" | "refresh",
cb: () => void
): this;

on(event: ClusterStatus, cb: () => void): this;
once(event: ClusterStatus, cb: () => void): this;

// base method of EventEmitter
on(event: string | symbol, listener: (...args: any[]) => void): this;
once(event: string | symbol, listener: (...args: any[]) => void): this;
}
applyMixin(Cluster, EventEmitter);

addTransactionSupport(Cluster.prototype);
Expand Down
144 changes: 144 additions & 0 deletions test/typing/cluster-events.test-d.ts
Original file line number Diff line number Diff line change
@@ -0,0 +1,144 @@
import { expectType } from "tsd";
import { Cluster, Redis } from "../../built";

const cluster = new Cluster([]);

expectType<Cluster>(cluster.on("connect", () => {}));
expectType<Cluster>(cluster.on("ready", () => {}));
expectType<Cluster>(cluster.on("close", () => {}));
expectType<Cluster>(cluster.on("reconnecting", () => {}));
expectType<Cluster>(cluster.on("end", () => {}));
expectType<Cluster>(cluster.on("disconnecting", () => {}));
expectType<Cluster>(cluster.on("wait", () => {}));

expectType<Cluster>(
cluster.on("error", (error) => {
expectType<Error>(error);
})
);

expectType<Cluster>(cluster.once("connect", () => {}));
expectType<Cluster>(cluster.once("ready", () => {}));
expectType<Cluster>(cluster.once("close", () => {}));
expectType<Cluster>(cluster.once("reconnecting", () => {}));
expectType<Cluster>(cluster.once("end", () => {}));
expectType<Cluster>(cluster.once("disconnecting", () => {}));
expectType<Cluster>(cluster.once("wait", () => {}));

expectType<Cluster>(
cluster.once("error", (error) => {
expectType<Error>(error);
})
);

cluster.on("message", (channel, message) => {
expectType<string>(channel);
expectType<string>(message);
});

cluster.on("messageBuffer", (channel, message) => {
expectType<Buffer>(channel);
expectType<Buffer>(message);
});

cluster.on("pmessage", (pattern, channel, message) => {
expectType<string>(pattern);
expectType<string>(channel);
expectType<string>(message);
});

cluster.on("pmessageBuffer", (pattern, channel, message) => {
expectType<string>(pattern);
expectType<Buffer>(channel);
expectType<Buffer>(message);
});

cluster.on("smessage", (channel, message) => {
expectType<string>(channel);
expectType<string>(message);
});

cluster.on("smessageBuffer", (channel, message) => {
expectType<Buffer>(channel);
expectType<Buffer>(message);
});

cluster.once("message", (channel, message) => {
expectType<string>(channel);
expectType<string>(message);
});

cluster.once("messageBuffer", (channel, message) => {
expectType<Buffer>(channel);
expectType<Buffer>(message);
});

cluster.once("pmessage", (pattern, channel, message) => {
expectType<string>(pattern);
expectType<string>(channel);
expectType<string>(message);
});

cluster.once("pmessageBuffer", (pattern, channel, message) => {
expectType<string>(pattern);
expectType<Buffer>(channel);
expectType<Buffer>(message);
});

cluster.once("smessage", (channel, message) => {
expectType<string>(channel);
expectType<string>(message);
});

cluster.once("smessageBuffer", (channel, message) => {
expectType<Buffer>(channel);
expectType<Buffer>(message);
});

cluster.on("+node", (node) => {
expectType<Redis>(node);
});

cluster.on("-node", (node, nodeKey) => {
expectType<Redis>(node);
expectType<string | undefined>(nodeKey);
});

cluster.on("node error", (error, nodeKey) => {
expectType<Error>(error);
expectType<string>(nodeKey);
});

cluster.on("nodeError", (error, nodeKey) => {
expectType<Error>(error);
expectType<string>(nodeKey);
});

cluster.once("+node", (node) => {
expectType<Redis>(node);
});

cluster.once("-node", (node, nodeKey) => {
expectType<Redis>(node);
expectType<string | undefined>(nodeKey);
});

cluster.once("node error", (error, nodeKey) => {
expectType<Error>(error);
expectType<string>(nodeKey);
});

cluster.once("nodeError", (error, nodeKey) => {
expectType<Error>(error);
expectType<string>(nodeKey);
});

cluster.on("+subscriber", () => {});
cluster.on("-subscriber", () => {});
cluster.on("subscribersReady", () => {});
cluster.on("refresh", () => {});

cluster.once("+subscriber", () => {});
cluster.once("-subscriber", () => {});
cluster.once("subscribersReady", () => {});
cluster.once("refresh", () => {});
Loading