Feature/search filters

.eslintrc

@@ -1,8 +1,7 @@
 {
-  "extends": "xo-space",
+  "extends": "xo-space/esnext",
   "rules": {
-    "strict": [2, "global"],
-    "no-var": 1
+    "strict": [2, "global"]
   },
   "ecmaFeatures": {
     "arrowFunctions": true,

.gitignore

@@ -26,3 +26,6 @@ build/Release
 # Dependency directory
 # https://docs.npmjs.com/misc/faq#should-i-check-my-node-modules-folder-into-git
 node_modules
+
+# VS Code config directory
+.vscode

index.js

@@ -1,11 +1,11 @@
 'use strict';
 
-require('./lib/server')(function (err, server) {
+require('./lib/server')((err, server) => {
   if (err) {
     return console.error(err);
   }
 
-  server.start(function (err) {
+  server.start(err => {
     if (err) {
       return console.error(err);
     }

lib/handlers/indexes/{name}.js

@@ -8,7 +8,7 @@ module.exports = {
 
     index.insert(req.payload)
       .then(o => {
-        reply(o).created(req.path + '/' + o.objectID);
+        reply(o).created(`${req.path}/${o.objectID}`);
       }, reply.error.bind(reply));
   }
 };

lib/search/index.js

@@ -0,0 +1,21 @@
+'use strict';
+
+const _ = require('lodash');
+const elasticsearchClient = require('../elasticsearchClient');
+const queryBuilder = require('./query_builder');
+
+const mapResults = function (results) {
+  return _.pluck(results.hits.hits, '_source');
+};
+
+class Search {
+  query(indexName, body) {
+    return elasticsearchClient.search({
+      index: indexName,
+      body: queryBuilder.build(body)
+    })
+    .then(mapResults);
+  }
+}
+
+module.exports = Search;

lib/search/query_builder.js

@@ -0,0 +1,49 @@
+'use strict';
+
+const buildTermFilter = function (filterParams) {
+  // Can't currenlty be a 1 liner due to https://github.com/nodejs/node/issues/2507
+  const term = {[filterParams.field]: filterParams.term};
+  return {term};
+};
+
+const buildRangeFilter = function (filterParams) {
+  const range = {[filterParams.field]: {}};
+  if (filterParams.range.from) {
+    range[filterParams.field].gte = filterParams.range.from;
+  }
+  if (filterParams.range.to) {
+    range[filterParams.field].lte = filterParams.range.to;
+  }
+
+  return {range};
+};
+
+const buildFilter = function (filterParams) {
+  if (filterParams.term) {
+    return buildTermFilter(filterParams);
+  }
+
+  if (filterParams.range) {
+    return buildRangeFilter(filterParams);
+  }
+};
+
+const buildQuery = function (searchParams) {
+  const query = {query: {filtered: {}}};
+
+  if (searchParams.query) {
+    query.query.filtered.query = {match: {_all: searchParams.query}};
+  }
+
+  if (searchParams.filters && searchParams.filters.length) {
+    query.query.filtered = {
+      filter: {and: searchParams.filters.map(buildFilter)}
+    };
+  }
+
+  return query;
+};
+
+module.exports = {
+  build: buildQuery
+};

lib/version.js

@@ -12,7 +12,7 @@ exports.register = function (server, options, next) {
     path: '/version',
     config: {
       description: 'Returns the version of the server',
-      handler: function (request, reply) {
+      handler(request, reply) {
         reply(versionResponse);
       }
     }

package.json

@@ -26,11 +26,13 @@
     "swaggerize-hapi": "^1.0.0"
   },
   "devDependencies": {
+    "babel-eslint": "^4.1.2",
     "chai": "^3.2.0",
     "cuid": "^1.3.8",
     "enjoi": "^1.0.0",
     "eslint": "^1.3.1",
     "eslint-config-xo-space": "^0.4.0",
+    "eslint-plugin-babel": "^2.1.1",
     "grunt": "^0.4.5",
     "grunt-contrib-watch": "^0.6.1",
     "grunt-eslint": "^17.1.0",

spec/indexes_{name}.js

@@ -8,7 +8,7 @@ const specRequest = require('./spec_request');
 const expect = require('chai').expect;
 
 describe('/indexes/{name}', () => {
-  const testIndexName = 'test_index_' + cuid();
+  const testIndexName = `test_index_${cuid()}`;
   const testObject = {name: 'object', field: 'value'};
   let createResponse;
 

spec/indexes_{name}_query.js

@@ -8,31 +8,108 @@ const specRequest = require('./spec_request');
 const expect = require('chai').expect;
 
 describe('/indexes/{name}/query', () => {
-  const testIndexName = 'test_index_' + cuid();
-  const testDocument = {sku: '12345'};
-
-  beforeEach(() => {
-    return elasticsearchClient.index({
-      index: testIndexName,
-      type: 'test_type',
-      body: {sku: '12345'}
-    })
-    .then(() => elasticsearchClient.indices.refresh({index: testIndexName}));
+  const testIndexName = `test_index_${cuid()}`;
+  const testIndexType = 'test_type';
+  const document1 = {sku: '12345', price: 1};
+  const document2 = {sku: '98765', price: 5};
+
+  before(() => {
+    return elasticsearchClient.bulk({
+      body: [
+        {index: {_index: testIndexName, _type: testIndexType, _id: 1}},
+        document1,
+        {index: {_index: testIndexName, _type: testIndexType, _id: 2}},
+        document2
+      ]
+    }).then(() => elasticsearchClient.indices.refresh({index: testIndexName}));
   });
 
-  afterEach(() => {
+  after(() => {
     return elasticsearchClient.indices.delete({index: testIndexName});
   });
 
   describe('post', () => {
     it('queries by keyword', () => {
       const payload = {query: '12345'};
 
-      return specRequest({url: `/1/indexes/${testIndexName}/query`, method: 'post', payload: payload})
+      return specRequest({url: `/1/indexes/${testIndexName}/query`, method: 'post', payload})
+        .then(response => {
+          expect(response.result).to.be.deep.equal([document1]);
+          expect(response.statusCode).to.equal(200);
+        });
+    });
+
+    it('filters results by terms', () => {
+      const payload = {filters: [{field: 'sku', term: '12345'}]};
+
+      return specRequest({url: `/1/indexes/${testIndexName}/query`, method: 'post', payload})
+        .then(response => {
+          expect(response.result).to.be.deep.equal([document1]);
+          expect(response.statusCode).to.equal(200);
+        });
+    });
+
+    it('filters results by ranges', () => {
+      const payload = {filters: [{field: 'sku', range: {from: 2}}]};
+
+      return specRequest({url: `/1/indexes/${testIndexName}/query`, method: 'post', payload})
         .then(response => {
-          expect(response.result).to.be.deep.equal([testDocument]);
+          expect(response.result).to.be.deep.equal([document2]);
           expect(response.statusCode).to.equal(200);
         });
     });
+
+    describe('validation', () => {
+      it('ensures query is a string', () => {
+        const payload = {query: {}};
+
+        return specRequest({url: '/1/indexes/test-index/query', method: 'post', payload})
+          .then(response => {
+            expect(response.result.message).to.match(/"query" must be a string]/);
+            expect(response.statusCode).to.equal(400);
+          });
+      });
+
+      it('ensures filters is an array', () => {
+        const payload = {filters: {}};
+
+        return specRequest({url: '/1/indexes/test-index/query', method: 'post', payload})
+          .then(response => {
+            expect(response.result.message).to.match(/"filters" must be an array]/);
+            expect(response.statusCode).to.equal(400);
+          });
+      });
+
+      it('ensures filter has field', () => {
+        const payload = {filters: [{term: '12345'}]};
+
+        return specRequest({url: '/1/indexes/test-index/query', method: 'post', payload})
+          .then(response => {
+            expect(response.result.message).to.match(/"field" is required]/);
+            expect(response.statusCode).to.equal(400);
+          });
+      });
+
+      it('ensures filter has term or range', () => {
+        const payload = {filters: [{field: 'sku'}]};
+
+        return specRequest({url: '/1/indexes/test-index/query', method: 'post', payload})
+          .then(response => {
+            expect(response.result.message).to.match(/"0" must have at least 2 children/);
+            expect(response.statusCode).to.equal(400);
+          });
+      });
+
+      it('ensures range filter has at least 1 bound', () => {
+        const payload = {filters: [{field: 'sku', range: {}}]};
+
+        return specRequest({url: `/1/indexes/test-index/query`, method: 'post', payload})
+          .then(response => {
+            expect(response.result.message).to.match(/"range" must have at least 1 children/);
+            expect(response.statusCode).to.equal(400);
+          });
+      });
+    });
   });
 });
+

spec/indexes_{name}_{objectID}.js

@@ -9,7 +9,7 @@ const specRequest = require('./spec_request');
 const expect = require('chai').expect;
 
 describe('/indexes/{name}/{objectID}', () => {
-  const testIndexName = 'test_index_' + cuid();
+  const testIndexName = `test_index_${cuid()}`;
   let indexedObject;
 
   before(() => {
@@ -42,7 +42,7 @@ describe('/indexes/{name}/{objectID}', () => {
     });
 
     it('returns a 404 when the index does not contain the identified object', () => {
-      return specRequest({url: '/1/indexes/' + testIndexName + '/12345'})
+      return specRequest({url: `/1/indexes/${testIndexName}/12345`})
         .then(response => {
           expect(response.statusCode).to.equal(404);
           expect(response.result.message).to.equal('Index does not contain object with identifier 12345');

spec/spec_request.js

@@ -4,19 +4,19 @@ const enjoi = require('enjoi');
 const swagger = require('../swagger.json');
 
 module.exports = function (options) {
-  return new Promise(function (resolve, reject) {
-    require('../lib/server')(function (err, server) {
+  return new Promise((resolve, reject) => {
+    require('../lib/server')((err, server) => {
       if (err) {
         return reject(err);
       }
 
-      server.inject(options, function (response) {
+      server.inject(options, response => {
         if (!response.request.route || response.request.route.path === '/{p*}') {
           return reject(new Error(`Undefined route ${options.url}`));
         }
 
         const apiBasePath = swagger.basePath || '';
-        const route = response.request.route.path.replace(new RegExp('^' + apiBasePath), '');
+        const route = response.request.route.path.replace(new RegExp(`^${apiBasePath}`), '');
         const method = response.request.method;
 
         const swaggerPath = swagger.paths[route];
@@ -33,13 +33,17 @@ module.exports = function (options) {
 
         const swaggerResponse = swaggerMethod.responses[response.statusCode];
 
+        if (response.statusCode === 400) {
+          return resolve(response);
+        }
+
         if (response.statusCode !== 404 && !swaggerResponse) {
           return reject(new Error(`${response.statusCode} result for ${method} of route ${route} is undocumented. Please add to swagger.json.`));
         }
 
         const validator = enjoi(swaggerResponse.schema, {subSchemas: {'#': swagger}});
 
-        validator.validate(response.payload, function (err) {
+        validator.validate(response.payload, err => {
           if (err) {
             return reject(new Error(`Response does not match the documented schema: ${err}`));
           }

swagger.json

@@ -153,6 +153,40 @@
                                 "query": {
                                     "type": "string",
                                     "description": "Search keywords"
+                                },
+                                "filters": {
+                                    "type": "array",
+                                    "description": "An array of search filter objects. Either 'term' or 'range' is required",
+                                    "items": {
+                                        "type": "object",
+                                        "minProperties": 2,
+                                        "required": ["field"],
+                                        "properties": {
+                                            "field": {
+                                                "type": "string",
+                                                "description": "The field to filter by"
+                                            },
+                                            "term": {
+                                                "type": "string",
+                                                "description": "The filter term"
+                                            },
+                                            "range": {
+                                                "type": "object",
+                                                "description": "The filter range",
+                                                "minProperties": 1,
+                                                "properties": {
+                                                    "from": {
+                                                        "type": "number",
+                                                        "description": "The range's lower bound"
+                                                    },
+                                                    "to": {
+                                                        "type": "number",
+                                                        "description": "The range's upper bound"
+                                                    }
+                                                }
+                                            }
+                                        }
+                                    }
                                 }
                             }
                         }