pryv 2.1.8

package/src/Service.js

@@ -0,0 +1,197 @@
+
+const utils = require('./utils.js');
+// Connection is required at the end of this file to allow circular requires.
+const Assets = require('./ServiceAssets.js');
+
+
+/**
+ * @class Pryv.Service
+ * A Pryv.io deployment is a unique "Service", as an example **Pryv Lab** is a service, deployed with the domain name **pryv.me**.
+ * 
+ * `Pryv.Service` exposes tools to interact with Pryv.io at a "Platform" level. 
+ *
+ *  ##### Initizalization with a service info URL
+```javascript
+const service = new Pryv.Service('https://reg.pryv.me/service/info');
+```
+
+- With the content of a serviceInfo configuration
+
+Service information properties can be overriden with specific values. This might be usefull to test new designs on production platforms.
+
+```javascript
+const serviceInfoUrl = 'https://reg.pryv.me/service/info';
+const serviceCustomizations = {
+  name: 'Pryv Lab 2',
+  assets: {
+    definitions: 'https://pryv.github.io/assets-pryv.me/index.json'
+  }
+}
+const service = new Pryv.Service(serviceInfoUrl, serviceCustomizations);
+``` 
+
+ * @memberof Pryv
+ * 
+ * @constructor
+ * @param {string} serviceInfoUrl Url point to /service/info of a Pryv platform see: {@link https://api.pryv.com/reference/#service-info}
+ */
+class Service {
+
+  constructor (serviceInfoUrl, serviceCustomizations) {
+    this._pryvServiceInfo = null;
+    this._assets = null;
+    this._polling = false;
+    this._pryvServiceInfoUrl = serviceInfoUrl;
+    this._pryvServiceCustomizations = serviceCustomizations;
+  }
+
+  /**
+   * Return service info parameters info known of fetch it if needed.
+   * Example   
+   *  - name of a platform   
+   *    `const serviceName = await service.info().name` 
+   * @see PryvServiceInfo For details on available properties.
+   * @param {boolean?} forceFetch If true, will force fetching service info.
+   * @returns {Promise<PryvServiceInfo>} Promise to Service info Object
+   */
+  async info (forceFetch) {
+    if (forceFetch || !this._pryvServiceInfo) {
+      let baseServiceInfo = {};
+      if (this._pryvServiceInfoUrl) {
+        const res = await utils.superagent.get(this._pryvServiceInfoUrl).set('Access-Control-Allow-Origin', '*').set('accept', 'json');
+        baseServiceInfo = res.body;
+      }
+      Object.assign(baseServiceInfo, this._pryvServiceCustomizations);
+      this.setServiceInfo(baseServiceInfo);
+    }
+    return this._pryvServiceInfo;
+  }
+
+  /**
+   * @private
+   * @param {PryvServiceInfo} serviceInfo
+   */
+  setServiceInfo (serviceInfo) {
+    if (!serviceInfo.name) {
+      throw new Error('Invalid data from service/info');
+    }
+    // cleanup serviceInfo for eventual url not finishing by "/" 
+    // code will be obsolete with next version of register
+    ['access', 'api', 'register'].forEach((key) => {
+      if (serviceInfo[key].slice(-1) !== '/') {
+        serviceInfo[key] += '/';
+      }
+    });
+    this._pryvServiceInfo = serviceInfo;
+  }
+
+  /**
+   * Return assets property content
+   * @param {boolean?} forceFetch If true, will force fetching service info.
+   * @returns {Promise<ServiceAssets>} Promise to ServiceAssets 
+   */
+  async assets (forceFetch) {
+    if (!forceFetch && this._assets) {
+      return this._assets;
+    } else {
+      const serviceInfo = await this.info();
+      if (!serviceInfo.assets || !serviceInfo.assets.definitions) {
+        console.log('Warning: no assets for this service');
+        return null;
+      }
+      this._assets = await Assets.setup(serviceInfo.assets.definitions);
+      return this._assets;
+    }
+  }
+
+  /**
+   * Return service info parameters info known or null if not yet loaded
+   * @returns {PryvServiceInfo} Service Info definition
+   */
+  infoSync () {
+    return this._pryvServiceInfo;
+  }
+
+  /**
+   * Return an API Endpoint from a username and token
+   * @param {string} username
+   * @param {string} [token]
+   * @return {PryvApiEndpoint}
+   */
+  async apiEndpointFor (username, token) {
+    const serviceInfo = await this.info();
+    return Service.buildAPIEndpoint(serviceInfo, username, token);
+  }
+
+  /**
+   * Return an API Endpoint from a username and token and a PryvServiceInfo. 
+   * This is method is rarely used. See **apiEndpointFor** as an alternative.
+   * @param {PryvServiceInfo} serviceInfo
+   * @param {string} username
+   * @param {string} [token]
+   * @return {PryvApiEndpoint}
+   */
+  static buildAPIEndpoint (serviceInfo, username, token) {
+    const endpoint = serviceInfo.api.replace('{username}', username);
+    return utils.buildPryvApiEndpoint({ endpoint: endpoint, token: token });
+  }
+
+  /**
+   * Issue a "login call on the Service" return a Connection on success  
+   * **! Warning**: the token of the connection will be a "Personal" token that expires
+   * @see https://api.pryv.com/reference-full/#login-user
+   * @param {string} username 
+   * @param {string} password 
+   * @param {string} appId 
+   * @param {string} [originHeader=service-info.register] Only for Node.js. If not set will use the register value of service info. In browsers this will overridden by current page location.
+   * @throws {Error} on invalid login
+   */
+  async login (username, password, appId, originHeader) {
+    const apiEndpoint = await this.apiEndpointFor(username);
+
+    try {
+      const headers = { accept: 'json' };
+      originHeader = originHeader || (await this.info()).register;
+      if (!utils.isBrowser()) {
+        headers.Origin = originHeader;
+      }
+      const res = await utils.superagent.post(apiEndpoint + 'auth/login')
+        .set(headers)
+        .send({ username: username, password: password, appId: appId });
+
+      if (!res.body.token) {
+        throw new Error('Invalid login response: ' + res.body);
+      }
+      return new Connection(
+        Service.buildAPIEndpoint(await this.info(), username, res.body.token),
+        this // Pre load Connection with service
+      );
+    } catch (e) {
+      if (e.response && e.response.body
+        && e.response.body.error
+        && e.response.body.error.message) {
+        throw new Error(e.response.body.error.message)
+      }
+    }
+  }
+}
+
+module.exports = Service;
+
+// Require is done after exports to allow circular references
+const Connection = require('./Connection');
+
+/**
+ * Object to handle Pryv Service Informations https://api.pryv.com/reference/#service-info
+ * @typedef {Object} PryvServiceInfo
+ * @property {string} register The URL of the register service.
+ * @property {string} access The URL of the access page.
+ * @property {string} api The API endpoint format.
+ * @property {string} name The platform name.
+ * @property {string} home The URL of the platform's home page.
+ * @property {string} support The email or URL of the support page.
+ * @property {string} terms The terms and conditions, in plain text or the URL displaying them.
+ * @property {string} eventTypes The URL of the list of validated event types.
+ * @property {Object} [assets] Holder for service specific Assets (icons, css, ...)
+ * @property {String} [assets.definitions] URL to json object with assets definitions
+ */

