mobility-toolbox-js 2.0.0-beta.8 → 2.0.1-beta.13

package/common/api/HttpAPI.js

@@ -0,0 +1,30 @@
+import qs from "query-string";
+import BaseObject from "ol/Object";
+class HttpApi extends BaseObject {
+  constructor(options = {}) {
+    super();
+    this.url = options.url;
+    this.apiKey = options.apiKey;
+  }
+  fetch(path, params, config) {
+    const urlParams = { ...params || {}, key: this.apiKey };
+    const clone = { ...urlParams };
+    Object.keys(urlParams).forEach((key) => (clone[key] === void 0 || clone[key] === null) && delete clone[key]);
+    if (!this.apiKey) {
+      return Promise.reject(new Error(`No apiKey defined for request to ${this.url}`));
+    }
+    return fetch(`${this.url}${path || ""}?${qs.stringify(clone)}`, config).then((response) => {
+      try {
+        return response.json().then((data) => {
+          if (data.error) {
+            throw new Error(data.error);
+          }
+          return data;
+        });
+      } catch (err) {
+        return Promise.reject(new Error(err));
+      }
+    });
+  }
+}
+export default HttpApi;

package/common/api/HttpAPI.test.js

@@ -0,0 +1,50 @@
+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" }));
+      return api.fetch("/path", {
+        q: "Bern",
+        fooUndefined: void 0,
+        fooNull: null,
+        fooEmpty: ""
+      }).then((response) => {
+        expect(fetch.mock.calls[0][0]).toEqual("https://foo.ch/path?fooEmpty=&key=apiKey&q=Bern");
+        expect(response).toEqual({ foo: "bar" });
+      });
+    });
+    describe("should display error message", () => {
+      test("reject error", (done) => {
+        fetch.mockRejectOnce(new Error("Fake error message"));
+        return 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).toEqual("invalid json response body at  reason: Unexpected token i in JSON at position 0");
+          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/common/api/WebSocketAPI.js

@@ -0,0 +1,175 @@
+class WebSocketApi {
+  constructor() {
+    this.defineProperties();
+  }
+  defineProperties() {
+    Object.defineProperties(this, {
+      closed: {
+        get: () => !!(this.websocket && this.websocket.readyState === this.websocket.CLOSED)
+      },
+      closing: {
+        get: () => !!(this.websocket && this.websocket.readyState === this.websocket.CLOSING)
+      },
+      connecting: {
+        get: () => !!(this.websocket && this.websocket.readyState === this.websocket.CONNECTING)
+      },
+      open: {
+        get: () => !!(this.websocket && this.websocket.readyState === this.websocket.OPEN)
+      },
+      messagesOnOpen: {
+        value: [],
+        writable: true
+      },
+      subscriptions: {
+        value: [],
+        writable: true
+      },
+      subscribed: {
+        value: {},
+        writable: true
+      }
+    });
+  }
+  static getRequestString(method, params) {
+    let reqStr = `${method} ${params.channel}`;
+    reqStr += params.args ? ` ${params.args}` : "";
+    reqStr += params.id ? ` ${params.id}` : "";
+    return reqStr.trim();
+  }
+  connect(url, onOpen = () => {
+  }) {
+    if (this.websocket && !this.closed) {
+      this.websocket.close();
+    }
+    this.websocket = new WebSocket(url);
+    if (!this.open) {
+      this.websocket.addEventListener("open", () => {
+        onOpen();
+        this.subscribePreviousSubscriptions();
+      });
+    } else {
+      onOpen();
+      this.subscribePreviousSubscriptions();
+    }
+  }
+  close() {
+    if (this.websocket) {
+      this.websocket.onclose = null;
+      this.websocket.close();
+      this.websocket = null;
+      this.messagesOnOpen = [];
+    }
+  }
+  send(message) {
+    if (!this.websocket) {
+      return;
+    }
+    const send = () => {
+      this.websocket.send(message);
+    };
+    if (!this.open) {
+      if (!this.messagesOnOpen.includes(message)) {
+        this.messagesOnOpen.push(message);
+        this.websocket.addEventListener("open", () => {
+          this.messagesOnOpen = [];
+          send();
+        });
+        this.websocket.addEventListener("close", () => {
+          this.messagesOnOpen = [];
+        });
+      }
+    } else if (!this.messagesOnOpen.includes(message)) {
+      send();
+    }
+  }
+  listen(params, cb, errorCb) {
+    this.unlisten(params, cb);
+    const onMessage = (evt) => {
+      let data = {};
+      try {
+        data = JSON.parse(evt.data);
+      } catch (err) {
+        console.error("WebSocket: unable to parse JSON data", err, evt.data);
+      }
+      let source = params.channel;
+      source += params.args ? ` ${params.args}` : "";
+      const contents = data.source === "buffer" ? data.content : [data];
+      contents.forEach((content) => {
+        if (content?.source === source && (!params.id || params.id === data.client_reference)) {
+          cb(content);
+        }
+      });
+    };
+    if (this.websocket) {
+      this.websocket.addEventListener("message", onMessage);
+      if (errorCb) {
+        this.websocket.addEventListener("error", errorCb);
+        this.websocket.addEventListener("close", errorCb);
+      }
+    }
+    return { onMessageCb: onMessage, onErrorCb: errorCb };
+  }
+  unlisten(params, cb) {
+    if (!this.websocket) {
+      return;
+    }
+    this.subscriptions.filter((s) => s.params.channel === params.channel && (!cb || s.cb === cb)).forEach(({ onMessageCb, onErrorCb }) => {
+      if (this.websocket) {
+        this.websocket.removeEventListener("message", onMessageCb);
+        if (onErrorCb) {
+          this.websocket.removeEventListener("error", onErrorCb);
+          this.websocket.removeEventListener("close", onErrorCb);
+        }
+      }
+    });
+  }
+  get(params, cb, errorCb) {
+    const reqStr = WebSocketApi.getRequestString("GET", params);
+    this.send(reqStr);
+    this.listen(params, cb, errorCb);
+  }
+  subscribe(params, cb, errorCb, quiet = false) {
+    const { onMessageCb, onErrorCb } = this.listen(params, cb, errorCb);
+    const reqStr = WebSocketApi.getRequestString("", params);
+    const index = this.subscriptions.findIndex((subcr) => params.channel === subcr.params.channel && cb === subcr.cb);
+    const newSubscr = { params, cb, errorCb, onMessageCb, onErrorCb, quiet };
+    if (index > -1) {
+      this.subscriptions[index] = newSubscr;
+    } else {
+      this.subscriptions.push(newSubscr);
+    }
+    if (!this.subscribed[reqStr]) {
+      if (!newSubscr.quiet) {
+        this.send(`GET ${reqStr}`);
+        this.send(`SUB ${reqStr}`);
+      }
+      this.subscribed[reqStr] = true;
+    }
+  }
+  unsubscribe(source, cb) {
+    const toRemove = this.subscriptions.filter((s) => s.params.channel === source && (!cb || s.cb === cb));
+    toRemove.forEach(({ onMessageCb, onErrorCb }) => {
+      if (this.websocket) {
+        this.websocket.removeEventListener("message", onMessageCb);
+        if (onErrorCb) {
+          this.websocket.removeEventListener("error", onErrorCb);
+          this.websocket.removeEventListener("close", onErrorCb);
+        }
+      }
+    });
+    this.subscriptions = this.subscriptions.filter((s) => s.params.channel !== source || cb && s.cb !== cb);
+    if (source && this.subscribed[source] && !this.subscriptions.find((s) => s.params.channel === source) && toRemove.find((subscr) => !subscr.quiet)) {
+      this.send(`DEL ${source}`);
+      this.subscribed[source] = false;
+    }
+  }
+  subscribePreviousSubscriptions() {
+    Object.keys(this.subscribed).forEach((key) => {
+      this.subscribed[key] = false;
+    });
+    [...this.subscriptions].forEach((s) => {
+      this.subscribe(s.params, s.cb, s.errorCb, s.quiet);
+    });
+  }
+}
+export default WebSocketApi;