mobility-toolbox-js 2.3.9 → 2.3.10

package/src/api/RoutingAPI.test.js

@@ -0,0 +1,41 @@
+import fetch from 'jest-fetch-mock';
+import RoutingAPI from './RoutingAPI';
+
+let api;
+
+describe('RoutingAPI', () => {
+  beforeEach(() => {
+    global.fetch = fetch;
+    fetch.resetMocks();
+
+    api = new RoutingAPI({ apiKey: 'apiKey' });
+  });
+
+  describe('#route', () => {
+    test('should success', (done) => {
+      fetch.mockResponseOnce(JSON.stringify(global.fetchRouteResponse));
+
+      api
+        .route({
+          mot: 'bus',
+          via: '47.3739194713294,8.538274823394632|47.37595378493421,8.537490375951839',
+        })
+        .then((featureCollection) => {
+          // Correct url
+          expect(fetch.mock.calls[0][0]).toEqual(
+            'https://api.geops.io/routing/v1/?key=apiKey&mot=bus&via=47.3739194713294%2C8.538274823394632%7C47.37595378493421%2C8.537490375951839',
+          );
+
+          // Correct search result (for bus mot)
+          expect(featureCollection.features[0].geometry.type).toEqual(
+            'LineString',
+          );
+          expect(featureCollection.features[0].properties.lines).toBeDefined();
+          expect(
+            featureCollection.features[0].properties.station_to,
+          ).toBeDefined();
+          done();
+        });
+    });
+  });
+});

package/src/api/RoutingAPI.ts

@@ -0,0 +1,47 @@
+import HttpAPI from '../common/api/HttpAPI';
+import { RoutingParameters, RoutingResponse } from '../types';
+
+export type RoutingAPIOptions = {
+  url?: string;
+  apiKey?: string;
+};
+
+/**
+ * Access to the [geOps Routing service](https://developer.geops.io/apis/routing).
+ *
+ * @example
+ * import { RoutingAPI } from 'mobility-toolbox-js';
+ *
+ * const api = new RoutingAPI({
+ *   apiKey: [yourApiKey]
+ * });
+ *
+ */
+class RoutingAPI extends HttpAPI {
+  /**
+   * Constructor
+   *
+   * @param {RoutingAPIOptions} options Options.
+   * @param {string} [options.url='https://api.geops.io/routing/v1/'] Service url.
+   * @param {string} options.apiKey Access key for [geOps services](https://developer.geops.io/).
+   */
+  constructor(options: RoutingAPIOptions = {}) {
+    super({ url: 'https://api.geops.io/routing/v1/', ...options });
+  }
+
+  /**
+   * Route.
+   *
+   * @param {RoutingParameters} params Request parameters. See [Routing service documentation](https://developer.geops.io/apis/routing/).
+   * @param {RequestInit} config Options for the fetch request.
+   * @return {Promise<RoutingResponse>} An GeoJSON feature collection with coordinates in [EPSG:4326](http://epsg.io/4326).
+   */
+  route(
+    params: RoutingParameters,
+    config: RequestInit,
+  ): Promise<RoutingResponse> {
+    return this.fetch('', params, config);
+  }
+}
+
+export default RoutingAPI;

package/src/api/StopsAPI.test.js

@@ -0,0 +1,34 @@
+import fetch from 'jest-fetch-mock';
+import StopsAPI from './StopsAPI';
+
+let api;
+
+describe('StopsAPI', () => {
+  beforeEach(() => {
+    global.fetch = fetch;
+    fetch.resetMocks();
+
+    api = new StopsAPI({ apiKey: 'apiKey' });
+  });
+
+  describe('#search', () => {
+    test('should success', (done) => {
+      fetch.mockResponseOnce(JSON.stringify(global.stopsSearchResponse));
+
+      api
+        .search({
+          q: 'Bern',
+        })
+        .then((featureCollection) => {
+          // Correct url
+          expect(fetch.mock.calls[0][0]).toEqual(
+            'https://api.geops.io/stops/v1/?key=apiKey&q=Bern',
+          );
+
+          // Correct search result
+          expect(featureCollection.features[0].properties.name).toEqual('Bern');
+          done();
+        });
+    });
+  });
+});

