BREAKING: rename CommandExecutor to Client

Author: uki00a

client.ts

@@ -0,0 +1,50 @@
+import type { Connection, SendCommandOptions } from "./connection.ts";
+import type { RedisReply, RedisValue } from "./protocol/shared/types.ts";
+
+export interface Client {
+  /**
+   * @deprecated
+   */
+  readonly connection: Connection;
+  /**
+   * @deprecated
+   */
+  exec(
+    command: string,
+    ...args: RedisValue[]
+  ): Promise<RedisReply>;
+
+  sendCommand(
+    command: string,
+    args?: RedisValue[],
+    options?: SendCommandOptions,
+  ): Promise<RedisReply>;
+
+  /**
+   * Closes a redis connection.
+   */
+  close(): void;
+}
+
+export class DefaultClient implements Client {
+  constructor(readonly connection: Connection) {}
+
+  exec(
+    command: string,
+    ...args: RedisValue[]
+  ): Promise<RedisReply> {
+    return this.connection.sendCommand(command, args);
+  }
+
+  sendCommand(
+    command: string,
+    args?: RedisValue[],
+    options?: SendCommandOptions,
+  ) {
+    return this.connection.sendCommand(command, args, options);
+  }
+
+  close(): void {
+    this.connection.close();
+  }
+}

executor.ts

@@ -1,50 +1,4 @@
-import type { Connection, SendCommandOptions } from "./connection.ts";
-import type { RedisReply, RedisValue } from "./protocol/shared/types.ts";
+import type { Client } from "./client.ts";
 
-export interface CommandExecutor {
-  /**
-   * @deprecated
-   */
-  readonly connection: Connection;
-  /**
-   * @deprecated
-   */
-  exec(
-    command: string,
-    ...args: RedisValue[]
-  ): Promise<RedisReply>;
-
-  sendCommand(
-    command: string,
-    args?: RedisValue[],
-    options?: SendCommandOptions,
-  ): Promise<RedisReply>;
-
-  /**
-   * Closes a redis connection.
-   */
-  close(): void;
-}
-
-export class DefaultExecutor implements CommandExecutor {
-  constructor(readonly connection: Connection) {}
-
-  exec(
-    command: string,
-    ...args: RedisValue[]
-  ): Promise<RedisReply> {
-    return this.connection.sendCommand(command, args);
-  }
-
-  sendCommand(
-    command: string,
-    args?: RedisValue[],
-    options?: SendCommandOptions,
-  ) {
-    return this.connection.sendCommand(command, args, options);
-  }
-
-  close(): void {
-    this.connection.close();
-  }
-}
+/** @deprecated Use {@linkcode Client} instead. */
+export type CommandExecutor = Client;

experimental/cluster/mod.ts

@@ -28,7 +28,7 @@
 
 import { connect, create } from "../../redis.ts";
 import type { RedisConnectOptions } from "../../redis.ts";
-import type { CommandExecutor } from "../../executor.ts";
+import type { Client } from "../../client.ts";
 import type { Connection, SendCommandOptions } from "../../connection.ts";
 import type { Redis } from "../../redis.ts";
 import type { RedisReply, RedisValue } from "../../protocol/shared/types.ts";
@@ -74,7 +74,7 @@ const kRedisClusterRequestTTL = 16;
 
 class ClusterError extends Error {}
 
