Merge pull request pelias#1404 from pelias/remove_check_types

remove npm check-types module

Author: missinglink

middleware/500.js

@@ -1,8 +1,8 @@
-var check = require('check-types'),
-    logger = require( 'pelias-logger' ).get( 'api' );
+const _ = require('lodash');
+const logger = require('pelias-logger').get('api');
 
 // handle application errors
-function middleware(err, req, res, next) {
+function middleware(err, req, res) {
 
   logger.error( 'Error: `%s`. Stack trace: `%s`.', err, err.stack );
 
@@ -11,9 +11,16 @@ function middleware(err, req, res, next) {
     res.status(500);
   }
 
-  var error = ( err && err.message ) ? err.message : err;
+  // set error message
+  const error = (err && err.message) ? err.message : err;
+  let msg = 'internal server error';
+  if (_.isString(error) && !_.isEmpty(error)) {
+    msg = error;
+  }
+
+  // send response
   res.header('Cache-Control','public');
-  res.json({ error: check.nonEmptyString( error ) ? error : 'internal server error' });
+  res.json({ error: msg });
 }
 
 module.exports = middleware;

middleware/accuracy.js

@@ -3,24 +3,23 @@
  * Accuracy level should be set for each item in the results.
  * The level can be any of the following:
  *  - point
- *  - interpolated
+ *  - interpolated (not currently used)
  *  - centroid
  */
 
-var check = require('check-types');
-
-var accuracyLevelPoint = 'point';
-var accuracyLevelInterpolated = 'interpolated';
-var accuracyLevelCentroid = 'centroid';
+const _ = require('lodash');
 
+const accuracyLevelPoint = 'point';
+// const accuracyLevelInterpolated = 'interpolated';
+const accuracyLevelCentroid = 'centroid';
 
 function setup() {
   return computeAccuracy;
 }
 
 function computeAccuracy(req, res, next) {
   // do nothing if no result data set
-  if (check.undefined(res) || check.undefined(res.data)) {
+  if (_.isUndefined(res) || _.isUndefined(res.data)) {
     return next();
   }
 

middleware/confidenceScore.js

@@ -11,24 +11,24 @@
  * - detection (or specification) of query type. i.e. an address shouldn't match an admin address.
  */
 
+const _ = require('lodash');
 const stats = require('stats-lite');
 const logger = require('pelias-logger').get('api');
-const check = require('check-types');
 const field = require('../helper/fieldValue');
 
 var RELATIVE_SCORES = true;
 
 function setup(peliasConfig) {
-  if (check.assigned(peliasConfig)) {
+  if (!_.isNil(peliasConfig)) {
     RELATIVE_SCORES = peliasConfig.hasOwnProperty('relativeScores') ? peliasConfig.relativeScores : true;
   }
   return computeScores;
 }
 
 function computeScores(req, res, next) {
   // do nothing if no result data set or if query is not of the pelias_parser variety
-  if (check.undefined(req.clean) || check.undefined(res) ||
-      check.undefined(res.data) || check.undefined(res.meta) ||
+  if (_.isUndefined(req.clean) || _.isUndefined(res) ||
+      _.isUndefined(res.data) || _.isUndefined(res.meta) ||
       res.meta.query_type !== 'search_pelias_parser') {
     return next();
   }
@@ -91,17 +91,17 @@ function computeConfidenceScore(req, mean, stdev, hit) {
  * @returns {bool}
  */
 function checkForDealBreakers(req, hit) {
-  if (check.undefined(req.clean.parsed_text)) {
+  if (_.isUndefined(req.clean.parsed_text)) {
     return false;
   }
 
-  if (check.assigned(req.clean.parsed_text.state) && check.assigned(hit.parent) &&
+  if (!_.isNil(req.clean.parsed_text.state) && !_.isNil(hit.parent) &&
       hit.parent.region_a && req.clean.parsed_text.state !== hit.parent.region_a[0]) {
     logger.debug('[confidence][deal-breaker]: state !== region_a');
     return true;
   }
 
-  if (check.assigned(req.clean.parsed_text.postalcode) && check.assigned(hit.address_parts) &&
+  if (!_.isNil(req.clean.parsed_text.postalcode) && !_.isNil(hit.address_parts) &&
       req.clean.parsed_text.postalcode !== hit.address_parts.zip) {
     return true;
   }
@@ -131,7 +131,7 @@ function checkDistanceFromMean(score, mean, stdev) {
  */
 function checkName(text, parsed_text, hit) {
   // parsed_text name should take precedence if available since it's the cleaner name property
-  if (check.assigned(parsed_text) && check.assigned(parsed_text.name) &&
+  if (!_.isNil(parsed_text) && !_.isNil(parsed_text.name) &&
     field.getStringValue(hit.name.default).toLowerCase() === parsed_text.name.toLowerCase()) {
     return 1;
   }
@@ -154,9 +154,9 @@ function checkName(text, parsed_text, hit) {
  * @returns {number}
  */
 function checkQueryType(text, hit) {
-  if (check.assigned(text) && check.assigned(text.number) &&
-      (check.undefined(hit.address_parts) ||
-      (check.assigned(hit.address_parts) && check.undefined(hit.address_parts.number)))) {
+  if (!_.isNil(text) && !_.isNil(text.number) &&
+      (_.isUndefined(hit.address_parts) ||
+      (!_.isNil(hit.address_parts) && _.isUndefined(hit.address_parts.number)))) {
     return 0;
   }
   return 1;
@@ -173,22 +173,22 @@ function checkQueryType(text, hit) {
 function propMatch(textProp, hitProp, expectEnriched) {
 
   // both missing, but expect to have enriched value in result => BAD
-  if (check.undefined(textProp) && check.undefined(hitProp) && check.assigned(expectEnriched)) { return 0; }
+  if (_.isUndefined(textProp) && _.isUndefined(hitProp) && !_.isNil(expectEnriched)) { return 0; }
 
   // both missing, and no enrichment expected => GOOD
-  if (check.undefined(textProp) && check.undefined(hitProp)) { return 1; }
+  if (_.isUndefined(textProp) && _.isUndefined(hitProp)) { return 1; }
 
   // text has it, result doesn't => BAD
-  if (check.assigned(textProp) && check.undefined(hitProp)) { return 0; }
+  if (!_.isNil(textProp) && _.isUndefined(hitProp)) { return 0; }
 
   // text missing, result has it, and enrichment is expected => GOOD
-  if (check.undefined(textProp) && check.assigned(hitProp) && check.assigned(expectEnriched)) { return 1; }
+  if (_.isUndefined(textProp) && !_.isNil(hitProp) && !_.isNil(expectEnriched)) { return 1; }
 
   // text missing, result has it, enrichment not desired => 50/50
-  if (check.undefined(textProp) && check.assigned(hitProp)) { return 0.5; }
+  if (_.isUndefined(textProp) && !_.isNil(hitProp)) { return 0.5; }
 
   // both present, values match => GREAT
-  if (check.assigned(textProp) && check.assigned(hitProp) &&
+  if (!_.isNil(textProp) && !_.isNil(hitProp) &&
       textProp.toString().toLowerCase() === hitProp.toString().toLowerCase()) { return 1; }
 
   // ¯\_(ツ)_/¯
@@ -218,7 +218,7 @@ function checkAddress(text, hit) {
   var checkCount = 5;
   var res = 0;
 
-  if (check.assigned(text) && check.assigned(text.number) && check.assigned(text.street)) {
+  if (!_.isNil(text) && !_.isNil(text.number) && !_.isNil(text.street)) {
     res += propMatch(text.number, (hit.address_parts ? hit.address_parts.number : null), false);
     res += propMatch(text.street, (hit.address_parts ? hit.address_parts.street : null), false);
     res += propMatch(text.postalcode, (hit.address_parts ? hit.address_parts.zip: null), true);

middleware/confidenceScoreFallback.js

@@ -9,9 +9,8 @@
  * - fallback status (aka layer match between expected and actual)
  */
 
-var check = require('check-types');
-var logger = require('pelias-logger').get('api');
 const _ = require('lodash');
+const logger = require('pelias-logger').get('api');
 
 function setup() {
   return computeScores;
@@ -20,8 +19,8 @@ function setup() {
 function computeScores(req, res, next) {
   // do nothing if no result data set or if the query is not of the fallback variety
   // later add disambiguation to this list
-  if (check.undefined(req.clean) || check.undefined(res) ||
-      check.undefined(res.data) || check.undefined(res.meta)) {
+  if (_.isUndefined(req.clean) || _.isUndefined(res) ||
+      _.isUndefined(res.data) || _.isUndefined(res.meta)) {
     return next();
   }
 
@@ -78,7 +77,7 @@ function checkFallbackLevel(req, hit) {
       case 'street':
         return 0.8;
       case 'postalcode':
-        return 0.8;    
+        return 0.8;
       case 'localadmin':
       case 'locality':
       case 'borough':

middleware/distance.js

@@ -1,11 +1,9 @@
-var geolib = require('geolib');
-var check = require('check-types');
-
+const _ = require('lodash');
+const geolib = require('geolib');
 
 function setup(prefix) {
-
   return function (req, res, next) {
-    var opts = {
+    const opts = {
       prefix: prefix || 'point.'
     };
     return computeDistances(req, res, next, opts);
@@ -19,8 +17,8 @@ function computeDistances(req, res, next, opts) {
     return next();
   }
 
-  if (!(check.number(req.clean[opts.prefix + 'lat']) &&
-        check.number(req.clean[opts.prefix + 'lon']))) {
+  if (!(_.isFinite(req.clean[opts.prefix + 'lat']) &&
+        _.isFinite(req.clean[opts.prefix + 'lon']))) {
     return next();
   }
 

middleware/localNamingConventions.js

@@ -1,4 +1,3 @@
-const check = require('check-types');
 const _ = require('lodash');
 const field = require('../helper/fieldValue');
 

package.json

@@ -39,7 +39,6 @@
     "@hapi/joi": "^16.0.1",
     "@mapbox/geojson-extent": "^0.3.1",
     "async": "^3.0.1",
-    "check-types": "^10.0.0",
     "elasticsearch": "^16.0.0",
     "express": "^4.8.8",
     "geojson": "^0.5.0",

query/address_search_using_ids.js

@@ -1,8 +1,6 @@
+const _ = require('lodash');
 const peliasQuery = require('pelias-query');
 const defaults = require('./search_defaults');
-const logger = require('pelias-logger').get('api');
-const _ = require('lodash');
-const check = require('check-types');
 
 //------------------------------
 // general-purpose search query
@@ -142,19 +140,19 @@ function generateQuery( clean, res ){
   }
 
   // focus point
-  if( check.number(clean['focus.point.lat']) &&
-      check.number(clean['focus.point.lon']) ){
+  if( _.isFinite(clean['focus.point.lat']) &&
+      _.isFinite(clean['focus.point.lon']) ){
     vs.set({
       'focus:point:lat': clean['focus.point.lat'],
       'focus:point:lon': clean['focus.point.lon']
     });
   }
 
   // boundary rect
-  if( check.number(clean['boundary.rect.min_lat']) &&
-      check.number(clean['boundary.rect.max_lat']) &&
-      check.number(clean['boundary.rect.min_lon']) &&
-      check.number(clean['boundary.rect.max_lon']) ){
+  if( _.isFinite(clean['boundary.rect.min_lat']) &&
+      _.isFinite(clean['boundary.rect.max_lat']) &&
+      _.isFinite(clean['boundary.rect.min_lon']) &&
+      _.isFinite(clean['boundary.rect.max_lon']) ){
     vs.set({
       'boundary:rect:top': clean['boundary.rect.max_lat'],
       'boundary:rect:right': clean['boundary.rect.max_lon'],
@@ -164,29 +162,29 @@ function generateQuery( clean, res ){
   }
 
   // boundary circle
-  if( check.number(clean['boundary.circle.lat']) &&
-      check.number(clean['boundary.circle.lon']) ){
+  if( _.isFinite(clean['boundary.circle.lat']) &&
+      _.isFinite(clean['boundary.circle.lon']) ){
     vs.set({
       'boundary:circle:lat': clean['boundary.circle.lat'],
       'boundary:circle:lon': clean['boundary.circle.lon']
     });
 
-    if( check.number(clean['boundary.circle.radius']) ){
+    if( _.isFinite(clean['boundary.circle.radius']) ){
       vs.set({
         'boundary:circle:radius': Math.round( clean['boundary.circle.radius'] ) + 'km'
       });
     }
   }
 
   // boundary country
-  if( check.nonEmptyArray(clean['boundary.country']) ){
+  if( _.isArray(clean['boundary.country']) && !_.isEmpty(clean['boundary.country']) ){
     vs.set({
       'boundary:country': clean['boundary.country'].join(' ')
     });
   }
 
   // boundary gid
-  if ( check.string(clean['boundary.gid']) ){
+  if ( _.isString(clean['boundary.gid']) ){
     vs.set({
       'boundary:gid': clean['boundary.gid']
     });