package/src/api/StopsAPI.ts

@@ -0,0 +1,45 @@
+import HttpAPI from '../common/api/HttpAPI';
+import { StopsParameters, StopsResponse } from '../types';
+
+export type StopsAPIOptions = {
+  url?: string;
+  apiKey?: string;
+};
+
+/**
+ * Access to the [Stops service](https://developer.geops.io/apis/5dcbd702a256d90001cf1361/).
+ *
+ * @example
+ * import { StopsAPI } from 'mobility-toolbox-js/api';
+ *
+ * const api = new StopsAPI({
+ *   url: 'https://api.geops.io/stops/v1/',
+ *   apiKey: [yourApiKey]
+ * });
+ *
+ */
+class StopsAPI extends HttpAPI {
+  /**
+   * Constructor
+   *
+   * @param {StopsAPIOptions} options Options.
+   * @param {string} [options.url='https://api.geops.io/stops/v1/'] Service url.
+   * @param {string} options.apiKey Access key for [geOps services](https://developer.geops.io/).
+   */
+  constructor(options: StopsAPIOptions = {}) {
+    super({ url: 'https://api.geops.io/stops/v1/', ...options });
+  }
+
+  /**
+   * Search fo stops.
+   *
+   * @param {StopsParameters} params Request parameters. See [Stops service documentation](https://developer.geops.io/apis/stops).
+   * @param {RequestInit} config Options for the fetch request.
+   * @return {Promise<StopsResponse>} An GeoJSON feature collection with coordinates in [EPSG:4326](http://epsg.io/4326).
+   */
+  search(params: StopsParameters, config: RequestInit): Promise<StopsResponse> {
+    return this.fetch('', params, config);
+  }
+}
+
+export default StopsAPI;

package/{api → src/api}/typedefs.js

@@ -25,11 +25,13 @@
  * @property {number} timediff Timestamp in ms.
  *
  */
+
 /**
  * @typedef {GeoJSONFeature} Station
  * @property {StationProperties} properties Returns the station's properties.
  * @property {GeoJSONPoint} geometry Returns a point.
  */
+
 /**
  * @typedef {Object} StationProperties
  * @property {Transfer[]} transfers
@@ -42,6 +44,7 @@
  * @property {boolean} hasAccessibility
  * @property {string} type
  */
+
 /**
  * @typedef {Object} NetworkLine
  * @property {number} id Identifier of the line.
@@ -50,26 +53,33 @@
  * @property {string} name Name of the line.
  * @property {string} text_color  Text color of the line  (CSS color string).
  */
+
 /**
  * @typedef {Object} Transfer
  * @property {string} mot Mode of transportation (ex: U-Bahn).
  * @property {string[]} lines Array of lines name (ex: ["U4", "U5"]).
  */
+
 /**
  * @typedef {GeoJSONFeature} StopSequence
  */
+
 /**
  * @typedef {GeoJSONFeature} RealtimeTrajectory
  */
+
 /**
  * @typedef {GeoJSONFeature} FullTrajectory
  */
+
 /**
  * @typedef {GeoJSONFeature} Vehicle
  */
+
 /**
  * @typedef {GeoJSONFeature} ExtraGeom
  */
+
 // These lines is to block TypeScript to add "use strict;" in the outputed file.
-const dummy = () => { };
+const dummy = () => {};
 export default dummy;

package/src/common/api/HttpAPI.test.js

