isaacgr/jaysonic

const EventEmitter = require("events");
const JsonRpcClientProtocol = require("./protocol/base");

/**
 * Creates an instance of JsonRpcClientFactory. This is the base factory which
 * all other factories inherit from.
 *
 * @extends EventEmitter
 * @requires events
 */
class JsonRpcClientFactory extends EventEmitter {
  /**
   * @inheritdoc
   * @param {Object} options Connection options for the factory class
   * @param {string} [options.host="127.0.0.1"] IP of server to connect to
   * @param {number} [options.port=8100] Port of server to connect to
   * @param {number} [options.version=2] JSON-RPC version to use (1|2)
   * @param {string} [options.delimiter="\n"] Delimiter to use for requests
   * @param {number} [options.timeout=30] Timeout for request response
   * @param {number} [options.connectionTimeout=5000] Timeout for connection to server
   * @param {number} [options.retries=2] Number of connection retry attempts
   * @property {Object} protocol  Instance of [JsonRpcClientProtocol]{@link JsonRpcClientProtocol} to use for managing client connections
   * @property {class} pcolInstance The [JsonRpcClientProtocol]{@link JsonRpcClientProtocol} instance
   * @property {object} timeouts Key value pairs of request IDs to `setTimeout` instance
   * @property {number} requestTimeout Same as `options.timeout`
   * @property {number} remainingRetries Same as `options.retries`
   * @property {number} connectionTimeout Same as `options.connectionTimeout`
   * @property {object} server Object of host and port `{host: options.host, port: options.port}`
   */
  constructor(options) {
    super();
    if (!(this instanceof JsonRpcClientFactory)) {
      return new JsonRpcClientFactory(options);
    }

    const defaults = {
      host: "127.0.0.1",
      port: 8100,
      version: 2,
      delimiter: "\n",
      timeout: 30,
      connectionTimeout: 5000,
      retries: 2
    };

    this.options = {
      ...defaults,
      ...(options || {})
    };
    this.protocol = JsonRpcClientProtocol;
    this.pcolInstance = undefined;
    this.timeouts = {};
    this.requestTimeout = this.options.timeout * 1000;
    this.remainingRetries = this.options.retries;
    this.connectionTimeout = this.options.connectionTimeout;

    this.server = { host: this.options.host, port: this.options.port };
  }

  /**
   * Set the `pcolInstance` for the client factory
   *
   * @abstract
   * @example
   * this.pcolInstance = new JsonRpcClientProtocol()
   */
  buildProtocol() {
    throw new Error("function must be overwritten in subclass");
  }

  /**
   * Calls `buildProtocol` method.
   *
   * Calls `connect()` on protocol instance
   *
   */
  connect() {
    if (this.pcolInstance) {
      // not having this caused MaxEventListeners error
      return Promise.reject(Error("client already connected"));
    }
    this.buildProtocol();
    return this.pcolInstance.connect();
  }

  /**
   * Calls `end()` on protocol instance
   *
   * @abstract
   */
  end() {
    throw new Error("function must be overwritten in subclass");
  }

  /**
   * Subscribe the function to the given event name
   *
   * @param {string} method Method name to subscribe to
   * @param {function} cb  Name of callback function to invoke on event
   * @abstract
   */
  subscribe() {
    throw new Error("function must be overwritten in subsclass");
  }

  /**
   * Unsubscribe the function from the given event name
   *
   * @param {string} method Method to unsubscribe from
   * @param {function} cb Name of function to remove
   * @abstract
   */
  unsubscribe() {
    throw new Error("function must be overwritten in subsclass");
  }

  /**
   * Unsubscribe all functions from given event name
   *
   * @param {string} method Method to unsubscribe all listeners from
   * @abstract
   */
  unsubscribeAll() {
    throw new Error("function must be overwritten in subsclass");
  }

  /**
   * Calls `message()` on the protocol instance
   *
   * @param {string} method Name of the method to use in the request
   * @param {Array|JSON} params Params to send
   * @param {boolean=} id If true it will use instances `message_id` for the request id, if false will generate a notification request
   * @example
   * client.message("hello", ["world"]) // returns {"jsonrpc": "2.0", "method": "hello", "params": ["world"], "id": 1}
   * client.message("hello", ["world"], false) // returns {"jsonrpc": "2.0", "method": "hello", "params": ["world"]}
   */
  message(method, params, id) {
    return this.pcolInstance.message(method, params, id);
  }

  /**
   * Calls `send()` method on protocol instance
   *
   * Promise will resolve when a response has been received for the request.
   *
   * Promise will reject if the server responds with an error object, or if
   * the response is not received within the set `requestTimeout`
   *
   * @param {string} method Name of the method to use in the request
   * @param {Array|JSON} params Params to send
   * @returns Promise
   * @example
   * client.send("hello", {"foo": "bar"})
   */
  send(method, params) {
    return this.pcolInstance.send(method, params);
  }

  /**
   * Calls `notify()` method on protocol instance
   *
   * Promise will resolve if the request was sucessfully sent, and reject if
   * there was an error sending the request.
   *
   * @param {string} method Name of the method to use in the notification
   * @param {Array|JSON} params Params to send
   * @return Promise
   * @example
   * client.notify("hello", ["world"])
   */
  notify(method, params) {
    return this.pcolInstance.notify(method, params);
  }

  /**
   * Calls `request()` method on protocol instance
   *
   * Plans to deprecate this in future versions.
   */
  request() {
    return this.pcolInstance.request();
  }

  /**
   * Calls `batch()` method on protocol instance
   *
   * @param {JSON[]} requests Valid JSON-RPC batch request array
   */
  batch(requests) {
    return this.pcolInstance.batch(requests);
  }

  /**
   * Listens for a `serverDisconnected` event, passing the callback function
   *
   * @param {function} cb
   */
  serverDisconnected(cb) {
    this.on("serverDisconnected", cb);
  }

  /**
   * Clears pending timeouts kept in `timeouts` property for the provided request IDs.
   *
   * @param {string[]|number[]} ids Array of request IDs
   */
  cleanUp(ids) {
    clearTimeout(this.timeouts[ids]);
    delete this.timeouts[ids];
  }
}
module.exports = JsonRpcClientFactory;

/**
 * TCP client constructor
 * @type TcpClientFactory
 * @static
 */
JsonRpcClientFactory.tcp = require("./tcp");

/**
 * HTTP client constructor
 * @type HttpClientFactory
 * @static
 */
JsonRpcClientFactory.http = require("./http");

/**
 * WebSocket client constructor
 * @type WsClientFactory
 * @static
 */
JsonRpcClientFactory.ws = require("./ws");