pryv 3.12.1 → 3.14.2

package/src/Auth/LoginMessages.js

@@ -19,11 +19,80 @@ const Messages = {
   SIGNOUT_CONFIRM: {
     en: 'Logout?',
     fr: 'Se déconnecter ?'
+  },
+  MENU_TITLE: {
+    en: 'Account',
+    fr: 'Compte'
+  },
+  LOGOUT: {
+    en: 'Log out',
+    fr: 'Se déconnecter'
+  },
+  MANAGE_ACCOUNT: {
+    en: 'Manage my account',
+    fr: 'Gérer mon compte'
+  },
+  APP: {
+    en: 'app',
+    fr: 'app'
+  },
+  CLOSE: {
+    en: 'Close',
+    fr: 'Fermer'
+  },
+  CANCEL: {
+    en: 'Cancel',
+    fr: 'Annuler'
+  },
+  LOGOUT_ALL: {
+    en: 'Log out of all accounts',
+    fr: 'Se déconnecter de tous les comptes'
+  },
+  MANAGE_ACCOUNT_OF: {
+    en: 'Manage {username}\'s account',
+    fr: 'Gérer le compte de {username}'
+  },
+  USE_FOR: {
+    en: 'Use this app for',
+    fr: 'Utiliser cette app pour'
+  },
+  ME: {
+    en: 'me',
+    fr: 'moi'
+  },
+  VIA: {
+    en: 'via',
+    fr: 'via'
+  },
+  ACTING_AS: {
+    en: 'acting as',
+    fr: 'pour le compte'
+  },
+  SWITCH_BACK: {
+    en: 'Switch back to {username}',
+    fr: 'Revenir à {username}'
+  },
+  SWITCHING: {
+    en: 'Switching...',
+    fr: 'Changement...'
+  },
+  OTHER_ACCOUNT: {
+    en: 'Another account...',
+    fr: 'Un autre compte...'
+  },
+  UNAVAILABLE: {
+    en: 'no longer available',
+    fr: 'plus disponible'
   }
 };
 
