@qikdev/sdk 0.1.169 → 0.1.170

package/src/api/qik.socket.js

@@ -0,0 +1,360 @@
+import { EventDispatcher } from "./qik.utils.js";
+
+///////////////////////////////////////////////////
+
+/**
+ * Creates a new instance of QikSocket a module of the SDK
+ * that contains all helper functions to do with realtime sockets
+ * @name socket
+ * @constructor
+ * @hideconstructor
+ * @param {QikAPI} qik A reference to the parent instance of the QikCore module. This module is usually created by a QikCore instance that passes itself in as the first argument.
+ */
+
+const QikSocket = function (qik, mode) {
+  mode = mode || "production";
+
+  if (!qik.auth) {
+    throw new Error(`Can't Instantiate QikSocket before QikAuth exists`);
+  }
+
+  const windowID = qik.utils.guid();
+
+  ///////////////////////////////////////////////////
+
+  let service = {
+    debug: false,
+    url: `wss://iqtm6zjz3l.execute-api.ap-southeast-2.amazonaws.com/${mode}`,
+    connected: false,
+    windowID,
+    autoreconnect: true,
+  };
+
+  let socket;
+  let timer;
+  let buckets = {};
+  const channels = {};
+
+  //Create a new dispatcher
+  const dispatcher = new EventDispatcher();
+  dispatcher.bootstrap(service);
+
+  ///////////////////////////////////////////////////
+
+  function getSubscriptions() {
+    return Object.keys(buckets);
+  }
+
+  ///////////////////////////////////////////////////
+
+  /**
+   * @description Create an event dispatcher instance and subscribe to a new socket channel.
+   * This can then be used to receive socket events for this channel
+   * @alias socket.channel
+   * @param  {String} key The key or name of the channel to subscribe to
+   * @example
+   * const socketChannel = await sdk.socket.channel('awesome:notifications')
+   * socketChannel.addEventListener('message', function(message) {
+   *    console.log('Received a new message from the socket')
+   * })
+   *
+   * // Disconnect from this channel and remove all listeners
+   * socketChannel.destroy();
+   *
+   */
+  service.channel = async function (key) {
+    if (!buckets[key]) {
+      // Create a new channel instance
+      const bucket = new EventDispatcher();
+      buckets[key] = bucket;
+
+      // If the user isn't online
+      if (!service.connected) {
+        // Connect them now
+        await service.connect();
+      }
+
+      // Subscribe to this key
+      service.subscribe(key);
+
+      // Listen for all relevant events
+      service.addEventListener(key, dispatchMessage);
+
+      function dispatchMessage(message) {
+        bucket.dispatch("message", message);
+      }
+
+      // Destroy the service
+      bucket.destroy = function () {
+        if (buckets[key]) {
+          buckets[key].removeAllListeners();
+          service.unsubscribe(key);
+          buckets[key] = null;
+        }
+      };
+    }
+
+    // Return the channel instance
+    return buckets[key];
+  };
+
+  ///////////////////////////////////////////////////
+
+  function ping() {
+    broadcast({
+      action: "ping",
+    });
+  }
+
+  function startHeartbeat() {
+    if (timer) {
+      return;
+    }
+    timer = setInterval(ping, 10000);
+  }
+
+  function stopHeartbeat() {
+    if (!timer) {
+      return;
+    }
+
+    clearInterval(timer);
+    timer = null;
+  }
+
+  ///////////////////////////////////////////////////
+
+  function socketOpened(event) {
+    service.debug ? console.log("[socket] Connection open", event) : null;
+    service.connected = true;
+
+    dispatcher.dispatch("connected", event);
+
+    // startHeartbeat();
+  }
+
+  async function socketClosed(event) {
+    if (event.wasClean) {
+      service.debug
+        ? console.log(
+            `[socket] Connection closed cleanly, code=${event.code} reason=${event.reason}`,
+          )
+        : null;
+    } else {
+      // e.g. server process killed or network down
+      // event.code is usually 1006 in this case
+      service.debug
+        ? console.log("[socket] - connection closed due to error", event)
+        : null;
+    }
+
+    service.connected = false;
+    dispatcher.dispatch("disconnected", event);
+    socket = null;
+
+    if (service.autoreconnect) {
+      service.reconnect();
+    }
+  }
+
+  function socketError(error) {
+    console.log("[event] socketError", event);
+    service.debug ? console.log("[socket] Error", error) : null;
+    dispatcher.dispatch("error", error);
+  }
+
+  function socketMessageReceived(event) {
+    const eventData = JSON.parse(event.data);
+    service.debug ? console.log("[socket] message received", eventData) : null;
+
+    // Dispatch a generic message
+    dispatcher.dispatch("message", eventData);
+
+    if (eventData.channel) {
+      dispatcher.dispatch(eventData.channel, eventData);
+    }
+  }
+
+  async function broadcast(data) {
+    socket.send(JSON.stringify(data));
+  }
+
+  ///////////////////////////////////////////////////
+
+  function wait() {
+    return new Promise(function (resolve) {
+      function check() {
+        if (service.connected) {
+          return resolve(socket);
+        }
+
+        setTimeout(check, 1000);
+      }
+
+      check();
+    });
+  }
+
+  ///////////////////////////////////////////////////
+
+  /**
+   * @description Connect to the socket service
+   * @alias socket.connect
+   * @example
+   * const connected = await sdk.socket.connect()
+   *
+   */
+  service.connect = async function () {
+    if (socket) {
+      if (!socket.connected) {
+        return wait();
+      }
+
+      console.log("[socket] - Socket is already connected");
+      return socket;
+    }
+
+    const accessToken = qik.auth.getCurrentToken();
+
+    if (!accessToken) {
+      service.debug
+        ? console.log("[socket] - Must be authenticated to connect to socket")
+        : null;
+      return;
+    }
+
+    socket = new WebSocket(
+      `${service.url}?access_token=${accessToken}&windowid=${windowID}`,
+    );
+    socket.addEventListener("close", socketClosed);
+    socket.addEventListener("error", socketError);
+    socket.addEventListener("open", socketOpened);
+    socket.addEventListener("message", socketMessageReceived);
+    service.debug
+      ? console.log("[socket] - Connected with event listeners")
+      : null;
+
+    return wait();
+  };
+
+  /**
+   * @description Reconnect to the socket service
+   * @alias socket.reconnect
+   * @example
+   * const connected = await sdk.socket.reconnect()
+   *
+   */
+  service.reconnect = async function () {
+    if (service.connected) {
+      return;
+    }
+
+    service.debug ? console.log(`[socket] reconnecting...`) : null;
+
+    // Reconnect all listeners
+    const result = await service.connect();
+
+    // Resubscribe to all previously connected channels
+    const subscribedChannels = Object.keys(channels);
+    subscribedChannels.forEach(function (channel) {
+      service.subscribe(channel);
+    });
+
+    return result;
+  };
+
+  ///////////////////////////////////////////////////
+
+  /**
+   * @description Close the connection to the socket service
+   * @alias socket.close
+   * @example
+   * const closed = await sdk.socket.close()
+   *
+   */
+  service.close = async function () {
+    if (!socket) {
+      console.log("[socket] - Socket is not connected");
+      return;
+    }
+
+    const previousSetting = service.autoreconnect;
+    service.autoreconnect = false;
+    socket.close();
+    socket.removeEventListener("close", socketClosed);
+    socket.removeEventListener("error", socketError);
+    socket.removeEventListener("open", socketOpened);
+    socket.removeEventListener("message", socketMessageReceived);
+    socket = null;
+    socketClosed({ wasClean: true });
+    service.autoreconnect = previousSetting;
+  };
+
+  service.disconnect = service.close;
+
+  ///////////////////////////////////////////////////
+
+  /**
+   * @description Subscribe to a socket channel
+   * @alias socket.subscribe
+   * @param  {String} key The name of the channel to subscribe to
+   * @example
+   * const subscribed = await sdk.socket.subscribe('some:cool:alert')
+   *
+   */
+  service.subscribe = async function (channel) {
+    if (!socket) {
+      console.log(
+        `[socket] - Can't subscribe to channel as socket is not connected`,
+      );
+      return;
+    }
+
+    broadcast({
+      action: "subscribe",
+      channel,
+    });
+
+    channels[channel] = true;
+
+    dispatcher.dispatch("subscribe", channel);
+    service.debug ? console.log(`[socket] - subscribed to ${channel}`) : null;
+  };
+
+  ///////////////////////////////////////////////////
+
+  /**
+   * @description Unsubscribe from a socket channel
+   * @alias socket.unsubscribe
+   * @param  {String} key The name of the channel to unsubscribe from
+   * @example
+   * const unsubscribed = await sdk.socket.unsubscribe('some:cool:alert')
+   *
+   */
+  service.unsubscribe = async function (channel) {
+    if (!socket) {
+      console.log(
+        `[socket] - Can't unsubscribe from channel as socket is not connected`,
+      );
+      return;
+    }
+
+    broadcast({
+      action: "unsubscribe",
+      channel,
+    });
+
+    delete channels[channel];
+
+    dispatcher.dispatch("unsubscribe", channel);
+    service.debug
+      ? console.log(`[socket] - unsubscribed from ${channel}`)
+      : null;
+  };
+
+  ///////////////////////////////////////////////////
+
+  return service;
+};
+
+export default QikSocket;