package/src/ServiceAssets.js

@@ -0,0 +1,162 @@
+const utils = require('./utils.js');
+/**
+ * Holds Pryv Service informations.
+ * 
+ * It's returned by `service.assets()`
+ *
+ * @memberof Pryv
+ **/
+class ServiceAssets {
+  /**
+   * Private => use ServiceAssets.setup()
+   * @param { object} assets The content of service/info.assets properties.
+   * @param { string } pryvServiceAssetsSourceUrl Url point to assets of the service of a Pryv platform: https://api.pryv.com/reference/#service-info property `assets.src`
+   */
+  constructor(assets, assetsURL) {
+    this._assets = assets;
+    this._assetsURL = assetsURL;
+  }
+
+  /**
+   * Load Assets definition
+   * @param {string} pryvServiceAssetsSourceUrl
+   * @returns {ServiceAssets}
+   */
+  static async setup(pryvServiceAssetsSourceUrl) {
+    const res = await utils.superagent.get(pryvServiceAssetsSourceUrl).set('accept', 'json');
+    return new ServiceAssets(res.body, pryvServiceAssetsSourceUrl);
+  }
+
+  /**
+   * get a value from path separated by `:`
+   * exemple of key `lib-js:buttonSignIn`
+   * @param {string} [keyPath] if null, will return the all assets  
+   */
+  get(keyPath) {
+    let result = Object.assign({}, this._assets);
+    if (keyPath) {
+      keyPath.split(':').forEach((key) => {
+        result = result[key];
+        if (typeof result === 'undefined') return result;
+      });
+    }
+    return result;
+  }
+
+  /**
+   * get an Url from path separated by `:`
+   * identical to doing assets.relativeURL(assets.get(keyPath))
+   * exemple of key `lib-js:buttonSignIn`
+   * @param {string} [keyPath] if null, will return the all assets  
+   */
+  getUrl(keyPath) {
+    const url = this.get(keyPath);
+    if (typeof url !== 'string') {
+      throw new Error(url + ' returned ' + value); 
+    }
+    return this.relativeURL(url);
+  }
+
+  /**
+   * get relativeUrl
+   */
+  relativeURL(url) {
+    return relPathToAbs(this._assets.baseUrl || this._assetsURL, url);
+  }
+
+  //----------------   Default service ressources
+  
+  /**
+   * Set all defaults Favicon, CSS
+   */
+  async setAllDefaults() {
+    this.setFavicon();
+    await this.loadCSS();
+  }
+
+  /**
+   * Set service Favicon to Web Page
+   */
+  setFavicon() {
+    var link = document.querySelector("link[rel*='icon']") || document.createElement('link');
+    link.type = 'image/x-icon';
+    link.rel = 'shortcut icon';
+    link.href = this.relativeURL(this._assets.favicon.default.url);
+    document.getElementsByTagName('head')[0].appendChild(link);
+  }
+
+  /**
+   * Set default service CSS
+   */
+  async loadCSS() {
+    loadCSS(this.relativeURL(this._assets.css.default.url));
+  }
+
+  // ---- Login
+
+  /**
+  * Load CSS for Login button
+  */
+  async loginButtonLoadCSS () {
+    loadCSS(this.relativeURL(this._assets['lib-js'].buttonSignIn.css));
+  }
+
+  /**
+  * Get HTML for Login Button
+  */
+  async loginButtonGetHTML() {
+    const res = await utils.superagent.get(this.relativeURL(this._assets['lib-js'].buttonSignIn.html)).set('accept', 'html');
+    return res.text;
+  }
+
+ /**
+ * Get Messages strings for Login Button
+ */
+  async loginButtonGetMessages() {
+    const res = await utils.superagent.get(this.relativeURL(this._assets['lib-js'].buttonSignIn.messages)).set('accept', 'json');
+    return res.body;
+  }
+
+}
+
+function loadCSS(url) {
+  var head = document.getElementsByTagName('head')[0];
+  var link = document.createElement('link');
+  link.id = url;
+  link.rel = 'stylesheet';
+  link.type = 'text/css';
+  link.href = url;
+  link.media = 'all';
+  head.appendChild(link);
+}
+
+  /*\
+  |*| Modified version of 
+  |*| :: translate relative paths to absolute paths ::
+  |*|
+  |*| https://developer.mozilla.org/en-US/docs/Web/API/document.cookie
+  |*|
+  |*| The following code is released under the GNU Public License, version 3 or later.
+  |*| http://www.gnu.org/licenses/gpl-3.0-standalone.html
+  |*|
+  \*/
+
+function relPathToAbs (baseUrlString, sRelPath) {
+  var baseLocation = location;
+  if (baseUrlString) {
+    baseLocation = document.createElement('a');
+    baseLocation.href = baseUrlString;
+  }
+
+  var nUpLn, sDir = "", sPath = baseLocation.pathname.replace(/[^\/]*$/, sRelPath.replace(/(\/|^)(?:\.?\/+)+/g, "$1"));
+  for (var nEnd, nStart = 0; nEnd = sPath.indexOf("/../", nStart), nEnd > -1; nStart = nEnd + nUpLn) {
+    nUpLn = /^\/(?:\.\.\/)*/.exec(sPath.slice(nEnd))[0].length;
+    sDir = (sDir + sPath.substring(nStart, nEnd)).replace(new RegExp("(?:\\\/+[^\\\/]*){0," + ((nUpLn - 1) / 3) + "}$"),
+      "/");
+  }
+  let portStr = baseLocation.port ? ':' + baseLocation.port : '';
+  return baseLocation.protocol + '//' + baseLocation.hostname + portStr + sDir + sPath.substr(nStart);
+}
+
+
+module.exports = ServiceAssets;