+/**
+ * Messages for a language. `definitions` (a service's own messages) override
+ * the defaults key by key, so a key the service does not define still has
+ * its default text.
+ */
 function get (languageCode, definitions) {
-  const myMessages = definitions || Messages;
+  const myMessages = Object.assign({}, Messages, definitions || {});
   const res = {};
   Object.keys(myMessages).forEach((key) => {
     res[key] = myMessages[key][languageCode] || myMessages[key].en;

package/src/Auth/ProfileStore.js

@@ -0,0 +1,137 @@
+/**
+ * @license
+ * [BSD-3-Clause](https://github.com/pryv/lib-js/blob/master/LICENSE)
+ */
+
+/**
+ * The accounts a sign-in button remembers for one app, as stored in its
+ * authorization data:
+ * `{ apiEndpoint, username, actingAs?, authUrl?, profiles: [...] }`.
+ * The top-level `apiEndpoint` / `username` are the active account (what
+ * versions without profiles read); `profiles` lists every remembered
+ * account, most recently used first, the active one included.
+ * A profile is `{ username, apiEndpoint, actingAs?, unavailable? }`, where
+ * `actingAs = { username, delegate }` marks an account used through account
+ * delegation (`delegate` is the username of the person acting).
+ * @memberof pryv.Auth
+ */
+module.exports = {
+  DEFAULT_LIMIT: 5,
+  read,
+  write,
+  activate,
+  remove,
+  markUnavailable,
+  profileOf,
+  fromAccepted,
+  carriesToken
+};
+
+const utils = require('../utils');
+
+/**
+ * Whether an apiEndpoint carries a token. A stored sign-in without one
+ * cannot call the API (3.13.0 saved such sign-ins after a redirect return,
+ * the credential hand-off not being redeemed).
+ * @param {string} apiEndpoint
+ * @returns {boolean}
+ */
+function carriesToken (apiEndpoint) {
+  try {
+    return Boolean(utils.extractTokenAndAPIEndpoint(apiEndpoint).token);
+  } catch (e) {
+    return false;
+  }
+}
+
+/**
+ * Parse stored authorization data (any version) into
+ * `{ active, profiles, authUrl }`; `active` is `profiles[0]` or null.
+ * @param {Object|null|undefined} stored
+ */
+function read (stored) {
+  const store = { active: null, profiles: [], authUrl: undefined };
+  if (stored == null || typeof stored !== 'object' || stored.deleted === true) return store;
+  if (typeof stored.authUrl === 'string') store.authUrl = stored.authUrl;
+  if (Array.isArray(stored.profiles)) {
+    store.profiles = stored.profiles.filter(isProfile).map(profileOf);
+  }
+  if (isProfile(stored)) {
+    const active = profileOf(stored);
+    store.profiles = [active].concat(store.profiles.filter((p) => p.username !== active.username));
+    store.active = active;
+  }
+  return store;
+}
+
+/**
+ * The authorization data to store for `store`.
+ * @returns {Object|null} null when nothing is left to remember
+ */
+function write (store) {
+  if (store.profiles.length === 0) return null;
+  const data = {};
+  if (store.active != null) {
+    data.apiEndpoint = store.active.apiEndpoint;
+    data.username = store.active.username;
+    if (store.active.actingAs != null) data.actingAs = store.active.actingAs;
+  }
+  if (store.authUrl != null) data.authUrl = store.authUrl;
+  data.profiles = store.profiles.map(profileOf);
+  return data;
+}
+
+/**
+ * Make `profile` the active account (replacing a stored one with the same
+ * username), then forget the least recently used accounts beyond `limit`.
+ */
+function activate (store, profile, limit) {
+  const max = Math.max(1, limit || module.exports.DEFAULT_LIMIT);
+  const active = profileOf(profile);
+  const profiles = [active].concat(store.profiles.filter((p) => p.username !== active.username));
+  return Object.assign({}, store, { active, profiles: profiles.slice(0, max) });
+}
+
+/** Forget `username`; forgetting the active account leaves none active. */
+function remove (store, username) {
+  const profiles = store.profiles.filter((p) => p.username !== username);
+  const active = (store.active != null && store.active.username !== username) ? store.active : null;
+  return Object.assign({}, store, { active, profiles });
+}
+
+/** Keep `username` listed, marked as no longer usable (revoked, detached). */
+function markUnavailable (store, username) {
+  const mark = (p) => (p.username === username ? Object.assign(profileOf(p), { unavailable: true }) : p);
+  const profiles = store.profiles.map(mark);
+  const active = (store.active != null && store.active.username === username) ? null : store.active;
+  return Object.assign({}, store, { active, profiles });
+}
+
+/** The stored fields of a profile, nothing else (credentials included). */
+function profileOf (p) {
+  const profile = { username: p.username, apiEndpoint: p.apiEndpoint };
+  if (p.actingAs != null && typeof p.actingAs.delegate === 'string') {
+    profile.actingAs = { username: p.username, delegate: p.actingAs.delegate };
+  }
+  if (p.unavailable === true) profile.unavailable = true;
+  return profile;
+}
+
+function isProfile (p) {
+  return p != null && typeof p.username === 'string' && typeof p.apiEndpoint === 'string';
+}
+
+/**
+ * The profile of an ACCEPTED auth-request body. Its `delegation` block is a
+ * display hint posted by the auth page; `accessInfo().delegation` is
+ * authoritative and replaces it when the profile is next activated.
+ */
+function fromAccepted (body) {
+  const profile = { username: body.username, apiEndpoint: body.apiEndpoint };
+  const d = body.delegation;
+  if (d != null && d.isDelegatedAccess === true && d.controlledUsername === body.username &&
+      typeof d.delegate?.username === 'string') {
+    profile.actingAs = { username: body.username, delegate: d.delegate.username };
+  }
+  return profile;
+}

package/src/Auth/index.js

@@ -26,11 +26,14 @@ module.exports = {
  * @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 | false} [settings.authRequest.returnURL] 'auto#' (default, also when unset or false):
+ *   popup on desktop, redirect on a phone or tablet; 'self#': always redirect back to this page;
+ *   a URL: always redirect back to that URL. Must end with '#', '?' or '&'.
+ * @param {string} [settings.authRequest.authUrl] Your own auth page for this request; honoured only
+ *   when it matches the platform's `access:trustedAuthUrls`
  * @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 {Function} settings.onStateChange
- * @param {string} [settings.returnURL] Set to "self#" to disable popup and force using the same page
  * @param {string} serviceInfoUrl
  * @param {Object} [serviceCustomizations] override properties of serviceInfoUrl
  * @returns {Promise<Service>}