Merge pull request #35 from pelias/mget-for-real

MGET

controller/get.js

@@ -5,25 +5,36 @@ function setup( backend ){
 
   // allow overriding of dependencies
   backend = backend || require('../src/backend');
+  backend = new backend(); 
   
   function controller( req, res, next ){
     
+    var docs = req.clean.ids.map( function(id) {
+      return {
+        _index: 'pelias',
+        _type: id.type,
+        _id: id.id
+      };
+    });
+
     // backend command
     var cmd = {
-      index: 'pelias',
-      type: req.clean.type,
-      id: req.clean.id
+      body: {
+        docs: docs
+      }
     };
     
-    // query backend
-    backend().client.get( cmd, function( err, data ){
+    // query new backend
+    backend.client.mget( cmd, function( err, data ){
       
       var docs = [];
       // handle backend errors
       if( err ){ return next( err ); }
 
-      if( data && data.found && data._source ){
-        docs.push(data._source);
+      if( data && data.docs && Array.isArray(data.docs) && data.docs.length ){
+        docs = data.docs.map( function( doc ){
+          return doc._source;
+        });
       }
 
       // convert docs to geojson

sanitiser/_id.js

@@ -1,5 +1,5 @@
 // validate inputs, convert types and apply defaults
-// id generally looks like 'geoname/4163334' (type/id)
+// id generally looks like 'geoname:4163334' (type:id)
 // so, both type and id are required fields.
 
 function sanitize( req ){
@@ -7,6 +7,7 @@ function sanitize( req ){
   req.clean   = req.clean || {};
   var params  = req.query;
   var indeces = require('../query/indeces');
+  var delim   = ':';
 
   // ensure params is a valid object
   if( Object.prototype.toString.call( params ) !== '[object Object]' ){
@@ -20,37 +21,44 @@ function sanitize( req ){
     }
   };
 
-  // id text
-  if('string' !== typeof params.id || !params.id.length){
+  if(('string' === typeof params.id && !params.id.length) || params.id === undefined){
     return errormessage('id');
   }
 
-  // id format
-  if(params.id.indexOf('/') === -1) {
-    return errormessage('id', 'invalid: must be of the format type/id for ex: \'geoname/4163334\'');
+  if( params && params.id && params.id.length ){
+    req.clean.ids = [];
+    params.ids = Array.isArray(params.id) ? params.id : [params.id];
+    
+    for (var i=0; i<params.ids.length; i++) {
+      var thisparam = params.ids[i];
+    
+      // basic format/ presence of ':'
+      if(thisparam.indexOf(delim) === -1) {
+        return errormessage(null, 'invalid: must be of the format type:id for ex: \'geoname:4163334\'');
       }
-  req.clean.id = params.id;
 
-  var param = params.id.split('/');
-  var param_type  = param[0];
-  var param_id    = param[1];
+      var param = thisparam.split(delim);
+      var type= param[0];
+      var id  = param[1];
 
       // id text
-  if('string' !== typeof param_id || !param_id.length){
-    return errormessage('id');
+      if('string' !== typeof id || !id.length){
+        return errormessage(thisparam);
       }
-
       // type text
-  if('string' !== typeof param_type || !param_type.length){
-    return errormessage('type');
+      if('string' !== typeof type || !type.length){
+        return errormessage(thisparam);
       }
-
       // type text must be one of the indeces
-  if(indeces.indexOf(param_type) == -1){
-    return errormessage('type', 'type must be one of these values - [' + indeces.join(", ") + ']');
+      if(indeces.indexOf(type) == -1){
+        return errormessage('type', type + ' is invalid. It must be one of these values - [' + indeces.join(", ") + ']');
+      }
+      req.clean.ids.push({
+        id: id,
+        type: type
+      });
+    }
   }
-  req.clean.id   = param_id;
-  req.clean.type = param_type;
   
   return { 'error': false };
 

test/unit/sanitiser/get.js

@@ -3,13 +3,19 @@ var get  = require('../../../sanitiser/get'),
     _sanitize = get.sanitize,
     middleware = get.middleware,
     indeces = require('../../../query/indeces'),
-    defaultIdError = 'invalid param \'id\': text length, must be >0',
-    defaultTypeError = 'invalid param \'type\': text length, must be >0',
-    defaultFormatError = 'invalid: must be of the format type/id for ex: \'geoname/4163334\'',
-    defaultError = defaultIdError,
-    defaultMissingTypeError = 'type must be one of these values - [' + indeces.join(", ") + ']',
-    defaultClean = { id: '123', type: 'geoname' },
-    sanitize = function(query, cb) { _sanitize({'query':query}, cb); }
+    delimiter = ':',
+    defaultLengthError = function(input) { return 'invalid param \''+ input + '\': text length, must be >0' },
+    defaultFormatError = 'invalid: must be of the format type:id for ex: \'geoname:4163334\'',
+    defaultError = 'invalid param \'id\': text length, must be >0',
+    defaultMissingTypeError = function(input) { 
+      var type = input.split(delimiter)[0];
+      return type + ' is invalid. It must be one of these values - [' + indeces.join(", ") + ']'},
+    defaultClean = { ids: [ { id: '123', type: 'geoname' } ] },
+    sanitize = function(query, cb) { _sanitize({'query':query}, cb); },
+    inputs = {
+      valid: [ 'geoname:1', 'osmnode:2', 'admin0:53', 'osmway:44', 'geoname:5' ],
+      invalid: [ ':', '', '::', 'geoname:', ':234', 'gibberish:23' ]
+    };
 
 module.exports.tests = {};
 
@@ -26,37 +32,19 @@ module.exports.tests.interface = function(test, common) {
   });
 };
 
-module.exports.tests.sanitize_id_and_type = function(test, common) {
-  var inputs = {
-    valid: [
-      'geoname/1',
-      'osmnode/2',
-      'admin0/53',
-      'osmway/44',
-      'geoname/5'
-    ],
-    invalid: [
-      '/',
-      '',
-      '//',
-      'geoname/',
-      '/234',
-      'gibberish/23'
-    ]
-  };
-
+module.exports.tests.sanitize_id = function(test, common) {
   test('invalid input', function(t) {
     inputs.invalid.forEach( function( input ){
       sanitize({ id: input }, function( err, clean ){
         switch (err) {
-          case defaultIdError:
-            t.equal(err, defaultIdError, input + ' is invalid (missing id)'); break;
-          case defaultTypeError:
-            t.equal(err, defaultTypeError, input + ' is invalid (missing type)'); break;
+          case defaultError:
+            t.equal(err, defaultError, input + ' is invalid input'); break;
+          case defaultLengthError(input):
+            t.equal(err, defaultLengthError(input), input + ' is invalid (missing id/type)'); break;
           case defaultFormatError:
             t.equal(err, defaultFormatError, input + ' is invalid (invalid format)'); break;
-          case defaultMissingTypeError:
-            t.equal(err, defaultMissingTypeError, input + ' is an unknown type'); break;
+          case defaultMissingTypeError(input):
+            t.equal(err, defaultMissingTypeError(input), input + ' is an unknown type'); break;
           default: break;
         }
         t.equal(clean, undefined, 'clean not set');
@@ -67,8 +55,8 @@ module.exports.tests.sanitize_id_and_type = function(test, common) {
 
   test('valid input', function(t) {
     inputs.valid.forEach( function( input ){
-      var input_parts = input.split('/');
-      var expected = { id: input_parts[1], type: input_parts[0] };
+      var input_parts = input.split(delimiter);
+      var expected = { ids: [ { id: input_parts[1], type: input_parts[0] } ] };
       sanitize({ id: input }, function( err, clean ){
         t.equal(err, undefined, 'no error (' + input + ')' );
         t.deepEqual(clean, expected, 'clean set correctly (' + input + ')');
@@ -78,6 +66,42 @@ module.exports.tests.sanitize_id_and_type = function(test, common) {
   });
 };
 
+
+module.exports.tests.sanitize_ids = function(test, common) {
+  test('invalid input', function(t) {
+    sanitize({ id: inputs.invalid }, function( err, clean ){
+      var input = inputs.invalid[0]; // since it breaks on the first invalid element
+      switch (err) {
+        case defaultError:
+          t.equal(err, defaultError, input + ' is invalid input'); break;
+        case defaultLengthError(input):
+          t.equal(err, defaultLengthError(input), input + ' is invalid (missing id/type)'); break;
+        case defaultFormatError:
+          t.equal(err, defaultFormatError, input + ' is invalid (invalid format)'); break;
+        case defaultMissingTypeError(input):
+          t.equal(err, defaultMissingTypeError(input), input + ' is an unknown type'); break;
+        default: break;
+      }
+      t.equal(clean, undefined, 'clean not set');
+    });
+    t.end();
+  });
+
+  test('valid input', function(t) {
+    var expected={};
+    expected.ids = [];
+    inputs.valid.forEach( function( input ){
+      var input_parts = input.split(delimiter);
+      expected.ids.push({ id: input_parts[1], type: input_parts[0] });
+    });
+    sanitize({ id: inputs.valid }, function( err, clean ){
+      t.equal(err, undefined, 'no error' );
+      t.deepEqual(clean, expected, 'clean set correctly');
+    });
+    t.end();
+  });
+};
+
 module.exports.tests.invalid_params = function(test, common) {
   test('invalid params', function(t) {
     sanitize( undefined, function( err, clean ){
@@ -102,7 +126,7 @@ module.exports.tests.middleware_failure = function(test, common) {
 
 module.exports.tests.middleware_success = function(test, common) {
   test('middleware success', function(t) {
-    var req = { query: { id: 'geoname/123' }};
+    var req = { query: { id: 'geoname' + delimiter + '123' }};
     var next = function( message ){
       t.equal(message, undefined, 'no error message set');
       t.deepEqual(req.clean, defaultClean);