@wemap/routers 7.2.0 → 7.2.2

package/src/remote/RemoteRouterUtils.js

@@ -1,6 +1,10 @@
+import { NoRouteFoundError } from '@wemap/geo';
 import { diffAngle } from '@wemap/maths';
 
 import Itinerary from '../model/Itinerary.js';
+import IdfmRemoteRouterTokenError from './idfm/IdfmRemoteRouterTokenError.js';
+import RemoteRouterServerUnreachable from './RemoteRouterServerUnreachable.js';
+import RoutingModeCorrespondanceNotFound from './RoutingModeCorrespondanceNotFound.js';
 
 
 /**
@@ -76,3 +80,10 @@ export function dateWithTimeZone(year, month, day, hour, minute, second, timeZon
 
     return date;
 }
+
+export function isRoutingError(e) {
+    return e instanceof RemoteRouterServerUnreachable
+        || e instanceof RoutingModeCorrespondanceNotFound
+        || e instanceof IdfmRemoteRouterTokenError
+        || e instanceof NoRouteFoundError;
+}

package/src/remote/idfm/IdfmRemoteRouter.js

@@ -103,14 +103,29 @@ class IdfmRemoteRouter extends RemoteRouter {
 
         const url = this.getURL(endpointUrl, mode, waypoints);
 
-        const res = await fetch(url, {
+        const res = await (fetch(url, {
             method: 'GET',
             headers: { Authorization: 'Bearer ' + this.token }
-        });
-        if (res.status !== 200) {
+        }).catch(() => {
+            throw new RemoteRouterServerUnreachable(this.rname, url);
+        }));
+
+
+        const response = await res.json().catch(() => {
             throw new RemoteRouterServerUnreachable(this.rname, url);
+        });
+
+        // When IDFM failed to calculate an itinerary (ie. start or end
+        // point is far from network), it respond a 404 with an error message
+        // or a 200 with an error message
+        if (response && response.error) {
+            const routerResponse = new RouterResponse();
+            routerResponse.routerName = this.rname;
+            routerResponse.from = waypoints[0];
+            routerResponse.to = waypoints[1];
+            routerResponse.error = response.error.message || 'no details.';
+            return routerResponse;
         }
-        const response = await res.json();
 
         return this.createRouterResponseFromJson(response);
     }

package/src/wemap-meta/WemapMetaRouter.js

@@ -7,6 +7,7 @@ import Logger from '@wemap/logger';
 import IOMap from './IOMap.js';
 import WemapMetaRouterOptions from './WemapMetaRouterOptions.js';
 import RemoteRouterManager from '../remote/RemoteRouterManager.js';
+import { isRoutingError } from '../remote/RemoteRouterUtils.js';
 import WemapMetaRemoteRouterOptions from '../remote/wemap-meta/WemapMetaRemoteRouterOptions.js';
 import WemapRouterOptions from '../wemap/WemapRouterOptions.js';
 import RouterResponse from '../model/RouterResponse.js';
@@ -63,6 +64,12 @@ class WemapMetaRouter {
         const start = waypoints[0];
         const end = waypoints[1];
 
+        const routerResponse = new RouterResponse();
+        routerResponse.routerName = this.rname;
+        routerResponse.from = start;
+        routerResponse.to = end;
+
+
         // Avoid cycles on remoteRouters
         const remoteRouters = options.remoteRouters.filter(
             ({ name }) => name !== WemapMetaRemoteRouterOptions.rname
@@ -101,7 +108,15 @@ class WemapMetaRouter {
          * 3 - intersection of this.maps and options.targetMaps is empty
          */
         if (!ioMapsToTest.length) {
-            return RemoteRouterManager.getItinerariesWithFallback(remoteRouters, mode, waypoints);
+            try {
+                return await RemoteRouterManager.getItinerariesWithFallback(remoteRouters, mode, waypoints);
+            } catch (e) {
+                if (!isRoutingError(e)) {
+                    throw e;
+                }
+                routerResponse.error = e.message;
+                return routerResponse;
+            }
         }
 
 
