deep-search/lib.es6/Search.js

DEEP Search Library

/**
 * Created by mgoria on 3/4/16.
 */

'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.Search = undefined;

var _deepKernel = require('deep-kernel');

var _deepKernel2 = _interopRequireDefault(_deepKernel);

var _deepCore = require('deep-core');

var _deepCore2 = _interopRequireDefault(_deepCore);

var _Elasticsearch = require('./Client/Elasticsearch');

var _UnknownSearchDomainException = require('./Exception/UnknownSearchDomainException');

var _MissingSearchClientException = require('./Exception/MissingSearchClientException');

var _NotReadySearchDomainException = require('./Exception/NotReadySearchDomainException');

var _util = require('util');

var _util2 = _interopRequireDefault(_util);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

/**
 * Deep Search implementation
 */
class Search extends _deepKernel2.default.ContainerAware {
  /**
   * @param {Object} domains
   *
   * @example domains = {
   *  rum: {
   *    type: 'es|cloudsearch',
   *    name: '<DomainName>',
   *    url: '<DomainUrl>'
   *  },
   *  ...
   * }
   */
  constructor(domains) {
    super();

    this._domains = domains;
    this._domainClients = [];
  }

  /**
   * @param {Kernel} kernel
   * @param {Function} callback
   */
  boot(kernel, callback) {
    this._domains = kernel.config.searchDomains || {};

    callback();
  }

  /**
   * @param {String|Function} domainName
   * @param {Function} callback
   */
  getClient(domainName, callback) {
    // use 'client' as default domainName
    if (typeof domainName === 'function') {
      callback = domainName;
      domainName = 'client';
    }

    if (this._domainClients.indexOf(domainName) !== -1) {
      callback(null, this._domainClients[domainName]);
      return;
    }

    this._createClient(domainName, (error, client) => {
      if (!error) {
        this._domainClients[domainName] = client;
      }

      callback(error, client);
    });
  }

  /**
   * @param {String} domainName
   * @param {Function} callback
   * @private
   */
  _createClient(domainName, callback) {
    if (!this._domains.hasOwnProperty(domainName)) {
      callback(new _UnknownSearchDomainException.UnknownSearchDomainException(domainName, Object.keys(this._domains)));
      return;
    }

    let domainConfig = this._domains[domainName];

    this.kernel.loadAsyncConfig(asyncConfig => {
      if (asyncConfig && asyncConfig.searchDomains && asyncConfig.searchDomains.hasOwnProperty(domainName)) {
        let client = null;
        domainConfig = _util2.default._extend(domainConfig, asyncConfig.searchDomains[domainName]);

        if (!domainConfig.hasOwnProperty('url')) {
          callback(new _NotReadySearchDomainException.NotReadySearchDomainException(domainConfig.name, domainConfig.type));
          return;
        }

        if (domainConfig.type === _deepCore2.default.AWS.Service.ELASTIC_SEARCH) {
          client = new _Elasticsearch.Elasticsearch(domainConfig.url, this.clientDecorator, !this.localBackend, domainConfig.version);
        }

        if (!client) {
          callback(new _MissingSearchClientException.MissingSearchClientException(domainConfig.name, domainConfig.type));
          return;
        }

        callback(null, client);
      } else {
        callback(new _NotReadySearchDomainException.NotReadySearchDomainException(domainConfig.name, domainConfig.type));
      }
    });
  }

  /**
   * @returns {Function}
   */
  get clientDecorator() {
    let func = null;

    if (this.kernel && this.kernel.isRumEnabled) {
      func = function (instance, originalFunctionName, ...args) {
        // RUM log ...

        let originalCallback = null;

        // seeking the callback function through the arguments and proxy it
        args.forEach((arg, index) => {
          if (typeof arg === 'function') {
            originalCallback = arg;

            args[index] = (...cbArgs) => {
              // RUM log ...

              originalCallback.call(instance, ...cbArgs);
            };
          }
        });

        instance[originalFunctionName](...args);
      };
    }

    return func;
  }
}
exports.Search = Search;