pryv 2.1.8

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "pryv",
+  "version": "2.1.8",
+  "homepage": "https://github.com/pryv/lib-js",
+  "description": "Pryv Javascript Library",
+  "keywords": [
+    "Pryv"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/pryv/lib-js"
+  },
+  "bugs": {
+    "url": "https://github.com/pryv/lib-js/issues"
+  },
+  "author": {
+    "name": "Pryv S.A."
+  },
+  "main": "src/index.js",
+  "license": "BSD-3-Clause",
+  "scripts": {
+    "setup": "./scripts/setup-environment-dev.sh",
+    "build": "webpack --config webpack.config.js",
+    "doc": "node node_modules/jsdoc/jsdoc.js -c .jsdoc-conf.json",
+    "test": "mocha --reporter spec  test/**/*.test.js --timeout 3000",
+    "test-debug": "mocha --inpect-brk=40000 --reporter spec  test/**/*.test.js ",
+    "test:browser": "npm run build; ",
+    "cover": "nyc npm run test && npm run cover:report",
+    "cover:report": "nyc report --reporter=lcov --reporter=html",
+    "webserver": "./node_modules/.bin/rec-la ./dist 9443",
+    "gh-pages": "./scripts/upload.sh",
+    "clear": "rm -r dist/ && npm run setup"
+  },
+  "contributors": [
+    {
+      "name": "Pierre-Mikael Legris",
+      "email": "perki@pryv.com"
+    }
+  ],
+  "dependencies": {
+    "superagent": "^5.2.2"
+  },
+  "devDependencies": {
+    "@pryv/lib-js-common": "git+https://github.com/pryv/lib-js-common.git#1.0.4",
+    "@pryv/monitor": "^1.0.5",
+    "@pryv/socket.io": "^1.0.5",
+    "chai": "^4.3.4",
+    "chai-as-promised": "^7.1.1",
+    "cuid": "^2.1.8",
+    "mocha": "^6.2.3",
+    "node-fetch": "^2.6.0",
+    "nyc": "^14.1.1",
+    "rec-la": "latest",
+    "universal-url": "^2.0.0",
+    "zombie": "^6.1.4"
+  }
+}

package/scripts/setup-environment-dev.sh

@@ -0,0 +1,28 @@
+#!/bin/sh
+
+# working dir fix
+scriptsFolder=$(cd $(dirname "$0"); pwd)
+cd $scriptsFolder/..
+
+# check for basic prerequisites
+hash git 2>&- || { echo >&2 "I require git."; exit 1; }
+hash npm 2>&- || { echo >&2 "I require Node and NPM."; exit 1; }
+
+echo "
+Installing Node modules if necessary...
+"
+npm install
+
+distFolder=dist
+if [ ! -d $distFolder ]
+then
+  echo "
+Setting up '$distFolder' folder for publishing to GitHub pages...
+"
+  git clone -b gh-pages git@github.com:pryv/lib-js.git $distFolder
+fi
+
+echo "
+
+OK!
+"

package/scripts/upload.sh

