Feature generic query builder

package.json

@@ -34,10 +34,14 @@
     "babel-core": "6.5.1",
     "babel-plugin-lodash": "2.0.1",
     "babel-preset-es2015": "6.5.0",
+    "babel-register": "6.18.0",
+    "babel-tape-runner": "2.0.1",
     "chai": "3.2.0",
     "documentation": "4.0.0-beta10",
     "eslint": "1.10.2",
     "mocha": "2.4.5",
+    "tap-spec": "4.1.1",
+    "tape": "4.6.2",
     "webpack": "1.12.13"
   },
   "dependencies": {

src/query-builder.js

@@ -0,0 +1,186 @@
+import _ from 'lodash'
+import {boolMerge} from './utils'
+
+/**
+ * QueryBuilder class to build query clauses.
+ *
+ * @private
+ */
+export default class QueryBuilder {
+
+  constructor() {
+    this._queries = {}
+    this._filters = {}
+    this._aggs = {}
+  }
+
+  get queries() {
+    return _.cloneDeep(this._queries)
+  }
+
+  /**
+   * Apply a query of a given type providing all the necessary arguments,
+   * passing these arguments directly to the specified query builder. Merges
+   * existing query(s) with the new query.
+   *
+   * @param  {String}  boolType Name of the query type.
+   * @param  {...args} args     Arguments passed to query builder.
+   * @returns {QueryBuilder}    Builder class.
+   */
+  _makeQuery(boolType, ...args) {
+    let nested = _.last(args)
+
+    let newQuery = this._buildQuery(...args)
+
+    if (_.isFunction(nested)) {
+      let clause = newQuery[_.findKey(newQuery)]
+      let builder = new QueryBuilder()
+      let recursiveResult = nested(builder)
+      if (!_.isEmpty(recursiveResult._aggs)) {clause.aggs = recursiveResult._aggs}
+      if (!_.isEmpty(recursiveResult._queries)) {clause.query = recursiveResult._queries}
+      if (!_.isEmpty(recursiveResult._filters)) {clause.filter = recursiveResult._filters}
+
+      return newQuery
+    }
+
+    return boolMerge(newQuery, this._queries, boolType)
+  }
+
+  _buildQuery(type, field, value, opts) {
+    let clause = {}
+
+    if (field && value && opts) {
+      clause = _.merge({[field]: value}, opts)
+    } else if (field && value) {
+      clause = {[field]: value}
+    } else if (field) {
+      clause = {field}
+    }
+
+    return {[type]: clause}
+  }
+
+  _makeFilter(boolType, ...args) {
+    let nested = _.last(args)
+
+    let newFilter = this._buildFilter(...args)
+
+    if (_.isFunction(nested)) {
+      let clause = newFilter[_.findKey(newFilter)]
+      let builder = new QueryBuilder()
+      let recursiveResult = nested(builder)
+
+      if (!_.isEmpty(recursiveResult._aggs)) {clause.aggs = recursiveResult._aggs}
+      if (!_.isEmpty(recursiveResult._queries)) {clause.query = recursiveResult._queries}
+      if (!_.isEmpty(recursiveResult._filters)) {clause.filter = recursiveResult._filters}
+
+      return newFilter
+    }
+
+    return boolMerge(newFilter, this._filters, boolType)
+  }
+
+  _buildFilter(type, field, value, opts) {
+    let clause = {}
+
+    if (field && value && opts) {
+      clause = _.merge({[field]: value}, opts)
+    } else if (field && value) {
+      clause = {[field]: value}
+    } else if (field) {
+      clause = {field}
+    }
+
+    return {[type]: clause}
+  }
+
+  _makeAggregation(...args) {
+    let nested = _.last(args)
+
+    let newAggregation = this._buildAggregation(...args)
+
+    if (_.isFunction(nested)) {
+      let clause = newAggregation[_.findKey(newAggregation)]
+      let builder = new QueryBuilder()
+      let recursiveResult = nested(builder)
+      if (!_.isEmpty(recursiveResult._aggs)) {clause.aggs = recursiveResult._aggs}
+      if (!_.isEmpty(recursiveResult._queries)) {clause.query = recursiveResult._queries}
+      if (!_.isEmpty(recursiveResult._filters)) {clause.filter = recursiveResult._filters}
+      return newAggregation
+    }
+
+    return newAggregation
+  }
+
+  _buildAggregation(type, field, name, opts) {
+    if (_.isObject(name)) {
+      let tmp = opts
+      opts = name
+      name = tmp
+    }
+
+    name = name || `agg_${type}_${field}`
+
+    return {
+      [name]: {
+        [type]: (() => _.assign({field}, opts))()
+      }
+    }
+  }
+
+  query(...args) {
+    this._queries = this._makeQuery('and', ...args)
+    return this
+  }
+
+  andQuery(...args) {
+    this._queries = this._makeQuery('and', ...args)
+    return this
+  }
+
+  addQuery(...args) {
+    this._queries = this._makeQuery('and', ...args)
+    return this
+  }
+
+  orQuery(...args) {
+    this._queries = this._makeQuery('or', ...args)
+    return this
+  }
+
+  notQuery(...args) {
+    this._queries = this._makeQuery('not', ...args)
+    return this
+  }
+
+  filter(...args) {
+    this._filters = this._makeFilter('and', ...args)
+    return this
+  }
+
+  andFilter(...args) {
+    this._filters = this._makeFilter('and', ...args)
+    return this
+  }
+
+  orFilter(...args) {
+    this._filters = this._makeFilter('or', ...args)
+    return this
+  }
+
+  notFilter(...args) {
+    this._filters = this._makeFilter('not', ...args)
+    return this
+  }
+
+  aggregation(...args) {
+    this._aggs = this._makeAggregation(...args)
+    return this
+  }
+
+  agg(...args) {
+    this._aggs = this.aggregation(...args)
+    return this
+  }
+
+}

test/query-builder.js

@@ -0,0 +1,131 @@
+import test from 'tape'
+import QueryBuilder from '../src/query-builder'
+
+test('QueryBuilder should build query with no field', (t) => {
+  t.plan(1)
+
+  const result = new QueryBuilder().query('match_all')
+
+  t.deepEqual(result._queries, {
+    match_all: {}
+  })
+})
+
+test('QueryBuilder should build query with field but no value', (t) => {
+  t.plan(1)
+
+  const result = new QueryBuilder().query('exists', 'user')
+
+  t.deepEqual(result._queries, {
+    exists: {
+      field: 'user'
+    }
+  })
+})
+
+test('QueryBuilder should build query with field and value', (t) => {
+  t.plan(1)
+
+  const result = new QueryBuilder().query('term', 'user', 'kimchy')
+
+  t.deepEqual(result._queries, {
+    term: {
+      user: 'kimchy'
+    }
+  })
+})
+
+test('QueryBuilder should build query with field and object value', (t) => {
+  t.plan(1)
+
+  const result = new QueryBuilder().query('range', 'date', {gt: 'now-1d'})
+
+  t.deepEqual(result._queries, {
+    range: {
+      date: {gt: 'now-1d'}
+    }
+  })
+})
+
+test('QueryBuilder should build query with more options', (t) => {
+  t.plan(1)
+
+  const result = new QueryBuilder().query('geo_distance', 'point', {lat: 40, lon: 20}, {distance: '12km'})
+
+  t.deepEqual(result._queries, {
+    geo_distance: {
+      distance: '12km',
+      point: {
+        lat: 40,
+        lon: 20
+      }
+    }
+  })
+})
+
+test('QueryBuilder should build nested queries', (t) => {
+  t.plan(1)
+
+  const result = new QueryBuilder().query('nested', 'path', 'obj1', (q) => q.query('match', 'obj1.color', 'blue'))
+
+  t.deepEqual(result._queries, {
+    nested: {
+      path: 'obj1',
+      query: {
+        match: {
+          'obj1.color': 'blue'
+        }
+      }
+    }
+  })
+})
+
+test('QueryBuilder should nest bool-merged queries', (t) => {
+  t.plan(1)
+
+  const result = new QueryBuilder().query('nested', 'path', 'obj1', {score_mode: 'avg'}, (q) => {
+    return q.query('match', 'obj1.name', 'blue').query('range', 'obj1.count', {gt: 5})
+  })
+
+  t.deepEqual(result._queries, {
+    nested: {
+      path: 'obj1',
+      score_mode: 'avg',
+      query: {
+        bool: {
+          must: [
+            {
+              match: {'obj1.name': 'blue'}
+            },
+            {
+              range: {'obj1.count': {gt: 5}}
+            }
+          ]
+        }
+      }
+    }
+  })
+})
+
+test('QueryBuilder should make filter aggregations', (t) => {
+  t.plan(1)
+
+  const result = new QueryBuilder().aggregation('filter', null, 'red_products', (b) => {
+    return b.filter('term', 'color', 'red').aggregation('avg', 'price', 'avg_price')
+  })
+
+  t.deepEqual(result._aggs, {
+    red_products: {
+      filter: {
+        term: {
+          color: 'red'
+        }
+      },
+      aggs: {
+        avg_price: {
+          avg: {field: 'price'}
+        }
+      }
+    }
+  })
+})