Feature/Proxy Implementation (#41)

* WIP Proxy Implementation

* WIP Test Coverage

* Fixing Tests

Author: moaxaca

.env.example

@@ -0,0 +1,2 @@
+REDIS_HOST=localhost
+REDIS_PORT=6379

package.json

@@ -2,7 +2,7 @@
   "private": false,
   "author": "Matthew Oaxaca",
   "license": "MIT",
-  "version": "1.1.8",
+  "version": "2.0.0",
   "name": "async-redis",
   "keywords": [
     "redis",
@@ -30,20 +30,22 @@
   "scripts": {
     "coveralls": "nyc yarn test && nyc report --reporter=text-lcov | coveralls",
     "lint": "eslint --fix --ext .js, .",
-    "test": "mocha",
-    "test:unit": "mocha",
+    "test": "mocha test/**/*.spec.js --config test/setup.js --exit",
+    "test:unit": "mocha test/unit/*.spec.js --config test/setup.js --exit",
     "version:patch": "npm version patch",
     "version:minor": "npm version minor",
     "version:major": "npm version major"
   },
   "dependencies": {
-    "redis": "^3.0.2",
-    "redis-commands": "^1.6.0"
+    "redis": "3.0.2"
   },
   "devDependencies": {
+    "@types/node": "^14.0.27",
+    "@types/redis": "^2.8.25",
     "chai": "^4.2.0",
     "chai-as-promised": "^7.1.1",
     "coveralls": "^3.1.0",
+    "dotenv": "^8.2.0",
     "eslint": "^7.6.0",
     "mocha": "^8.1.0",
     "nyc": "^15.1.0"

src/index.d.ts

@@ -0,0 +1,162 @@
+import { Commands, RedisClient, ClientOpts, ServerInfo } from 'redis';
+import {EventEmitter} from "events";
+
+type Callback<T> = (err: Error | null, reply: T) => void;
+
+type Omit<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>>;
+type Omitted = Omit<RedisClient, keyof Commands<boolean>>;
+type OkOrError = 'OK'|Error
+
+interface OverloadedCommand<T, R> {
+  (arg1: T, arg2: T, arg3: T, arg4: T, arg5: T, arg6: T): R;
+  (arg1: T, arg2: T, arg3: T, arg4: T, arg5: T): R;
+  (arg1: T, arg2: T, arg3: T, arg4: T): R;
+  (arg1: T, arg2: T, arg3: T): R;
+  (arg1: T, arg2: T | T[]): R;
+  (arg1: T | T[]): R;
+  (...args: Array<T>): R;
+}
+
+interface Promisified<T = RedisClient> extends Omitted, Commands<Promise<boolean>> {}
+
+interface AsyncRedisConstructor {
+  new (port: number, host?: string, options?: ClientOpts): Promisified;
+  new (unix_socket: string, options?: ClientOpts): Promisified;
+  new (redis_url: string, options?: ClientOpts): Promisified;
+  new (options?: ClientOpts): Promisified;
+
+  createClient(port: number, host?: string, options?: ClientOpts): Promisified;
+  createClient(unix_socket: string, options?: ClientOpts): Promisified;
+  createClient(redis_url: string, options?: ClientOpts): Promisified;
+  createClient(options?: ClientOpts): Promisified;
+
+  decorate: (client: RedisClient) => Promisified;
+}
+
+interface AsyncRedisEventHandlers extends EventEmitter {
+  on(event: 'message' | 'message_buffer', listener: (channel: string, message: string) => void): this;
+  on(event: 'pmessage' | 'pmessage_buffer', listener: (pattern: string, channel: string, message: string) => void): this;
+  on(event: 'subscribe' | 'unsubscribe', listener: (channel: string, count: number) => void): this;
+  on(event: 'psubscribe' | 'punsubscribe', listener: (pattern: string, count: number) => void): this;
+  on(event: string, listener: (...args: any[]) => void): this;
+}
+
+interface AsyncRedisCommands<R> {
+  /**
+   * Listen for all requests received by the server in real time.
+   */
+  monitor(cb?: Callback<undefined>): any;
+  MONITOR(cb?: Callback<undefined>): any;
+
+  /**
+   * Get information and statistics about the server.
+   */
+  info(): Promise<ServerInfo|boolean>;
+  info(section?: string | string[]): Promise<ServerInfo|boolean>;
+  INFO(): Promise<ServerInfo|boolean>;
+  INFO(section?: string | string[]): Promise<ServerInfo|boolean>;
+
+  /**
+   * Ping the server.
+   */
+  ping(): Promise<string|boolean>;
+  ping(message: string): Promise<string|boolean>;
+  PING(): Promise<string|boolean>;
+  PING(message: string): Promise<string|boolean>;
+
+  /**
+   * Authenticate to the server.
+   */
+  auth(password: string): Promise<string>;
+  AUTH(password: string): Promise<string>;
+
+  /**
+   * Get array of Redis command details.
+   *
+   * COUNT - Get total number of Redis commands.
+   * GETKEYS - Extract keys given a full Redis command.
+   * INFO - Get array of specific REdis command details.
+   */
+  command(cb?: Callback<Array<[string, number, string[], number, number, number]>>): R;
+  COMMAND(cb?: Callback<Array<[string, number, string[], number, number, number]>>): R;
+
+  /**
+   * Get array of Redis command details.
+   *
+   * COUNT - Get array of Redis command details.
+   * GETKEYS - Extract keys given a full Redis command.
+   * INFO - Get array of specific Redis command details.
+   * GET - Get the value of a configuration parameter.
+   * REWRITE - Rewrite the configuration file with the in memory configuration.
+   * SET - Set a configuration parameter to the given value.
+   * RESETSTAT - Reset the stats returned by INFO.
+   */
+  config: OverloadedCommand<string, boolean>;
+  CONFIG: OverloadedCommand<string, boolean>;
+
+  /**
+   * Return the number of keys in the selected database.
+   */
+  dbsize(): Promise<number>;
+  DBSIZE(): Promise<number>;
+
+  /**
+   * OBJECT - Get debugging information about a key.
+   * SEGFAULT - Make the server crash.
+   */
+  debug: OverloadedCommand<string, boolean>;
+  DEBUG: OverloadedCommand<string, boolean>;
+
+  /**
+   * PubSub Commands
+   */
+  /**
+   * Post a message to a channel.
+   */
+  publish(channel: string, value: string): Promise<number|boolean>;
+  PUBLISH(channel: string, value: string): Promise<number|boolean>;
+
+  /**
+   * CRUD Commands
+   */
+
+  /**
+   * Append a value to a key.
+   */
+  append(key: string, value: string): Promise<number>;
+  APPEND(key: string, value: string): Promise<number>;
+
+  /**
+   * Asynchronously rewrite the append-only file.
+   */
+  bgrewriteaof(): Promise<OkOrError>;
+  BGREWRITEAOF(): Promise<OkOrError>;
+
+  /**
+   * Asynchronously save the dataset to disk.
+   */
+  bgsave(): Promise<OkOrError>;
+  BGSAVE(): Promise<OkOrError>;
+
+  /**
+   * Determine if a key exists.
+   */
+  exists: OverloadedCommand<string, R>;
+  EXISTS: OverloadedCommand<string, R>;
+
+  /**
+   * Set the string value of a key.
+   */
+  set(key: string, value: string): Promise<string|boolean>;
+  set(key: string, value: string, flag: string): Promise<string|boolean>;
+  set(key: string, value: string, mode: string, duration: number): Promise<string|undefined>;
+  set(key: string, value: string, mode: string, duration: number, flag: string): Promise<string|undefined>;
+  SET(key: string, value: string): Promise<string|boolean>;
+  SET(key: string, value: string, flag: string): Promise<string|boolean>;
+  SET(key: string, value: string, mode: string, duration: number): Promise<string|undefined>;
+  SET(key: string, value: string, mode: string, duration: number, flag: string): Promise<string|undefined>;
+}
+
+interface AsyncRedisInterface extends AsyncRedisConstructor, AsyncRedisEventHandlers, AsyncRedisCommands<boolean> {}
+declare const AsyncRedis: AsyncRedisInterface;
+export = AsyncRedis;

src/index.js

@@ -1,47 +1,49 @@
 const redis = require('redis');
-const commands = require('redis-commands').list;
 const objectDecorator = require('./object-decorator');
+const objectPromisify = require('./object-promisify');
+const redisCommands = require('./redis-commands');
 
-const AsyncRedis = function (args) {
-  const client = Array.isArray(args) ? redis.createClient(...args) : redis.createClient(args);
-  return AsyncRedis.decorate(client);
-};
-
-AsyncRedis.createClient = (...args) => new AsyncRedis(args);
+const redisClients = new Map();
 
-const commandsToSkipSet = new Set(['multi']);
-const commandSet = new Set(commands.filter(c => !commandsToSkipSet.has(c)));
-const queueCommandSet = new Set(['batch', 'multi']);
-const multiCommandSet = new Set(['exec', 'exec_atomic']);
+/**
+ * @return RedisClient
+ */
+const AsyncRedis = function (args=null) {
+  if (args) {
+    const serializedArgs = JSON.stringify(args);
+    if (!redisClients.has(serializedArgs)) {
+      redisClients.set(serializedArgs, Array.isArray(args) ? redis.createClient(...args) : redis.createClient(args));
+    }
+    this.setup(redisClients.get(serializedArgs));
+  }
+};
 
-const promisify = function (object, method) {
-  return (...args) => new Promise((resolve, reject) => {
-    args.push((error, ...results) => {
-      if (error) {
-        reject(error, ...results);
-      } else {
-        resolve(...results);
+AsyncRedis.prototype.setup = function(redisClient) {
+  this.__redisClient = redisClient;
+  const commandConfigs = redisCommands(redisClient);
+  objectDecorator(redisClient, (name, method) => {
+    if (commandConfigs.commands.has(name)) {
+      objectPromisify(this, redisClient, name);
+    } else if (commandConfigs.queueCommands.has(name)) {
+      return (...args) => {
+        const multi = method.apply(redisClient, args);
+        return objectDecorator(multi, (multiName, multiMethod) => {
+          if (commandConfigs.multiCommands.has(multiName)) {
+            return objectPromisify(multi, multiMethod);
+          }
+          return multiMethod;
+        });
       }
-    });
-    method.apply(object, args);
+    }
   });
 };
 
-AsyncRedis.decorate = redisClient => objectDecorator(redisClient, (name, method) => {
-  if (commandSet.has(name)) {
-    return promisify(redisClient, method);
-  } else if (queueCommandSet.has(name)) {
-    return (...args) => {
-      const multi = method.apply(redisClient, args);
-      return objectDecorator(multi, (multiName, multiMethod) => {
-        if (multiCommandSet.has(multiName)) {
-          return promisify(multi, multiMethod);
-        }
-        return multiMethod;
-      });
-    }
-  }
-  return method;
-});
+AsyncRedis.createClient = (...args) => new AsyncRedis(args);
+
+AsyncRedis.decorate = (redisClient) => {
+  const asyncClient = new AsyncRedis();
+  asyncClient.setup(redisClient);
+  return asyncClient;
+};
 
 module.exports = AsyncRedis;

src/object-decorator.js

@@ -4,12 +4,13 @@
  * @returns {*}
  */
 module.exports = (object, decorator) => {
-  /* eslint-disable */
   for (const prop in object) {
     if (typeof object[prop] === 'function') {
-      object[prop] = decorator(prop, object[prop]);
+      const returned = decorator(prop, object[prop]);
+      if (typeof returned === 'function') {
+        object[prop] = returned;
+      }
     }
   }
-  /* eslint-enable */
   return object;
 };

src/object-promisify.js

@@ -0,0 +1,20 @@
+/**
+ * @param proxy
+ * @param object
+ * @param name
+ * @returns void
+ */
+module.exports = (proxy, object, name) => {
+  proxy[name] = (...args) => {
+    return new Promise((resolve, reject) => {
+      args.push((error, ...results) => {
+        if (error) {
+          reject(error, ...results);
+        } else {
+          resolve(...results);
+        }
+      });
+      object[name](...args);
+    });
+  };
+};

src/redis-commands.js

@@ -0,0 +1,21 @@
+const commandsToSkipSet = new Set(['multi']);
+const queueCommands = new Set(['batch', 'multi']);
+const multiCommands = new Set(['exec', 'exec_atomic']);
+
+/**
+ * @param redisClient
+ * @returns {{queueCommands: Set<string>, multiCommands: Set<string>, commands: Set<any>}}
+ */
+module.exports = (redisClient) => {
+  const commands = [];
+  for (const prop in redisClient) {
+    if (typeof redisClient[prop] === 'function') {
+      commands.push(prop);
+    }
+  }
+  return {
+    commands: new Set(commands.filter(c => !commandsToSkipSet.has(c))),
+    queueCommands,
+    multiCommands,
+  }
+};