Feature generic query builder

.travis.yml

@@ -4,8 +4,6 @@ node_js:
   - '5.11'
   - '4.4'
   - '4.2'
-  - '0.12'
-  - '0.10'
 branches:
   only:
   - master

package.json

@@ -17,6 +17,7 @@
     "lint": "eslint src test",
     "style": "npm run lint",
     "test": "mocha --require babel-core/register --recursive test",
+    "test-bb": "babel-tape-runner test/body-builder.js | tap-spec",
     "watch:test": "mocha --watch --require babel-core/register --recursive test",
     "check": "npm run lint && npm test",
     "preversion": "npm run check && npm run build"
@@ -34,10 +35,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/aggregation-builder.js

@@ -0,0 +1,52 @@
+import _ from 'lodash'
+import { buildAggregation } from './utils'
+import filterBuilder from './filter-builder'
+
+export default function aggregationBuilder () {
+  let aggregations = {}
+
+  function makeAggregation (type, field, ...args) {
+    const aggName = _.find(args, _.isString) || `agg_${type}_${field}`
+    const opts = _.find(args, _.isPlainObject) || {}
+    const nested = _.find(args, _.isFunction)
+    const nestedClause = {}
+
+    if (_.isFunction(nested)) {
+      const nestedResult = nested(Object.assign(
+        {},
+        aggregationBuilder(),
+        filterBuilder()
+      ))
+      if (nestedResult.hasFilter()) {
+        nestedClause.filter = nestedResult.getFilter()
+      }
+      if (nestedResult.hasAggregations()) {
+        nestedClause.aggs = nestedResult.getAggregations()
+      }
+    }
+
+    Object.assign(
+      aggregations,
+      {[aggName]: Object.assign(
+        buildAggregation(type, field, opts),
+        nestedClause
+      )}
+    )
+  }
+
+  return {
+    aggregation (...args) {
+      makeAggregation(...args)
+      return this
+    },
+    agg (...args) {
+      return this.aggregation(...args)
+    },
+    getAggregations () {
+      return aggregations
+    },
+    hasAggregations () {
+      return !!_.size(aggregations)
+    }
+  }
+}

src/body-builder.js

@@ -0,0 +1,137 @@
+import _ from 'lodash'
+import queryBuilder from './query-builder'
+import filterBuilder from './filter-builder'
+import aggregationBuilder from './aggregation-builder'
+import { sortMerge } from './utils'
+
+export default function bodyBuilder () {
+  let body = {}
+
+  return Object.assign(
+    {
+      /**
+       * Set a sort direction on a given field.
+       *
+       * @param  {String} field             Field name.
+       * @param  {String} [direction='asc'] A valid direction: 'asc' or 'desc'.
+       * @returns {Bodybuilder} Builder class.
+       */
+      sort(field, direction = 'asc') {
+        body.sort = body.sort || []
+
+        if (_.isArray(field)) {
+
+            if(_.isPlainObject(body.sort)) {
+                body.sort = [body.sort]
+            }
+
+            if(_.isArray(body.sort)) {
+                _.each(field, (sorts) => {
+                    _.each(sorts, (value, key) => {
+                        sortMerge(body.sort, key, value)
+                    })
+                })
+            }
+        } else {
+          sortMerge(body.sort, field, direction)
+        }
+        return this
+      },
+
+      /**
+       * Set a *from* offset value, for paginating a query.
+       *
+       * @param  {Number} quantity The offset from the first result you want to
+       *                           fetch.
+       * @returns {Bodybuilder} Builder class.
+       */
+      from(quantity) {
+        body.from = quantity
+        return this
+      },
+
+      /**
+       * Set a *size* value for maximum results to return.
+       *
+       * @param  {Number} quantity Maximum number of results to return.
+       * @returns {Bodybuilder} Builder class.
+       */
+      size(quantity) {
+        body.size = quantity
+        return this
+      },
+
+      /**
+       * Set any key-value on the elasticsearch body.
+       *
+       * @param  {String} k Key.
+       * @param  {String} v Value.
+       * @returns {Bodybuilder} Builder class.
+       */
+      rawOption(k, v) {
+        body[k] = v
+        return this
+      },
+
+      build(version) {
+        const queries = this.getQuery()
+        const filters = this.getFilter()
+        const aggregations = this.getAggregations()
+
+        if (version === 'v2') {
+          return _buildV2(body, queries, filters, aggregations)
+        }
+
+        return _buildV1(body, queries, filters, aggregations)
+      }
+
+    },
+    queryBuilder(),
+    filterBuilder(),
+    aggregationBuilder()
+  )
+}
+
+function _buildV1(body, queries, filters, aggregations) {
+  let clonedBody = _.cloneDeep(body)
+
+  if (!_.isEmpty(filters)) {
+    _.set(clonedBody, 'query.filtered.filter', filters)
+
+    if (!_.isEmpty(queries)) {
+      _.set(clonedBody, 'query.filtered.query', queries)
+    }
+
+  } else if (!_.isEmpty(queries)) {
+    _.set(clonedBody, 'query', queries)
+  }
+
+  if (!_.isEmpty(aggregations)) {
+    _.set(clonedBody, 'aggregations', aggregations)
+  }
+  return clonedBody
+}
+
+function _buildV2(body, queries, filters, aggregations) {
+  let clonedBody = _.cloneDeep(body)
+
+  if (!_.isEmpty(filters)) {
+    let filterBody = {}
+    let queryBody = {}
+    _.set(filterBody, 'query.bool.filter', filters)
+    if (!_.isEmpty(queries.bool)) {
+      _.set(queryBody, 'query.bool', queries.bool)
+    } else if (!_.isEmpty(queries)) {
+      _.set(queryBody, 'query.bool.must', queries)
+    }
+    _.merge(clonedBody, filterBody, queryBody)
+  } else if (!_.isEmpty(queries)) {
+    _.set(clonedBody, 'query', queries)
+  }
+
+  if (!_.isEmpty(aggregations)) {
+    _.set(clonedBody, 'aggs', aggregations)
+  }
+
+  return clonedBody
+}