package/src/api/qik.system.js

@@ -0,0 +1,49 @@
+///////////////////////////////////////////////////
+
+/**
+ * Creates a new QikSystem instance.
+ * This module provides a number of helper functions for the system
+ * @alias system
+ * @constructor
+ * @hideconstructor
+ * @param {QikCore} qik A reference to the parent instance of the QikCore module. This module is usually created by a QikCore instance that passes itself in as the first argument.
+ */
+export default function(qik) {
+
+    ///////////////////////////////////////////////////
+
+    var service = {}
+
+
+    ///////////////////////////////////////////////////////////////////////////////
+
+    var inflightCountries;
+
+    /**
+     * @alias system.countries
+     * @description Helper function for retrieving a full list of all countries, their ISO codes
+     * and phone number prefixes. Helpful for populating dropdown lists.
+     * @example
+     * const countries = await sdk.system.countries()
+     */
+    service.countries = async function() {
+
+        if (!inflightCountries) {
+
+            inflightCountries = new Promise(async function(resolve, reject) {
+                qik.api.get(`/system/countries`)
+                    .then(function(res) {
+                        return resolve(res.data);
+                    })
+                    .catch(reject);
+            })
+        }
+
+        return inflightCountries;
+    }
+
+    ///////////////////////////////////////////////////
+
+    return service;
+
+}