@@ -114,10 +129,6 @@ class WemapMetaRouter {
          *
          */
 
-        const routerResponse = new RouterResponse();
-        routerResponse.from = start;
-        routerResponse.to = end;
-
         /** @type {Itinerary} */
         let ioMapItinerary;
 
@@ -139,7 +150,7 @@ class WemapMetaRouter {
             try {
                 ioMapItinerary = mapWithStart.getItineraryInsideMap(start, end, wemapRouterOptions);
             } catch (e) {
-                if (!(e instanceof NoRouteFoundError)) {
+                if (!isRoutingError(e)) {
                     throw e;
                 }
                 routerResponse.error = `${e.message} - on map ${mapWithStart.name}.`;
@@ -156,19 +167,27 @@ class WemapMetaRouter {
         // Note: At this step, mapWithEnd is necessarily different from mapWithStart
         const mapWithEnd = ioMapsToTest.find(map => map.isPointInside(end));
 
+
+        /** @type {RouterResponse} */
+        let remoteRouterResponse;
+
         /*
          * Case 2
          *
          * If no io map have been found for "start" and "end", therefore use remote router.
          */
         if (!mapWithStart && !mapWithEnd) {
-            return RemoteRouterManager.getItinerariesWithFallback(remoteRouters, mode, waypoints);
+            try {
+                return await RemoteRouterManager.getItinerariesWithFallback(remoteRouters, mode, waypoints);
+            } catch (e) {
+                if (!isRoutingError(e)) {
+                    throw e;
+                }
+                routerResponse.error = e.message;
+                return routerResponse;
+            }
         }
 
-        /** @type {RouterResponse} */
-        let remoteRouterResponse;
-
-
         /**
          * Case 3
          *
@@ -192,23 +211,21 @@ class WemapMetaRouter {
 
             try {
                 ioMapItinerary = mapWithStart.getBestItineraryFromStartToEntryPoints(start, end, wemapRouterOptions);
+                remoteRouterResponse = await RemoteRouterManager.getItinerariesWithFallback(
+                    remoteRouters, mode, [ioMapItinerary.to, end]
+                );
+                if (!remoteRouterResponse.itineraries.length) {
+                    throw new NoRouteFoundError(ioMapItinerary.to, end, remoteRouterResponse.error);
+                }
             } catch (e) {
-                if (!(e instanceof NoRouteFoundError)) {
+                if (!isRoutingError(e)) {
                     throw e;
                 }
-                routerResponse.error = `${e.message} - on map ${mapWithStart.name}.`;
-                return routerResponse;
-            }
-            remoteRouterResponse = await RemoteRouterManager.getItinerariesWithFallback(
-                remoteRouters, mode, [ioMapItinerary.to, end]
-            );
-
-
-            if (!remoteRouterResponse.itineraries.length) {
-                routerResponse.error = `Tried to calculate an itinerary from "start" 
-                    to "entrypoints" using wemap router on local map "${mapWithStart.name}" and
-                    an itinerary from  "entrypoints" to "end" using remote routers 
-                    (${remoteRouters.map(r => r.name).join(', ')}), but failed.`;
+                routerResponse.error = 'Tried to calculate an itinerary from "start" '
+                    + `to "entrypoints" using wemap router on local map "${mapWithStart.name}" and `
+                    + 'an itinerary from  "entrypoints" to "end" using remote routers '
+                    + `(${remoteRouters.map(r => r.name).join(', ')}), but failed. `
+                    + `Details: ${e.message}.`;
                 return routerResponse;
             }
 
@@ -248,22 +265,21 @@ class WemapMetaRouter {
              */
             try {
                 ioMapItinerary = mapWithEnd.getBestItineraryFromEntryPointsToEnd(start, end, wemapRouterOptions);
+                remoteRouterResponse = await RemoteRouterManager.getItinerariesWithFallback(
+                    remoteRouters, mode, [start, ioMapItinerary.from]
+                );
+                if (!remoteRouterResponse.itineraries.length) {
+                    throw new NoRouteFoundError(start, ioMapItinerary.from, remoteRouterResponse.error);
+                }
             } catch (e) {
-                if (!(e instanceof NoRouteFoundError)) {
+                if (!isRoutingError(e)) {
                     throw e;
                 }
-                routerResponse.error = `${e.message} - on map ${mapWithEnd.name}.`;
-                return routerResponse;
-            }
-            remoteRouterResponse = await RemoteRouterManager.getItinerariesWithFallback(
-                remoteRouters, mode, [start, ioMapItinerary.from]
-            );
-
-            if (!remoteRouterResponse.itineraries.length) {
-                routerResponse.error = `Tried to calculate an itinerary from "start" to "entrypoints" 
-                    using remote routers (${remoteRouters.map(r => r.name).join(', ')}) and an
-                    itinerary from "entrypoints" to "end" using wemap router on local map
-                    "${mapWithEnd.name}", but failed.`;
+                routerResponse.error = 'Tried to calculate an itinerary from "start" to "entrypoints" '
+                    + `using remote routers (${remoteRouters.map(r => r.name).join(', ')}) and an `
+                    + 'itinerary from "entrypoints" to "end" using wemap router on local map '
+                    + `"${mapWithEnd.name}", but failed. `
+                    + `Details: ${e.message}.`;
                 return routerResponse;
             }
 
@@ -306,32 +322,23 @@ class WemapMetaRouter {
         let ioMapItinerary1, ioMapItinerary2;
         try {
             ioMapItinerary1 = mapWithStart.getBestItineraryFromStartToEntryPoints(start, end, wemapRouterOptions);
-        } catch (e) {
-            if (!(e instanceof NoRouteFoundError)) {
-                throw e;
-            }
-            routerResponse.error = `${e.message} - on map ${mapWithStart.name}.`;
-            return routerResponse;
-        }
-        try {
             ioMapItinerary2 = mapWithEnd.getBestItineraryFromEntryPointsToEnd(start, end, wemapRouterOptions);
+            remoteRouterResponse = await RemoteRouterManager.getItinerariesWithFallback(
+                remoteRouters, mode, [ioMapItinerary1.to, ioMapItinerary2.from]
+            );
+            if (!remoteRouterResponse.itineraries.length) {
+                throw new NoRouteFoundError(ioMapItinerary1.to, ioMapItinerary2.from, remoteRouterResponse.error);
+            }
         } catch (e) {
-            if (!(e instanceof NoRouteFoundError)) {
+            if (!isRoutingError(e)) {
                 throw e;
             }
-            routerResponse.error = `${e.message} - on map ${mapWithEnd.name}.`;
-            return routerResponse;
-        }
-        remoteRouterResponse = await RemoteRouterManager.getItinerariesWithFallback(
-            remoteRouters, mode, [ioMapItinerary1.to, ioMapItinerary2.from]
-        );
-
-        if (!remoteRouterResponse.itineraries.length) {
-            routerResponse.error = `Tried to calculate an itinerary from "start" to "entrypoints1" 
-                using wemap router on local map  "${mapWithStart.name}", an itinerary from
-                "entrypoints1" to "entrypoints2" using remote routers 
-                (${remoteRouters.map(r => r.name).join(', ')}) and an itinerary from "entrypoints2" 
-                to "end" using wemap router on local map "${mapWithEnd.name}", but failed.`;
+            routerResponse.error = 'Tried to calculate an itinerary from "start" to "entrypoints1" '
+                + `using wemap router on local map  "${mapWithStart.name}", an itinerary from `
+                + '"entrypoints1" to "entrypoints2" using remote routers '
+                + `(${remoteRouters.map(r => r.name).join(', ')}) and an itinerary from "entrypoints2" `
+                + `to "end" using wemap router on local map "${mapWithEnd.name}", but failed. `
+                + `Details: ${e.message}.`;
             return routerResponse;
         }