src/filter-builder.js

@@ -0,0 +1,65 @@
+import _ from 'lodash'
+import { boolMerge, buildClause } from './utils'
+import queryBuilder from './query-builder'
+import aggregationBuilder from './aggregation-builder'
+
+export default function filterBuilder () {
+  let filter = {}
+
+  function makeFilter (boolType, filterType, ...args) {
+    const nested = {}
+    if (_.isFunction(_.last(args))) {
+      const nestedCallback = args.pop()
+      const nestedResult = nestedCallback(
+        Object.assign(
+          {},
+          queryBuilder(),
+          filterBuilder(),
+          aggregationBuilder()
+        )
+      )
+      if (nestedResult.hasQuery()) {
+        nested.query = nestedResult.getQuery()
+      }
+      if (nestedResult.hasFilter()) {
+        nested.filter = nestedResult.getFilter()
+      }
+      if (nestedResult.hasAggregations()) {
+        nested.aggs = nestedResult.getAggregations()
+      }
+    }
+
+    filter = boolMerge(
+      {[filterType]: Object.assign(buildClause(...args), nested)},
+      filter,
+      boolType
+    )
+  }
+
+  return {
+    filter (...args) {
+      makeFilter('and', ...args)
+      return this
+    },
+    andFilter (...args) {
+      return this.filter(...args)
+    },
+    addFilter (...args) {
+      return this.filter(...args)
+    },
+    orFilter (...args) {
+      makeFilter('or', ...args)
+      return this
+    },
+    notFilter (...args) {
+      makeFilter('not', ...args)
+      return this
+    },
+    getFilter () {
+      return filter
+    },
+    hasFilter () {
+      return !!_.size(filter)
+    }
+  }
+}

src/query-builder.js

@@ -0,0 +1,60 @@
+import _ from 'lodash'
+import { boolMerge, buildClause } from './utils'
+import filterBuilder from './filter-builder'
+
+export default function queryBuilder () {
+  let query = {}
+
+  function makeQuery (boolType, queryType, ...args) {
+    const nested = {}
+    if (_.isFunction(_.last(args))) {
+      const nestedCallback = args.pop()
+      const nestedResult = nestedCallback(
+        Object.assign(
+          {},
+          queryBuilder(),
+          filterBuilder()
+        )
+      )
+      if (nestedResult.hasQuery()) {
+        nested.query = nestedResult.getQuery()
+      }
+      if (nestedResult.hasFilter()) {
+        nested.filter = nestedResult.getFilter()
+      }
+    }
+
+    query = boolMerge(
+      {[queryType]: Object.assign(buildClause(...args), nested)},
+      query,
+      boolType
+    )
+  }
+
+  return {
+    query (...args) {
+      makeQuery('and', ...args)
+      return this
+    },
+    andQuery (...args) {
+      return this.query(...args)
+    },
+    addQuery (...args) {
+      return this.query(...args)
+    },
+    orQuery (...args) {
+      makeQuery('or', ...args)
+      return this
+    },
+    notQuery (...args) {
+      makeQuery('not', ...args)
+      return this
+    },
+    getQuery () {
+      return query
+    },
+    hasQuery () {
+      return !!_.size(query)
+    }
+  }
+}

src/utils.js

@@ -10,10 +10,8 @@ import queries from './queries'
  * @param {Object} target Target.
  * @returns {Object} Merged object.
  */
-export function mergeConcat(target) {
-  let args = Array.prototype.slice.call(arguments, 1)
-
-  args.unshift(target)
+export function mergeConcat() {
+  let args = Array.prototype.slice.call(arguments, 0)
   args.push(function customizer(a, b) {
     if (_.isPlainObject(a)) {
       return _.assignWith(a, b, customizer)
@@ -80,4 +78,34 @@ export function sortMerge(current, field, direction) {
   }
 
   return current
-}
+}
+
+/**
+ * Generic builder for filter and query clauses
+ *
+ * @private
+ *
+ * @param  {string} field Field name.
+ * @param  {any}    value Field value.
+ * @param  {Object} opts  Additional key-value pairs.
+ * @return {Object}       query clause component
+ */
+export function buildClause (field, value, opts) {
+  const clause = {}
+
+  if (field && value && opts) {
+    Object.assign(clause, opts, {[field]: value})
+  } else if (field && value) {
+    clause[field] = value
+  } else if (field) {
+    clause.field = field
+  }
+
+  return clause
+}
+
+export function buildAggregation (type, field, opts) {
+  return {
+    [type]: Object.assign({field}, opts)
+  }
+}