@furkot/directions 1.5.2 → 2.0.1

package/lib/directions.js

@@ -1,13 +1,11 @@
-const strategy = require('run-waterfall-until');
 const travelMode = require('./model').travelMode;
-const util = require('./service/util');
+const { defaults: defaults, withTimeout } = require('./service/util');
 
 module.exports = furkotDirections;
 
-function skip(options, query, result) {
-  // some other service already calculated directions
-  // or service is disabled
-  return result || !options.enable(query, result);
+function skip(options, query) {
+  // if service is disabled
+  return !options.enable(query);
 }
 
 // query cascades through services until one produces a result
@@ -32,9 +30,9 @@ const services = {
   },
   osrm: {
     service: require('./service/osrm'),
-    skip(options, query, result) {
+    skip(options, query) {
       // or asking for walking or biking directions (OSRM doesn't do it well)
-      return skip(options, query, result) || (query.mode !== travelMode.car && query.mode !== travelMode.motorcycle);
+      return skip(options, query) || (query.mode !== travelMode.car && query.mode !== travelMode.motorcycle);
     }
   }
 };
@@ -42,96 +40,98 @@ const services = {
 // default timeout to complete operation
 const defaultTimeout = 20 * 1000;
 
-let id = 0;
-
 function furkotDirections(options) {
 
-  /**
-   * Asynchronous directions service
-   * @param query directions query object
-   * @param fn function called with directions
-   */
-  function directions(query, fn) {
-    if (!query) {
-      return fn();
-    }
-
-    id += 1;
-
-    const result = new Array(query.length);
-    if (!query.length) {
-      return fn(query, result);
-    }
-
-    const queryId = id;
-    let timeoutId = setTimeout(function () {
-      timeoutId = undefined;
-      // cancel outstanding requests
-      options.services.forEach(function (service) {
-        service.abort(queryId);
-      });
-    }, options.timeout);
-
-    strategy(options.services, queryId, query, result, function (err, queryId, query, result) {
-      if (timeoutId) {
-        clearTimeout(timeoutId);
-        timeoutId = undefined;
-      }
-      if (err) {
-        return fn();
-      }
-      // if no results, mark first as empty
-      if (result.length > 0 && !result.some(function (r) {
-          return r;
-        })) {
-        result[0] = {
-          query: query[0],
-          routes: [{
-            distance: 0,
-            duration: 0
-          }]
-        };
-      }
-      fn(query, result);
-    });
-  }
-
-  options = util.defaults(options, {
+  options = {
     timeout: defaultTimeout,
-    order: ['osrm', 'mapquest', 'valhalla', 'graphhopper', 'openroute']
-  });
+    order: ['osrm', 'mapquest', 'valhalla', 'graphhopper', 'openroute'],
+    ...options
+  };
   if (!options.services) {
-    options.services = options.order.reduce(function (result, name) {
+    options.services = options.order.map(name => {
       const service = services[options[name] || name];
-      let defaults;
-      if (service && options[(name + '_enable')]) {
-        defaults = {
+      if (!service) {
+        return;
+      }
+      const enable = options[`${name}_enable`];
+      if (!enable) {
+        return;
+      }
+      // object representing actual parameters for a service
+      const serviceOptions = {
+        name,
+        limiter: options[`${name}_limiter`],
+        enable,
+        skip: service.skip
+      };
+      if (options[name]) {
+        Object.keys(options).reduce(mapOptions, {
+          options,
           name,
-          limiter: options[(name + '_limiter')],
-          enable: options[(name + '_enable')],
-          skip: service.skip
-        };
-        if (options[name]) {
-          Object.keys(options).reduce(mapOptions, {
-            options,
-            name,
-            optName: options[name],
-            defaults
-          });
-        }
-        result.push(service.service(util.defaults(defaults, options)));
+          optName: options[name],
+          serviceOptions
+        });
       }
-      return result;
-    }, []);
+      // we are adding options that has not been copied to serviceOptions yet
+      return service.service(defaults(serviceOptions, options));
+    }).filter(Boolean);
   }
 
   directions.options = options;
   return directions;
+
+  /**
+   * Asynchronous directions service
+   * @param query directions query object
+   */
+  function directions(query, { signal } = {}) {
+    if (query?.points?.length > 1) {
+      return requestDirections(query, options.timeout);
+    }
+
+    async function requestDirections(query, timeout) {
+      const stats = [];
+      for (const service of options.services) {
+        if (service.skip(service, query)) {
+          continue;
+        }
+        stats.push(service.name);
+        const startTime = Date.now();
+        const result = await withTimeout(service.operation(query), Math.floor(timeout / 2), signal);
+        if (signal?.aborted) {
+          break;
+        }
+        if (result?.query) {
+          result.stats = stats;
+          result.provider = service.name;
+          return result;
+        }
+        timeout -= Date.now() - startTime;
+        if (timeout <= 0) {
+          break;
+        }
+        if (query.points.length > 2) {
+          return requestDirections({
+            ...query,
+            points: query.points.slice(0, 2)
+          }, timeout);
+        }
+      }
+      return {
+        query: {
+          ...query,
+          points: query.points.slice(0, 2)
+        },
+        stats,
+        routes: [{}]
+      };
+    }
+  }
 }
 
 function mapOptions(result, opt) {
   if (opt.startsWith(result.name)) {
-    result.defaults[opt.replace(result.name, result.optName)] = result.options[opt];
+    result.serviceOptions[opt.replace(result.name, result.optName)] = result.options[opt];
   }
   return result;
 }

package/lib/model.js

@@ -17,7 +17,7 @@ const travelMode = {
 };
 
 // template for directions query object
-const directionsQuery = [{ // array of legs each for consecutive series of points
+const directionsQuery = {
   mode: travelMode.car, // numeric value of travel mode
   avoidHighways: false, // true to avoid highways
   avoidTolls: false, // true to avoid toll roads
@@ -31,12 +31,11 @@ const directionsQuery = [{ // array of legs each for consecutive series of point
   seasonal: false, // include roads that are seasonally closed
   path: pathType.none, // the degree of route path simplification
   span: 0, // distance in meters for more detailed path simplification
-  alternate: false, // return alternatives to the default route
-  stats: [] // set on output - list of providers that requests have been sent to to obtain directions
-}];
+  alternate: false // return alternatives to the default route
+};
 
 // template for directions results object
-const directionsResult = [{ // array of directions legs, one for each consecutive series of points
+const directionsResult = {
   query: directionsQuery, // query parameters
   places: [], // addresses or place names corresponding to points (if directions service performs reverse geocoding)
   name: '', // human-readable name of directions (if available)
@@ -53,8 +52,9 @@ const directionsResult = [{ // array of directions legs, one for each consecutiv
     path: [], // series of interim points; each point is [lon, lat]
     instructions: '' // textual instructions for this segment
   }],
+  stats: [], // list of providers that requests have been sent to to obtain directions
   provider: '' // identifies service providing the directions
-}];
+};
 
 module.exports = {
   directionsQuery,

package/lib/service/index.js

@@ -1,8 +1,8 @@
 const fetchagent = require('fetchagent');
-const pathType = require("../model").pathType;
-const series = require('run-series');
+const { pathType } = require("../model");
+const makeLimiter = require('limiter-component');
 const status = require('./status');
-const util = require('./util');
+const makeSimplify = require('./simplify');
 const debug = require('debug')('furkot:directions:service');
 
 module.exports = init;
@@ -11,218 +11,107 @@ const limiters = {};
 
 const ERROR = 'input error';
 
-function eachOfSeries(items, task, fn) {
-  const tasks = items.map(function (item, i) {
-    return task.bind(null, item, i);
-  });
-  return series(tasks, fn);
-}
-
-function request(url, req, fn) {
-  const options = this;
-  let fa = fetchagent;
-  if (options.post) {
-    fa = fa.post(url).send(req);
-  } else {
-    fa = fa.get(url).query(req);
-  }
-  if (options.authorization) {
-    fa.set('authorization', options.authorization);
-  }
-  return fa
-    .set('accept', 'application/json')
-    .end(fn);
-}
-
-function initUrl(url) {
-  if (typeof url === 'function') {
-    return url;
-  }
-  return function () {
-    return url;
+function init(options) {
+  options = {
+    interval: 340,
+    penaltyInterval: 2000,
+    limiter: limiters[options.name],
+    request,
+    operation,
+    ...options
   };
-}
+  options.url = initUrl(options.url);
+  limiters[options.name] = options.limiter || makeLimiter(options.interval, options.penaltyInterval);
+  const limiter = limiters[options.name];
+  const simplify = makeSimplify(options);
+  return options;
+
+  async function operation(query) {
+    const { maxPoints } = options;
+    const { points } = query;
+    if (points.length > maxPoints) {
+      debug('Can only query %d points', maxPoints);
+      query = {
+        ...query,
+        points: points.slice(0, maxPoints)
+      };
+    }
+    return queryDirections(query);
+  }
 
-function init(options) {
-  let limiter;
-  let holdRequests;
-  let simplify;
-  const outstanding = {};
+  async function queryDirections(query) {
+    if (!query) {
+      throw ERROR;
+    }
 
-  function abort(queryId) {
-    debug('abort', queryId);
-    if (!outstanding[queryId]) {
+    query.path = query.path || pathType.none;
+    let req = options.prepareRequest(query);
+    if (!req) {
       return;
     }
-    // cancel later request if scheduled
-    if (outstanding[queryId].laterTimeoutId) {
-      clearTimeout(outstanding[queryId].laterTimeoutId);
-    }
-    // cancel request in progress
-    if (outstanding[queryId].reqInProgress) {
-      outstanding[queryId].reqInProgress.abort();
+    if (req === true) {
+      req = undefined;
     }
-    outstanding[queryId].callback(ERROR);
-  }
-
-  function directions(queryId, queryArray, result, fn) {
 
-    function spliceResults(idx, segments, segResult) {
-      Array.prototype.splice.apply(queryArray, [idx + queryArray.delta, 1].concat(segments));
-      Array.prototype.splice.apply(result, [idx + queryArray.delta, 1].concat(segResult));
-      queryArray.delta += segments.length - 1;
+    await limiter.trigger();
+    const { status: err, response } = await options.request(options.url(query), req);
+    let st = options.status(err, response);
+    if (st === undefined) {
+      // shouldn't happen (bug or unexpected response format)
+      // treat it as no route
+      st = status.empty;
+    }
+    if (st === status.failure) {
+      // don't ever ask again
+      options.skip = () => true;
+      return;
+    }
+    if (st === status.error) {
+      // try again later
+      limiter.penalty();
+      return queryDirections(query);
+    }
+    if (st === status.empty) {
+      return;
     }
 
-    function queryDirections(query, idx, callback) {
-      let req;
-      let segments;
-
-      function requestLater() {
-        outstanding[queryId].laterTimeoutId = setTimeout(function () {
-          if (outstanding[queryId]) {
-            delete outstanding[queryId].laterTimeoutId;
-          }
-          queryDirections(query, idx, callback);
-        }, options.penaltyTimeout);
-      }
-
-      if (!outstanding[queryId]) {
-        // query has been aborted
-        return;
-      }
-      outstanding[queryId].callback = callback;
-
-      if (options.skip(options, query, result[idx + queryArray.delta])) {
-        return callback();
-      }
-
-      if (holdRequests) {
-        return callback();
-      }
-
-      segments = util.splitPoints(query, queryArray.maxPoints || options.maxPoints);
-      if (!segments) {
-        return callback(ERROR);
-      }
-
-      if (segments !== query) {
-        segments[0].stats = query.stats;
-        delete query.stats;
-        return directions(queryId, segments,
-          new Array(segments.length),
-          function (err, stop, id, query, result) {
-            if (query && result) {
-              spliceResults(idx, query, result);
-            }
-            callback(err);
-          });
-      }
-
-      query.path = query.path || pathType.none;
-      req = options.prepareRequest(query);
-      if (!req) {
-        return callback();
+    const res = options.processResponse(response, query);
+    if (res) {
+      if (!res.pathReady && res.routes && res.segments) {
+        simplify(query.path, query.span, res.routes, res.segments);
       }
-      if (req === true) {
-        req = undefined;
+      if (!query.turnbyturn) {
+        delete res.segments;
       }
-
-      limiter.trigger(function () {
-        if (!outstanding[queryId]) {
-          // query has been aborted
-          limiter.skip(); // immediately process the next request in the queue
-          return;
-        }
-        query.stats = query.stats || [];
-        query.stats.push(options.name);
-        outstanding[queryId].reqInProgress = options.request(options.url(query), req, function (err, response) {
-          let st;
-          let res;
-          if (!outstanding[queryId]) {
-            // query has been aborted
-            return;
-          }
-          delete outstanding[queryId].reqInProgress;
-          st = options.status(err, response);
-          if (st === undefined) {
-            // shouldn't happen (bug or unexpected response format)
-            // treat it as no route
-            st = status.empty;
-          }
-          if (st === status.failure) {
-            // don't ever ask again
-            holdRequests = true;
-            return callback();
-          }
-          if (st === status.error) {
-            // try again later
-            limiter.penalty();
-            return requestLater();
-          }
-          if (st === status.empty && query.points.length > 2) {
-            query = [query];
-            query.maxPoints = 2;
-
-            return directions(queryId, query,
-              new Array(1),
-              function (err, stop, id, query, result) {
-                if (query && result) {
-                  spliceResults(idx, query, result);
-                }
-                callback(err);
-              });
-          }
-
-          res = options.processResponse(response, query);
-          if (res) {
-            if (!res.pathReady && res.routes && res.segments) {
-              simplify(query.path, query.span, res.routes, res.segments);
-            }
-            if (!query.turnbyturn) {
-              delete res.segments;
-            }
-            result[idx + queryArray.delta] = res;
-          }
-          callback();
-        });
-      });
     }
+    return res;
+  }
+}
 
-    outstanding[queryId] = outstanding[queryId] || {
-      stack: 0,
-      hits: 0
-    };
-    outstanding[queryId].stack += 1;
-    outstanding[queryId].callback = function (err) {
-      fn(err, true, queryId, queryArray, result);
+async function request(url, req) {
+  const options = this;
+  let fa = fetchagent;
+  if (options.post) {
+    fa = fa.post(url).send(req);
+  } else {
+    fa = fa.get(url).query(req);
+  }
+  if (options.authorization) {
+    fa.set('authorization', options.authorization);
+  }
+  const res = await fa.set('accept', 'application/json').end();
+  let status;
+  if (!res.ok) {
+    status = {
+      status: res.status
     };
-    queryArray.delta = 0;
-
-    eachOfSeries(queryArray, queryDirections, function (err) {
-      if (outstanding[queryId]) {
-        outstanding[queryId].stack -= 1;
-        if (!outstanding[queryId].stack) {
-          delete outstanding[queryId];
-        }
-        if (err === ERROR) {
-          return fn(outstanding[queryId] ? err : undefined, true, queryId, queryArray, result);
-        }
-        fn(err, false, queryId, queryArray, result);
-      }
-    });
   }
+  return {
+    status,
+    response: await res.json()
+  };
+}
 
-  options = util.defaults(options, {
-    interval: 340,
-    penaltyInterval: 2000,
-    limiter: limiters[options.name],
-    request,
-    abort
-  });
-  options.url = initUrl(options.url);
-  limiters[options.name] = options.limiter || require('limiter-component')(options.interval, options.penaltyInterval);
-  limiter = limiters[options.name];
-  simplify = require('./simplify')(options);
-  directions.abort = options.abort;
-  return directions;
+function initUrl(url) {
+  return typeof url === 'function' ? url : () => url;
 }

package/lib/service/openroute/index.js

@@ -1,3 +1,6 @@
+// https://openrouteservice.org/dev/#/api-docs/directions
+
+const LatLon = require('geodesy/latlon-spherical');
 const { pathType, travelMode } = require("../../model");
 const status = require('../status');
 const util = require('../util');
@@ -17,6 +20,7 @@ const profileRestrictions = {
   }
 };
 const ferryType = 9;
+const maxRoundabout = 12 * 60 * 60; // 12 hours maximum for route that is 10 times longer than direct distance
 
 function nextFerry(result, points = [-1, -1]) {
   let { waytypes } = result;
@@ -87,9 +91,35 @@ function extractDirections(result, { distance, duration, steps }, i) {
   return result;
 }
 
+function toLatLon(p) {
+  return new LatLon(p[1], p[0]);
+}
+
+function directDistance(locations) {
+  return locations.reduce((result, next) => {
+    next = toLatLon(next);
+    result.dist += result.ll.distanceTo(next);
+    result.ll = next;
+    return result;
+  }, {
+    dist: 0,
+    ll: toLatLon(locations[0])
+  }).dist;
+}
+
 function getStatus(st, response) {
   if (!st && response && response.routes && response.routes.length) {
-    return status.success;
+    const { distance, duration } = response.routes.reduce((result, { summary}) => {
+      result.distance += summary.distance;
+      result.duration += summary.duration;
+      return result;
+    }, { distance: 0, duration: 0 });
+    const coordinates = response.metadata?.query?.coordinates;
+    const direct = coordinates ? directDistance(coordinates) : distance;
+    if (distance < 5 * direct || duration < maxRoundabout) {
+      return status.success;
+    }
+    delete response.routes;
   }
   return status.empty;
 }

package/lib/service/util.js

@@ -13,7 +13,9 @@ module.exports = {
   metersInKm: 1000,
   metersInMile: 1609.34,
   split2object,
-  splitPoints
+  collateResults,
+  withTimeout,
+  timeout
 };
 
 function concat(result, path) {
@@ -43,9 +45,8 @@ function indexAt(path, distance) {
   let index = 1;
   let p1 = toLatLon(path[0]);
   let d = 0;
-  let p2;
   while (index < path.length) {
-    p2 = toLatLon(path[index]);
+    const p2 = toLatLon(path[index]);
     d += p1.distanceTo(p2);
     if (d > distance) {
       break;
@@ -78,24 +79,56 @@ function split2object(str, conn, obj) {
   }, obj || {});
 }
 
-function splitPoints(query, maxPoints) {
-  let i;
-  let segments;
-  if (!(query.points && query.points.length > 1)) {
-    return;
-  }
-  if (query.points.length <= maxPoints) {
-    return query;
+function collateResults(results, query) {
+  return results.reduce((result, r) => {
+    concatArrayProp(result, r, 'segments');
+    concatArrayProp(result, r, 'places');
+    concatArrayProp(result, r, 'routes');
+    if (!result.name && r?.name) {
+      result.name = r.name;
+    }
+    return result;
+  }, {
+    query
+  });
+
+  function concatArrayProp(to, from, prop) {
+    if (!from[prop]) {
+      return;
+    }
+    if (!to[prop]) {
+      to[prop] = from[prop];
+    } else {
+      to[prop].push(...from[prop]);
+    }
   }
-  segments = [];
-  for (i = 0; i < query.points.length - 1; i += maxPoints - 1) {
-    segments.push(defaults({
-      points: query.points.slice(i, i + maxPoints),
-      stats: []
-    }, query));
+}
+
+function withTimeout(promise, millis, signal) {
+  let id;
+  let reject;
+
+  signal?.addEventListener('abort', onabort);
+  return Promise
+    .race([promise, new Promise(timeoutPromise)])
+    .finally(() => {
+      signal?.removeEventListener('abort', onabort);
+      clearTimeout(id);
+    });
+
+  function onabort() {
+    reject(signal.reason);
   }
-  if (last(segments).points.length === 1) {
-    last(segments).points.unshift(segments[segments.length - 2].points.pop());
+
+  function timeoutPromise(_, _reject) {
+    reject = _reject;
+    id = setTimeout(
+      () => reject(Error('timeout', { cause: Symbol.for('timeout') })),
+      millis
+    );
   }
-  return segments;
+}
+
+function timeout(millis = 0) {
+  return new Promise(resolve => setTimeout(resolve, millis));
 }

package/lib/service/valhalla/index.js

@@ -25,6 +25,7 @@ const costingOptions = {
 };
 const minSpeed = 15 * 1000 / 3600; // bump speed when it is absurdly low
 const turnDistance = 100; // don't adjust speed of turns
+const maxRoundabout = 12 * 60 * 60; // 12 hours maximum for route that is 10 times longer than direct distance
 
 const maneuver = {
   ferryEnter: 28,
@@ -109,9 +110,17 @@ function toLatLon(p) {
   return new LatLon(p.lat, p.lon);
 }
 
-function minDistance(locations, units) {
+function directDistance(locations, units) {
   units = units === 'miles' ? util.metersInMile : util.metersInKm;
-  return 0.9 * toLatLon(locations[0]).distanceTo(toLatLon(util.last(locations))) / units;
+  return locations.reduce((result, next) => {
+    next = toLatLon(next);
+    result.dist += result.ll.distanceTo(next);
+    result.ll = next;
+    return result;
+  }, {
+    dist: 0,
+    ll: toLatLon(locations[0])
+  }).dist / units;
 }
 
 function getStatus(err, response) {
@@ -130,10 +139,14 @@ function getStatus(err, response) {
   }
   st = response.trip && response.trip.status;
   if (st === 0) {
-    if (response.trip.legs && response.trip.legs.length &&
+    if (response.trip.legs && response.trip.legs.length) {
+      const { length, time } = response.trip.summary;
+      const distance = directDistance(response.trip.locations, response.trip.units);
       // make sure points are not too far from roads
-      response.trip.summary.length > minDistance(response.trip.locations, response.trip.units)) {
-      return status.success;
+      if (length > 0.9 * distance &&
+          (length < 10 * distance || time < maxRoundabout)) {
+        return status.success;
+      }
     }
     delete response.trip.legs;
     return status.empty;
@@ -169,7 +182,7 @@ function init(options) {
     if (query.avoidHighways) {
       req.costing_options[req.costing].use_highways = 0;
     } else {
-      req.costing_options[req.costing].use_highways = 1;
+      req.costing_options[req.costing].use_highways = 1.1;
     }
     vehicleSize(query, req.costing_options[req.costing]);
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@furkot/directions",
-  "version": "1.5.2",
+  "version": "2.0.1",
   "description": "Directions service for Furkot",
   "author": {
     "name": "Damian Krzeminski",
@@ -17,17 +17,13 @@
   "dependencies": {
     "@pirxpilot/google-polyline": "^3.0.0",
     "debug": "~2 || ~3 || ~4",
-    "fetchagent": "~2",
+    "fetchagent": "~2.1.0",
     "geodesy": "^1.1.1",
-    "limiter-component": "^1.0.0",
-    "run-series": "^1.1.4",
-    "run-waterfall-until": "~1",
+    "limiter-component": "^1.2.0",
     "vis-why": "^1.2.2"
   },
   "devDependencies": {
     "jshint": "~2",
-    "lodash.clonedeep": "^4.5.0",
-    "lodash.clonedeepwith": "^4.5.0",
     "mocha": "~10",
     "should": "~13",
     "sinon": "~14"