@@ -0,0 +1,68 @@
+import fetch from 'jest-fetch-mock';
+import API from './HttpAPI';
+
+let api;
+
+describe('HttpAPI', () => {
+  beforeEach(() => {
+    global.fetch = fetch;
+    fetch.resetMocks();
+
+    api = new API({ url: 'https://foo.ch', apiKey: 'apiKey' });
+  });
+
+  describe('#fetch', () => {
+    test('should success', () => {
+      fetch.mockResponseOnce(JSON.stringify({ foo: 'bar' }));
+
+      api
+        .fetch('/path', {
+          q: 'Bern',
+          fooUndefined: undefined,
+          fooNull: null,
+          fooEmpty: '',
+        })
+        .then((response) => {
+          // Correct url
+          expect(fetch.mock.calls[0][0]).toEqual(
+            'https://foo.ch/path?key=apiKey&q=Bern&fooEmpty=',
+          );
+
+          // Correct search result
+          expect(response).toEqual({ foo: 'bar' });
+        });
+    });
+
+    describe('should display error message', () => {
+      test('reject error', (done) => {
+        fetch.mockRejectOnce(new Error('Fake error message'));
+        api.fetch().catch((err) => {
+          expect(err.name).toEqual('Error');
+          expect(err.message).toEqual('Fake error message');
+          done();
+        });
+      });
+
+      test('if the response is invalid json', (done) => {
+        fetch.mockResponseOnce('invalid json');
+
+        api.fetch().catch((err) => {
+          expect(err.name).toEqual('FetchError');
+          expect(err.message).toMatch(
+            'invalid json response body at  reason: Unexpected token',
+          );
+          done();
+        });
+      });
+
+      test('if the response contains an error message', (done) => {
+        fetch.mockResponseOnce('{"error":"foo2"}');
+        api.fetch().catch((err) => {
+          expect(err.name).toEqual('Error');
+          expect(err.message).toEqual('foo2');
+          done();
+        });
+      });
+    });
+  });
+});

package/src/common/api/HttpAPI.ts

@@ -0,0 +1,77 @@
+import BaseObject from 'ol/Object';
+import getUrlWithParams from '../utils/getUrlWithParams';
+
+export type HttpAPIOptions = {
+  url: string;
+  apiKey?: string;
+};
+/**
+ * Common class to access to a geOps api using http.
+ *
+ * @example
+ * import { API } from 'mobility-toolbox-js/api';
+ *
+ * const api = new HttpApi({
+ *   url: [yourUrl],
+ *   apiKey: [yourApiKey]
+ * });
+ *
+ * @classproperty {string} url Url of the service.
+ * @classproperty {string} apiKey Api key to access the service.
+ */
+class HttpAPI extends BaseObject {
+  url: string;
+
+  apiKey?: string;
+
+  constructor(options: HttpAPIOptions) {
+    super();
+    /** @private */
+    this.url = options.url;
+
+    /** @private */
+    this.apiKey = options.apiKey;
+  }
+
+  /**
+   * Append the apiKey before sending the request.
+   * @private
+   */
+  fetch(path: string, params: Object, config: RequestInit): Promise<any> {
+    if (!this.url) {
+      // eslint-disable-next-line no-console
+      return Promise.reject(
+        new Error(`No url defined for request to ${this.url}/${path}`),
+      );
+    }
+    if (!this.url && !this.apiKey && !/key=/.test(this.url)) {
+      // eslint-disable-next-line no-console
+      return Promise.reject(
+        new Error(`No apiKey defined for request to ${this.url}`),
+      );
+    }
+
+    // Clean requets parameters, removing undefined and null values.
+    const searchParams = params || {};
+    const url = getUrlWithParams(`${this.url}${path || ''}`, {
+      key: this.apiKey,
+      ...searchParams,
+    });
+
+    // We use toString  because of TYpeScript bug that only accept a string in fetch method.
+    return fetch(url.toString(), config).then((response) => {
+      try {
+        return response.json().then((data) => {
+          if (data.error) {
+            throw new Error(data.error);
+          }
+          return data;
+        });
+      } catch (err: any | Error) {
+        return Promise.reject(new Error(err));
+      }
+    });
+  }
+}
+
+export default HttpAPI;