package/src/index-socket.io-monitor.js

@@ -0,0 +1,4 @@
+const Pryv = require('./Pryv');
+require('@pryv/socket.io')(Pryv);
+require('@pryv/monitor')(Pryv);
+module.exports = Pryv;

package/src/index.html

@@ -0,0 +1,17 @@
+<!doctype html>
+<html>
+
+<head>
+  <title>Pryv - Light - Javascript Lib</title>
+
+  <script src="./print.bundle.js"></script>
+</head>
+
+<body>
+  -
+  <script src="./bundle.js"></script>
+  +
+  <script src="./app.bundle.js"></script>
+</body>
+
+</html>

package/src/index.js

@@ -0,0 +1,3 @@
+const Pryv = require('./Pryv');
+
+module.exports = Pryv;

package/src/lib/browser-getEventStreamed.js

@@ -0,0 +1,80 @@
+
+/**
+ * @private
+ * Replacement for getEventStreamed for Browser
+ * To be used as long as superagent does not propose it.
+ * 
+ */
+async function getEventStreamed(conn, queryParam, parser) {
+
+  /**
+   * Holds Parser's settings
+   */
+  const parserSettings = {
+    ondata: null,
+    onend: null,
+    encoding: 'utf8'
+  }
+
+  /**
+   * Mock Response
+   */
+  const fakeRes = {
+    setEncoding : function(encoding) {
+      parserSettings.encoding = encoding;
+    }, // will receive 'data' and 'end' callbacks
+    on: function(key, f) { 
+      parserSettings['on' + key] = f;
+    }
+  }
+
+  /**
+   * Holds results from the parser
+   */
+  let errResult;
+  let bodyObjectResult;
+  /**
+   * 
+   */
+  parser(fakeRes, function (err, bodyObject) { 
+    errResult = err;
+    bodyObjectResult = bodyObject;
+  });
+
+
+  // ------------   fetch ------------------- //
+  let url = new URL(conn.endpoint + 'events');
+  url.search = new URLSearchParams(queryParam);
+  let fetchParams = {method: 'GET', headers: {Accept: 'application/json'}};
+  if (conn.token) fetchParams.headers.Authorization = conn.token;
+
+  let response = await fetch(url,fetchParams);
+  const reader = response.body.getReader();
+  
+  while (true) {
+    const { done, value } = await reader.read();
+    parserSettings.ondata(new TextDecoder(parserSettings.encoding).decode(value));
+    if (done) { parserSettings.onend(); break; }
+  }
+
+  if (errResult) {
+    throw new Error(errResult);
+  }
+
+  // We're done!
+  const result = {
+    text: fakeRes.text, // from the parser
+    body: bodyObjectResult, // from the parser
+    statusCode: response.status,
+    headers: {}
+  }
+  // add headers to result
+  for (var pair of response.headers.entries()) {
+    result.headers[pair[0]] = pair[1];
+  }
+
+  return result;
+}
+
+
+module.exports = getEventStreamed;

