deep-search/lib.compiled/Search.js

DEEP Search Library

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

'use strict';

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

var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();

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 }; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }

function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }

/**
 * Deep Search implementation
 */
let Search = exports.Search = function (_Kernel$ContainerAwar) {
  _inherits(Search, _Kernel$ContainerAwar);

  /**
   * @param {Object} domains
   *
   * @example domains = {
   *  rum: {
   *    type: 'es|cloudsearch',
   *    name: '<DomainName>',
   *    url: '<DomainUrl>'
   *  },
   *  ...
   * }
   */
  function Search(domains) {
    _classCallCheck(this, Search);

    var _this = _possibleConstructorReturn(this, (Search.__proto__ || Object.getPrototypeOf(Search)).call(this));

    _this._domains = domains;
    _this._domainClients = [];
    return _this;
  }

  /**
   * @param {Kernel} kernel
   * @param {Function} callback
   */


  _createClass(Search, [{
    key: 'boot',
    value: function boot(kernel, callback) {
      this._domains = kernel.config.searchDomains || {};

      callback();
    }

    /**
     * @param {String|Function} domainName
     * @param {Function} callback
     */

  }, {
    key: 'getClient',
    value: function 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
     */

  }, {
    key: '_createClient',
    value: function _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}
     */

  }, {
    key: 'clientDecorator',
    get: function get() {
      let func = null;

      if (this.kernel && this.kernel.isRumEnabled) {
        func = function func(instance, originalFunctionName) {
          for (var _len = arguments.length, args = Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
            args[_key - 2] = arguments[_key];
          }

          // 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] = function () {
                var _originalCallback;

                for (var _len2 = arguments.length, cbArgs = Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
                  cbArgs[_key2] = arguments[_key2];
                }

                // RUM log ...

                (_originalCallback = originalCallback).call.apply(_originalCallback, [instance].concat(cbArgs));
              };
            }
          });

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

      return func;
    }
  }]);

  return Search;
}(_deepKernel2.default.ContainerAware);