-class ClusterExecutor implements CommandExecutor {
+class ClusterClient implements Client {
   #nodeBySlot!: SlotMap;
   #startupNodes: ClusterNode[];
   #refreshTableASAP?: boolean;
@@ -338,9 +338,9 @@ function getKeyFromCommand(command: string, args: RedisValue[]): string | null {
  * @see https://redis.io/topics/cluster-spec
  */
 async function connectToCluster(opts: ClusterConnectOptions): Promise<Redis> {
-  const executor = new ClusterExecutor(opts);
-  await executor.initializeSlotsCache();
-  return create(executor);
+  const client = new ClusterClient(opts);
+  await client.initializeSlotsCache();
+  return create(client);
 }
 
 export { connectToCluster as connect };

mod.ts

@@ -67,6 +67,7 @@ export type {
   ConnectionEventType,
   ConnectionReconnectingEventDetails,
 } from "./events.ts";
+export type { Client } from "./client.ts";
 export type { CommandExecutor } from "./executor.ts";
 export type { RedisPipeline } from "./pipeline.ts";
 export type {

pipeline.ts

@@ -1,6 +1,6 @@
 import type { Connection, SendCommandOptions } from "./connection.ts";
 import { kEmptyRedisArgs } from "./connection.ts";
-import type { CommandExecutor } from "./executor.ts";
+import type { Client } from "./client.ts";
 import type {
   RawOrError,
   RedisReply,
@@ -19,15 +19,15 @@ export function createRedisPipeline(
   connection: Connection,
   tx = false,
 ): RedisPipeline {
-  const executor = new PipelineExecutor(connection, tx);
+  const pipeline = new PipelineClient(connection, tx);
   function flush(): Promise<RawOrError[]> {
-    return executor.flush();
+    return pipeline.flush();
   }
-  const client = create(executor);
+  const client = create(pipeline);
   return Object.assign(client, { flush });
 }
 
-export class PipelineExecutor implements CommandExecutor {
+class PipelineClient implements Client {
   private commands: {
     command: string;
     args: RedisValue[];

pool/executor.ts pool/client.tspool/executor.ts renamed to pool/client.ts

@@ -1,21 +1,21 @@
 import type { Connection, SendCommandOptions } from "../connection.ts";
 import type { Pool } from "./pool.ts";
-import type { CommandExecutor } from "../executor.ts";
-import { DefaultExecutor } from "../executor.ts";
+import type { Client } from "../client.ts";
+import { DefaultClient } from "../client.ts";
 import type { RedisReply, RedisValue } from "../protocol/shared/types.ts";
 
-export function createPooledExecutor(pool: Pool<Connection>): CommandExecutor {
-  return new PooledExecutor(pool);
+export function createPoolClient(pool: Pool<Connection>): Client {
+  return new PoolClient(pool);
 }
 
-class PooledExecutor implements CommandExecutor {
+class PoolClient implements Client {
   readonly #pool: Pool<Connection>;
   constructor(pool: Pool<Connection>) {
     this.#pool = pool;
   }
 
   get connection(): Connection {
-    throw new Error("PooledExecutor.connection is not supported");
+    throw new Error("PoolClient.connection is not supported");
   }
 
   async exec(
@@ -24,8 +24,8 @@ class PooledExecutor implements CommandExecutor {
   ): Promise<RedisReply> {
     const connection = await this.#pool.acquire();
     try {
-      const executor = new DefaultExecutor(connection);
-      return await executor.exec(command, ...args);
+      const client = new DefaultClient(connection);
+      return await client.exec(command, ...args);
     } finally {
       this.#pool.release(connection);
     }
@@ -38,8 +38,8 @@ class PooledExecutor implements CommandExecutor {
   ): Promise<RedisReply> {
     const connection = await this.#pool.acquire();
     try {
-      const executor = new DefaultExecutor(connection);
-      return await executor.sendCommand(command, args, options);
+      const client = new DefaultClient(connection);
+      return await client.sendCommand(command, args, options);
     } finally {
       this.#pool.release(connection);
     }

pool/mod.ts

@@ -3,7 +3,7 @@ import { create } from "../redis.ts";
 import type { Connection } from "../connection.ts";
 import { createRedisConnection } from "../connection.ts";
 import { createDefaultPool } from "./default_pool.ts";
-import { createPooledExecutor } from "./executor.ts";
+import { createPoolClient as baseCreatePoolClient } from "./client.ts";
 
 export interface CreatePoolClientOptions {
   connection: RedisConnectOptions;
@@ -17,8 +17,7 @@ export function createPoolClient(
     acquire,
     maxConnections: options.maxConnections ?? 8,
   });
-  const executor = createPooledExecutor(pool);
-  const client = create(executor);
+  const client = create(baseCreatePoolClient(pool));
   return Promise.resolve(client);
 
   async function acquire(): Promise<Connection> {

pubsub.ts

@@ -1,4 +1,4 @@
-import type { CommandExecutor } from "./executor.ts";
+import type { Client } from "./client.ts";
 import { isRetriableError } from "./errors.ts";
 import type { Binary } from "./protocol/shared/types.ts";
 import { decoder } from "./internal/encoding.ts";
@@ -33,17 +33,17 @@ class RedisSubscriptionImpl<
   TMessage extends ValidMessageType = DefaultMessageType,
 > implements RedisSubscription<TMessage> {
   get isConnected(): boolean {
-    return this.executor.connection.isConnected;
+    return this.client.connection.isConnected;
   }
 
   get isClosed(): boolean {
-    return this.executor.connection.isClosed;
+    return this.client.connection.isClosed;
   }
 
   private channels = Object.create(null);
   private patterns = Object.create(null);
 
-  constructor(private executor: CommandExecutor) {}
+  constructor(private client: Client) {}
 
   async psubscribe(...patterns: string[]) {
     await this.#writeCommand("PSUBSCRIBE", patterns);
@@ -89,7 +89,7 @@ class RedisSubscriptionImpl<
     RedisPubSubMessage<T>
   > {
     let forceReconnect = false;
-    const connection = this.executor.connection;
+    const connection = this.client.connection;
     while (this.isConnected) {
       try {
         let rep: [string | Binary, string | Binary, T] | [
@@ -156,32 +156,32 @@ class RedisSubscriptionImpl<
   }
 
   close() {
-    this.executor.connection.close();
+    this.client.connection.close();
   }
 
   async #writeCommand(command: string, args: Array<string>): Promise<void> {
-    await this.executor.connection[kUnstableWriteCommand]({ command, args });
+    await this.client.connection[kUnstableWriteCommand]({ command, args });
   }
 }
 
 export async function subscribe<
   TMessage extends ValidMessageType = DefaultMessageType,
 >(
-  executor: CommandExecutor,
+  client: Client,
   ...channels: string[]
 ): Promise<RedisSubscription<TMessage>> {
-  const sub = new RedisSubscriptionImpl<TMessage>(executor);
+  const sub = new RedisSubscriptionImpl<TMessage>(client);
   await sub.subscribe(...channels);
   return sub;
 }
 
 export async function psubscribe<
   TMessage extends ValidMessageType = DefaultMessageType,
 >(
-  executor: CommandExecutor,
+  client: Client,
   ...patterns: string[]
 ): Promise<RedisSubscription<TMessage>> {
-  const sub = new RedisSubscriptionImpl<TMessage>(executor);
+  const sub = new RedisSubscriptionImpl<TMessage>(client);
   await sub.psubscribe(...patterns);
   return sub;
 }