package/src/lib/json-parser.js

@@ -0,0 +1,156 @@
+// there two steps 1 find events, then eventDeletions
+const EVENTMARKERS = ['"events":[', '"eventDeletions":['];
+
+/**
+ * Customize superagent parser
+ * Work on 'node.js' and use by browser-getEventStreamed
+ */
+module.exports = function (foreachEvent, includeDeletions) {
+  let eventOrEventDeletions = 0; // start with event
+  let buffer = ''; // temp data
+  let body = null; // to be returned
+
+  //IN EVENTS VARS
+  let depth = 0; // level of depth in brackets 
+  let inString = false; // cursor is in a String 
+  let skipNextOne = false; // when a backslash is found
+  let cursorPos = 0; // position of Character Cursor
+
+  // counters
+  let eventsCount = 0;
+  let eventDeletionsCount = 0;
+
+  const states = {
+    A_BEFORE_EVENTS: 0,
+    B_IN_EVENTS: 1,
+    D_AFTER_EVENTS: 2
+  }
+
+  let state = states.A_BEFORE_EVENTS;
+
+  function processBuffer() {
+    switch (state) {
+      case states.A_BEFORE_EVENTS:
+        searchStartEvents();
+        break;
+      case states.B_IN_EVENTS:
+        processEvents();
+        break;
+      default:
+        afterEvents();
+        break;
+    }
+  }
+
+
+  function searchStartEvents() {
+    // search for "events": and happend any info before to the body 
+    var n = buffer.indexOf(EVENTMARKERS[eventOrEventDeletions]);
+    if (n > 0) {
+      if (eventOrEventDeletions === 0) { // do only once
+        body = buffer.substring(0, n);
+      }
+      buffer = buffer.substr(n + EVENTMARKERS[eventOrEventDeletions].length);
+      state = states.B_IN_EVENTS;
+      processEvents();
+    }
+  }
+
+
+  function processEvents() {
+    /// ---- in Event
+    while (cursorPos < buffer.length && (state === states.B_IN_EVENTS)) {
+      if (skipNextOne) { // ignore next character
+        skipNextOne = false;
+        cursorPos++;
+        continue;
+      }
+      switch (buffer.charCodeAt(cursorPos)) {
+        case 93:  // ]
+          if (depth === 0) { // end of events
+            if (cursorPos !== 0) {
+              throw new Error('Found trailling ] in mid-course');
+            }
+            if (eventOrEventDeletions === 0 && includeDeletions) {
+              state = states.A_BEFORE_EVENTS;
+              eventOrEventDeletions = 1; // now look for eventDeletions
+              return;
+            } else { // done 
+              state = states.D_AFTER_EVENTS;
+              let eventsOrDeletionMsg = '';
+              if (eventOrEventDeletions === 1) {
+                eventsOrDeletionMsg = '"eventDeletionsCount":' + eventDeletionsCount + ','
+              }
+              buffer = eventsOrDeletionMsg + '"eventsCount":' + eventsCount + '' + buffer.substr(1);
+            }
+          }
+          break;
+        case 92:  // \
+          skipNextOne = true;
+          break;
+        case 123:  // {
+          if (!inString) depth++;
+          break;
+        case 34: // "
+          inString = !inString;
+          break;
+        case 125: // }
+          if (!inString) depth--;
+          if (depth === 0) {
+            // ignore possible coma ',' if first char
+            const ignoreComa = (buffer.charCodeAt(0) === 44) ? 1 : 0;
+            const eventStr = buffer.substring(ignoreComa, cursorPos + 1);
+            
+            if (eventOrEventDeletions === 0) {
+              eventsCount++;
+            } else {
+              eventDeletionsCount++;
+            }
+            buffer = buffer.substr(cursorPos + 1 );
+            addEvent(eventStr);
+            cursorPos = -1;
+          }
+          break;
+      }
+      cursorPos++;
+    }
+  }
+
+  function afterEvents() {
+    // just happend the end of message;
+    body += buffer;
+    buffer = '';
+    return;
+  }
+
+  return function (res, fn) {
+    res.setEncoding('utf8'); // Already UTF8 in browsers
+    res.on('data', chunk => {
+      buffer += chunk;
+      processBuffer();
+    });
+    res.on('end', () => {
+      let err;
+      let bodyObject;
+      try {
+        res.text = body + buffer;
+        bodyObject = res.text && JSON.parse(res.text);
+      } catch (err_) {
+        err = err_;
+        // issue #675: return the raw response if the response parsing fails
+        err.rawResponse = res.text || null;
+        // issue #876: return the http status code if the response parsing fails
+        err.statusCode = res.statusCode;
+      } finally {
+        fn(err, bodyObject);
+      }
+    });
+  };
+
+
+  /// --- Direct Push
+  function addEvent(strEvent) {
+    foreachEvent(JSON.parse(strEvent));
+  }
+
+};