@collectionspace/cspace-public-browser/lib/helpers/esQueryHelpers.js

CollectionSpace public browser

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.termFilterParamToQuery = exports.histogramFilterParamToQuery = exports.getTermsAgg = exports.getSort = exports.getSearchResultPayload = exports.getSearchQuery = exports.getQuery = exports.getHistogramAgg = exports.getFilterQueries = exports.getFilterAgg = exports.getAggs = exports.fulltextParamToQuery = exports.filterParamToQuery = void 0;
var _config = _interopRequireDefault(require("../config"));
var _ids = require("../constants/ids");
function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
const fulltextParamToQuery = value => {
  if (!value) {
    return undefined;
  }
  const fulltextSearchFields = _config.default.get('fulltextSearchFields');
  return {
    bool: {
      should: [{
        multi_match: {
          query: value,
          fields: fulltextSearchFields,
          type: 'cross_fields',
          operator: 'and'
        }
      }, {
        multi_match: {
          query: value,
          fields: fulltextSearchFields,
          type: 'phrase_prefix',
          operator: 'and'
        }
      }],
      minimum_should_match: '1'
    }
  };
};
exports.fulltextParamToQuery = fulltextParamToQuery;
const termFilterParamToQuery = (field, value) => ({
  terms: {
    [field]: value.toJS()
  }
});
exports.termFilterParamToQuery = termFilterParamToQuery;
const histogramFilterParamToQuery = (field, value, interval) => {
  const clauses = value.map(v => ({
    range: {
      [field]: {
        gte: v,
        lt: v + interval
      }
    }
  })).toJS();
  if (clauses.length === 1) {
    return clauses[0];
  }
  return {
    bool: {
      should: clauses
    }
  };
};
exports.histogramFilterParamToQuery = histogramFilterParamToQuery;
const filterParamToQuery = (id, value) => {
  const filterFieldConfig = _config.default.getFilterFieldConfig(id);
  if (!filterFieldConfig) {
    return undefined;
  }
  const {
    field,
    type
  } = filterFieldConfig;
  if (type === 'histogram') {
    return histogramFilterParamToQuery(field, value, filterFieldConfig.interval);
  }
  return termFilterParamToQuery(field, value);
};
exports.filterParamToQuery = filterParamToQuery;
const getSearchQuery = params => fulltextParamToQuery(params.get(_ids.SEARCH_QUERY_ID));
exports.getSearchQuery = getSearchQuery;
const getFilterQueries = params => params.delete(_ids.SEARCH_QUERY_ID).entrySeq().map(([id, value]) => filterParamToQuery(id, value)).toJS();
exports.getFilterQueries = getFilterQueries;
const getQuery = params => {
  const clauses = [_config.default.get('defaultQuery'), getSearchQuery(params), ...getFilterQueries(params)].filter(clause => !!clause);
  if (clauses.length > 1) {
    return {
      bool: {
        must: clauses
      }
    };
  }
  if (clauses.length > 0) {
    return clauses[0];
  }
  return {
    match_all: {}
  };
};
exports.getQuery = getQuery;
const getHistogramAgg = (field, interval = 1) => ({
  histogram: {
    field,
    interval,
    min_doc_count: 1
  }
});
exports.getHistogramAgg = getHistogramAgg;
const getTermsAgg = (field, order = _config.default.get('filterOrder'), size = _config.default.get('filterSize')) => ({
  terms: {
    field,
    order,
    size
  }
});
exports.getTermsAgg = getTermsAgg;
const getFilterAgg = filterFieldConfig => {
  const {
    field,
    order,
    size,
    type
  } = filterFieldConfig;
  if (type === 'histogram') {
    return getHistogramAgg(field, filterFieldConfig.interval);
  }
  return getTermsAgg(field, order, size);
};
exports.getFilterAgg = getFilterAgg;
let aggs;
const getAggs = params => {
  if (!aggs) {
    aggs = {};
    const filterFieldsConfig = _config.default.get('filters').fields;
    Object.entries(filterFieldsConfig).forEach(([id, filterFieldConfig]) => {
      const param = params.get(id);
      const hasValue = param && param.size > 0;
      if (!hasValue) {
        aggs[id] = getFilterAgg(filterFieldConfig);
      }
    });
  }
  return aggs;
};
exports.getAggs = getAggs;
const getSort = params => {
  const sortOrder = params.get(_ids.SORT_ID) || _config.default.get('defaultSortOrder');
  const effectiveSortOrder = sortOrder === 'bestmatch' && params.delete(_ids.SORT_ID).isEmpty() ? 'newest' : sortOrder;
  switch (effectiveSortOrder) {
    case 'bestmatch':
      return [{
        _score: {
          order: 'desc'
        }
      }, {
        [_config.default.get('sortField')]: {
          order: 'asc'
        }
      }];
    case 'atoz':
      return {
        [_config.default.get('sortField')]: {
          order: 'asc'
        }
      };
    case 'ztoa':
      return {
        [_config.default.get('sortField')]: {
          order: 'desc'
        }
      };
    case 'newest':
      return {
        'collectionspace_core:createdAt': {
          order: 'desc'
        }
      };
    case 'oldest':
      return {
        'collectionspace_core:createdAt': {
          order: 'asc'
        }
      };
    default:
      return {};
  }
};
exports.getSort = getSort;
const getSearchResultPayload = (params, pageSize, offset) => ({
  query: getQuery(params.delete(_ids.SORT_ID)),
  from: offset,
  size: pageSize,
  _source: {
    includes: _config.default.get('includeFields')
  },
  sort: getSort(params)
});
exports.getSearchResultPayload = getSearchResultPayload;