@@ -0,0 +1,15 @@
+#!/bin/sh
+
+set -e
+
+# working dir fix
+scriptsFolder=$(cd $(dirname "$0"); pwd)
+cd $scriptsFolder/..
+
+if [ $# -eq 0 ]
+  then
+  echo "No commit message was provided, please provide a message as argument for readability";
+  exit 1;
+fi
+
+cd dist && git add . && git add -u . && git commit -m "$1" && git push

package/src/Auth/AuthController.js

@@ -0,0 +1,276 @@
+const utils = require('../utils');
+const Service = require('../Service');
+const AuthStates = require('./AuthStates');
+const Messages = require('./LoginMessages');
+
+/**
+ * @private
+ */
+class AuthController {
+
+  /**
+   * 
+   * @param {*} settings 
+   * @param {*} service 
+   */
+  constructor (settings, service, loginButton) {
+    this.settings = settings;
+    validateSettings.call(this, settings);
+
+    this.stateChangeListeners = [];
+    if (this.settings.onStateChange) {
+      this.stateChangeListeners.push(this.settings.onStateChange);
+    }
+    this.service = service;
+
+    // probably remove
+    this.languageCode = this.settings.authRequest.languageCode || 'en';    
+    this.messages = Messages(this.languageCode);
+
+    this.loginButton = loginButton;
+
+    function validateSettings (settings) {
+      if (!settings) { throw new Error('settings cannot be null'); }
+      // -- settings 
+      if (!settings.authRequest) { throw new Error('Missing settings.authRequest'); }
+  
+      // -- Extract returnURL 
+      settings.authRequest.returnURL =
+        this.getReturnURL(settings.authRequest.returnURL);
+  
+      if (!settings.authRequest.requestingAppId) {
+        throw new Error('Missing settings.authRequest.requestingAppId');
+      }
+      if (!settings.authRequest.requestedPermissions) {
+        throw new Error('Missing settings.authRequest.requestedPermissions');
+      }
+    }
+  }
+
+  /**
+   * async function to call right after instanciating object
+   * 
+   * @returns {PryvService}
+   */
+  async init () {
+    this.serviceInfo = this.service.infoSync();
+    this.state = { status: AuthStates.LOADING };
+    this.assets = await loadAssets(this);
+    
+    const loginButton = this.loginButton;
+    // initialize human interaction interface
+    if (loginButton != null) {
+      this.stateChangeListeners.push(loginButton.onStateChange.bind(loginButton));
+      // autologin needs cookies/storage implemented in human interaction interface
+      await checkAutoLogin(this);
+    }
+
+    // if auto login is not prompted
+    if (this.state.status != AuthStates.AUTHORIZED) {
+      this.state = { status: AuthStates.INITIALIZED, serviceInfo: this.serviceInfo};
+    }
+
+    if (loginButton != null && loginButton.finishAuthProcessAfterRedirection != null) {
+      await loginButton.finishAuthProcessAfterRedirection(this);
+    }
+    
+    return this.service;
+  }
+
+  /**
+   * Stops poll for auth request
+   */
+  stopAuthRequest (msg) {
+    this.state = { status: AuthStates.ERROR, message: msg };
+  }
+
+  /**
+   * Triggered when button is pressed
+   */
+  async handleClick () {
+    if (isAuthorized.call(this)) {
+      this.state = { status: AuthStates.SIGNOUT };
+    } else if (isInitialized.call(this)) {
+      this.startAuthRequest();
+    } else if (isNeedSignIn.call(this)) {
+      // reopen popup
+      this.state = this.state;
+    } else {
+      console.log('Unhandled action in "handleClick()" for status:', this.state.status);
+    }
+
+    function isAuthorized () {
+      return this.state.status == AuthStates.AUTHORIZED;
+    }
+    function isInitialized () {
+      return this.state.status === AuthStates.INITIALIZED;
+    }
+    function isNeedSignIn () {
+      return this.state.status === AuthStates.NEED_SIGNIN;
+    }
+  }
+
+  /**
+   * Used only to retrieve returnUrl in browser environments
+   * 
+   * @param {*} returnURL 
+   * @param {*} windowLocationForTest 
+   * @param {*} navigatorForTests 
+   */
+  getReturnURL (
+    returnURL,
+    windowLocationForTest,
+    navigatorForTests
+  ) {
+    const RETURN_URL_AUTO = 'auto';
+
+    returnURL = returnURL || RETURN_URL_AUTO + '#';
+
+    // check the trailer
+    let trailer = returnURL.slice(-1);
+    if ('#&?'.indexOf(trailer) < 0) {
+      throw new Error('Pryv access: Last character of --returnURL setting-- is not ' +
+        '"?", "&" or "#": ' + returnURL);
+    }
+    // auto mode for desktop
+    if (
+      returnUrlIsAuto(returnURL) &&
+      !utils.browserIsMobileOrTablet(navigatorForTests)
+    ) {
+      return false;
+    } else if (
+      // auto mode for mobile or self
+      (returnUrlIsAuto(returnURL) &&
+        utils.browserIsMobileOrTablet(navigatorForTests)
+      )
+      || returnURL.indexOf('self') === 0
+    ) {
+      // set self as return url?
+      // eventually clean-up current url from previous pryv returnURL
+      const locationHref = windowLocationForTest || window.location.href;
+      returnURL = locationHref + returnURL.substring(4);
+    }
+    return utils.cleanURLFromPrYvParams(returnURL);
+
+    function returnUrlIsAuto (returnURL) {
+      return returnURL.indexOf(RETURN_URL_AUTO) === 0;
+    }
+  }
+
+  async startAuthRequest () {
+    this.state = await postAccess.call(this);
+    
+    await doPolling.call(this);
+    
+    async function postAccess () {
+      try {
+        const res = await utils.superagent
+          .post(this.serviceInfo.access)
+          .send(this.settings.authRequest);
+        return res.body;
+      } catch (e) {
+        this.state = {
+          status: AuthStates.ERROR,
+          message: 'Requesting access',
+          error: e
+        };
+        throw e; // forward error
+      }
+    }
+
+    async function doPolling() {
+      if (this.state.status !== AuthStates.NEED_SIGNIN) {
+        return;
+      }
+      const pollResponse = await pollAccess(this.state.poll);
+      
+      if (pollResponse.status === AuthStates.NEED_SIGNIN) {
+        setTimeout(await doPolling.bind(this), this.state.poll_rate_ms);
+      } else {
+        this.state = pollResponse;
+      }
+
+      async function pollAccess(pollUrl) {
+        try {
+          const res = await utils.superagent
+            .get(pollUrl)
+          return res.body;
+        } catch (e) {
+          if (e.response &&
+              e.response.status === 403 &&
+              e.response.body &&
+              e.response.body.status === 'REFUSED') {
+            return { status: AuthStates.INITIALIZED };
+          } else {
+            return { status: AuthStates.ERROR, message: 'Error while polling for auth request', error: e };
+          }
+        }
+      }
+    }
+
+    
+  }
+
+  // -------------- state listeners ---------------------
+  set state (newState) {
+
+    // retro-compatibility for lib-js < 2.0.9
+    newState.id = newState.status;
+
+    this._state = newState;
+
+    this.stateChangeListeners.map((listener) => {
+      try {
+        listener(this.state)
+      } catch (e) {
+        console.log('Error during set state ()', e);
+      }
+    });
+  }
+
+  get state () {
+    return this._state;
+  }
+}
+
+// ----------- private methods -------------
+
+async function checkAutoLogin (authController) {
+  const loginButton = authController.loginButton;
+  if (loginButton == null) {
+    return;
+  }
+
+  const storedCredentials = await loginButton.getAuthorizationData();
+  if (storedCredentials != null) {
+    authController.state = Object.assign({}, {status: AuthStates.AUTHORIZED}, storedCredentials);
+  }
+}
+
+// ------------------ ACTIONS  ----------- //
+
+async function loadAssets(authController) {
+  let loadedAssets = {};
+  try {
+    loadedAssets = await authController.service.assets();
+    if (typeof location !== 'undefined') {
+      await loadedAssets.loginButtonLoadCSS();
+      const thisMessages = await loadedAssets.loginButtonGetMessages();
+      if (thisMessages.LOADING) {
+        authController.messages = Messages(authController.languageCode, thisMessages);
+      } else {
+        console.log("WARNING Messages cannot be loaded using defaults: ", thisMessages)
+      }
+    }
+  } catch (e) {
+    authController.state = {
+      status: AuthStates.ERROR,
+      message: 'Cannot fetch button visuals',
+      error: e
+    };
+    throw e; // forward error
+  }
+  return loadedAssets;
+}
+
+module.exports = AuthController;

package/src/Auth/AuthStates.js

@@ -0,0 +1,20 @@
+
+
+/**
+ * Enum Possible states: ERROR, LOADING, INITIALIZED, AUTHORIZED, SIGNOUT
+ * @readonly
+ * @enum {string}
+ * @memberof Pryv.Browser
+ */
+const AuthState = {
+  ERROR : 'ERROR',
+  LOADING : 'LOADING',
+  INITIALIZED: 'INITIALIZED',
+  NEED_SIGNIN: 'NEED_SIGNIN',
+  AUTHORIZED: 'ACCEPTED',
+  SIGNOUT: 'SIGNOUT',
+  REFUSED: 'REFUSED',
+} 
+
+
+module.exports = AuthState 

package/src/Auth/LoginMessages.js

@@ -0,0 +1,29 @@
+const Messages = {
+  LOADING: {
+    'en': '...'
+  },
+  ERROR: {
+    'en': 'Error',
+    'fr': 'Erreur',
+  },
+  LOGIN: {
+    'en': 'Signin',
+    'fr': 'Login'
+  },
+  SIGNOUT_CONFIRM: {
+    'en': 'Logout ?',
+    'fr': 'Se deconnecter ?'
+  }
+}
+
+function get(languageCode, definitions) {
+  const myMessages = definitions || Messages;
+  const res = {};
+  Object.keys(myMessages).map((key) => {
+    res[key] = myMessages[key][languageCode] || myMessages[key]['en'];
+  });
+  return res;
+}
+
+
+module.exports = get;

package/src/Auth/index.js

@@ -0,0 +1,43 @@
+const AuthController = require('./AuthController');
+const AuthStates = require('./AuthStates');
+const LoginButton = require('../Browser/LoginButton');
+const Service = require('../Service');
+
+/**
+ * @memberof Pryv
+ * @namespace Pryv.Auth
+ */
+
+/**
+ * Start an authentication process
+ *
+ * @memberof Pryv.Auth
+ * @param {Object} settings
+ * @param {Object} settings.authRequest See https://api.pryv.com/reference/#data-structure-access
+ * @param {string} [settings.authRequest.languageCode] Language code, as per LoginButton Messages: 'en', 'fr
+ * @param {string} settings.authRequest.requestingAppId Application id, ex: 'my-app'
+ * @param {Object} settings.authRequest.requestedPermissions
+ * @param {string | boolean} settings.authRequest.returnURL : false, // set this if you don't want a popup
+ * @param {string} [settings.authRequest.referer] To track registration source 
+ * @param {string} settings.spanButtonID set and <span> id in DOM to insert default login button or null for custom
+ * @param {Browser.AuthStateChangeHandler} settings.onStateChange
+ * @param {string} [settings.returnURL=auto#]  Set to "self#" to disable popup and force using the same page. Set a custom url when process is finished (specific use cases). Should always end by # ? or &
+ * @param {string} serviceInfoUrl
+ * @param {Object} [serviceCustomizations] override properties of serviceInfoUrl 
+ * @returns {Pryv.Service}
+ */
+async function setupAuth (settings, serviceInfoUrl, serviceCustomizations, HumanInteraction = LoginButton) {
+  const service = new Service(serviceInfoUrl, serviceCustomizations);
+  await service.info()
+
+  const humanInteraction = new HumanInteraction(settings, service);
+  await humanInteraction.init();
+
+  return service;
+}
+
+module.exports = {
+  setupAuth: setupAuth,
+  AuthStates: AuthStates,
+  AuthController: AuthController,
+}

package/src/Browser/CookieUtils.js

@@ -0,0 +1,51 @@
+
+const utils = require('../utils');
+/**
+ * @memberof Pryv.Browser
+ * @namespace Pryv.Browser.CookieUtils
+ */
+
+/**
+  * Set a Local cookier
+  * @memberof Pryv.Browser.CookieUtils
+  * @param {string} cookieKey - The key for the cookie
+  * @param {mixed} value - The Value 
+  * @param {number} expireInDays - Expiration date in days from now
+  */
+function set(cookieKey, value, expireInDays) {
+  if (! utils.isBrowser()) return;
+  expireInDays = expireInDays || 365;
+  var myDate = new Date();
+  var hostName = window.location.hostname;
+  var path = window.location.pathname;
+  myDate.setDate(myDate.getDate() + expireInDays);
+  var cookieStr = encodeURIComponent(cookieKey) + '=' + encodeURIComponent(JSON.stringify(value))
+    + ';expires=' + myDate.toGMTString()
+    + ';domain=.' + hostName + ';path=' + path;
+    // do not add SameSite when removing a cookie
+  if (expireInDays >= 0) cookieStr += ';SameSite=Strict';
+  document.cookie = cookieStr;
+}
+exports.set = set;
+
+/**
+ * returns the value of a local cookie
+ * @memberof Pryv.Browser.CookieUtils
+ * @param cookieKey - The key
+ */
+exports.get = function get(cookieKey) {
+  const name = encodeURIComponent(cookieKey);
+  if (! utils.isBrowser()) return;
+  var value = "; " + document.cookie;
+  var parts = value.split("; " + name + "=");
+  if (parts.length == 2) return JSON.parse(decodeURIComponent(parts.pop().split(";").shift()));
+}
+
+/**
+ * delete a local cookie
+ * @memberof Pryv.Browser.CookieUtils
+ * @param cookieKey - The key
+ */
+exports.del = function del(cookieKey) {
+  set(cookieKey, {deleted: true}, -1);
+}