cozy-client 34.11.0 → 35.0.0

package/dist/CozyClient.js

@@ -548,7 +548,7 @@ var CozyClient = /*#__PURE__*/function () {
      * Emits
      *
      * - "beforeLogout" at the beginning, before links have been reset
-     * - "login" when the client is fully logged out and links have been reset
+     * - "logout" when the client is fully logged out and links have been reset
      *
      * @returns {Promise} - Resolves when all links have been reset and client is fully logged out
      */
@@ -2669,7 +2669,7 @@ var CozyClient = /*#__PURE__*/function () {
 CozyClient.hooks = CozyClient.hooks || {};
 CozyClient.fetchPolicies = _policies.default; //COZY_CLIENT_VERSION_PACKAGE in replaced by babel. See babel config
 
-CozyClient.version = "34.11.0";
+CozyClient.version = "35.0.0";
 
 _microee.default.mixin(CozyClient);
 

package/dist/index.js

@@ -323,7 +323,7 @@ var _registry = _interopRequireDefault(require("./registry"));
 
 var _RealTimeQueries = _interopRequireDefault(require("./RealTimeQueries"));
 
-var manifest = _interopRequireWildcard(require("./manifest"));
+var manifest = _interopRequireWildcard(require("./models/manifest"));
 
 exports.manifest = manifest;
 

package/dist/index.node.js

@@ -221,7 +221,7 @@ var _store = require("./store");
 
 var _registry = _interopRequireDefault(require("./registry"));
 
-var manifest = _interopRequireWildcard(require("./manifest"));
+var manifest = _interopRequireWildcard(require("./models/manifest"));
 
 exports.manifest = manifest;
 

package/dist/models/manifest.js

@@ -0,0 +1,239 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.sanitizeCategories = sanitizeCategories;
+exports.areTermsValid = areTermsValid;
+exports.isPartnershipValid = isPartnershipValid;
+exports.sanitize = sanitize;
+exports.getIdentifier = exports.sanitizeIdentifier = exports.legacyLoginFields = exports.ROLE_IDENTIFIER = void 0;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _flow2 = _interopRequireDefault(require("lodash/flow"));
+
+var _cloneDeep2 = _interopRequireDefault(require("lodash/cloneDeep"));
+
+var _findKey = _interopRequireDefault(require("lodash/findKey"));
+
+function _createForOfIteratorHelper(o, allowArrayLike) { var it; if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = o[Symbol.iterator](); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+var ROLE_IDENTIFIER = 'identifier';
+/**
+ * Legacy login fields declared by some konnectors
+ */
+
+exports.ROLE_IDENTIFIER = ROLE_IDENTIFIER;
+var legacyLoginFields = ['login', 'identifier', 'new_identifier', 'email'];
+exports.legacyLoginFields = legacyLoginFields;
+var legacyEncryptedFields = ['secret', 'dob', 'code', 'answer', 'access_token', 'refresh_token', 'appSecret'];
+var APP_CATEGORIES = ['banking', 'cozy', 'energy', 'health', 'host_provider', 'insurance', 'isp', 'mes_infos', 'online_services', 'others', 'partners', 'press', 'productivity', 'ptnb', 'public_service', 'shopping', 'social', 'telecom', 'transport'];
+/**
+ * Filters unauthorized categories. Defaults to ['others'] if no suitable category.
+ *
+ * @param {Array<Object>} categories - Array of categories
+ * @returns {Array<Object>} sanitized categories
+ */
+
+function sanitizeCategories(categories) {
+  if (!categories) return ['others'];
+  var filteredList = categories.filter(function (c) {
+    return APP_CATEGORIES.includes(c);
+  });
+  if (!filteredList.length) return ['others'];
+  return filteredList;
+}
+
+function areTermsValid(terms) {
+  return Boolean(terms && terms.id && terms.url && terms.version);
+}
+
+function isPartnershipValid(partnership) {
+  return Boolean(partnership && partnership.description);
+}
+/**
+ * Normalize app manifest, retro-compatibility for old manifests
+ *
+ * @param  {import('../types').Manifest} manifest - app manifest to normalize
+ * @returns {import('../types').SanitizedManifest}
+ */
+
+
+function sanitize(manifest) {
+  var sanitized = _objectSpread({}, manifest); // Make categories an array and delete category attribute if it exists
+
+
+  if (!manifest.categories && manifest.category && typeof manifest.category === 'string') {
+    sanitized.categories = [manifest.category];
+    delete sanitized.category;
+  }
+
+  sanitized.categories = sanitizeCategories(sanitized.categories); // manifest name is not an object
+
+  if (typeof manifest.name === 'object') sanitized.name = manifest.name.en; // Fix camelCase from cozy-stack
+
+  if (manifest.available_version) {
+    sanitized.availableVersion = manifest.available_version;
+    delete sanitized.available_version;
+  } // Fix camelCase from cozy-stack
+
+
+  if (manifest.latest_version) {
+    sanitized.latestVersion = manifest.latestVersion;
+    delete sanitized.latest_version;
+  } // Remove invalid terms
+
+
+  if (sanitized.terms && !areTermsValid(sanitized.terms)) {
+    delete sanitized.terms;
+  } // Remove invalid partnership
+
+
+  if (sanitized.partnership && !isPartnershipValid(sanitized.partnership)) {
+    delete sanitized.partnership;
+  }
+
+  if (sanitized.fields) {
+    sanitized.fields = sanitizeFields(manifest.fields);
+  }
+
+  return sanitized;
+}
+/**
+ * Ensures that fields has at least one field with the role 'identifier'
+ *
+ * @param  {import('../types').ManifestFields} fields - Manifest fields
+ * @returns {import('../types').ManifestFields} - Sanitized manifest fields
+ */
+
+
+var sanitizeIdentifier = function sanitizeIdentifier(fields) {
+  var sanitized = (0, _cloneDeep2.default)(fields);
+  var hasIdentifier = false;
+
+  for (var fieldName in sanitized) {
+    if (sanitized[fieldName].role === ROLE_IDENTIFIER) {
+      if (hasIdentifier) delete sanitized[fieldName].role;else hasIdentifier = true;
+    }
+  }
+
+  if (hasIdentifier) return sanitized;
+
+  var _iterator = _createForOfIteratorHelper(legacyLoginFields),
+      _step;
+
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var name = _step.value;
+
+      if (sanitized[name]) {
+        sanitized[name].role = ROLE_IDENTIFIER;
+        return sanitized;
+      }
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+
+  for (var _fieldName in sanitized) {
+    if (sanitized[_fieldName].type !== 'password') {
+      sanitized[_fieldName].role = ROLE_IDENTIFIER;
+      return sanitized;
+    }
+  }
+
+  return sanitized;
+};
+/**
+ * Returns the key for the field having the role=identifier attribute
+ *
+ * @param  {import('../types').ManifestFields} fields Konnector fields
+ * @returns {String|null}  The key for the identifier field, example 'login'
+ */
+
+
+exports.sanitizeIdentifier = sanitizeIdentifier;
+
+var getIdentifier = function getIdentifier() {
+  var fields = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  return (0, _findKey.default)(sanitizeIdentifier(fields), function (field) {
+    return field.role === ROLE_IDENTIFIER;
+  }) || null;
+};
+/**
+ * Ensures old fields are removed
+ *
+ * @param  {Object} fields Manifest fields
+ * @returns {Object}        Sanitized manifest fields
+ */
+
+
+exports.getIdentifier = getIdentifier;
+
+var removeOldFields = function removeOldFields(fields) {
+  var sanitized = (0, _cloneDeep2.default)(fields);
+  delete sanitized.advancedFields;
+  return sanitized;
+};
+/**
+ * Ensures every field not explicitely tagged as not required is required
+ *
+ * @param  {import('../types').ManifestFields} [fields={}] Manifest fields
+ * @returns {import('../types').ManifestFields}            Sanitized manifest fields
+ */
+
+
+var sanitizeRequired = function sanitizeRequired(fields) {
+  var sanitized = (0, _cloneDeep2.default)(fields);
+
+  for (var fieldName in sanitized) {
+    var field = sanitized[fieldName]; // Ensure legacy for field isRequired
+
+    var required = typeof field.required === 'undefined' ? field.isRequired : field.required;
+    sanitized[fieldName].required = typeof required === 'boolean' ? required : true;
+  }
+
+  return sanitized;
+};
+/**
+ * Ensures:
+ * * any field flagged as encrypted keeps its flag
+ * * any legacy encrypted field is tagged as encrypted
+ *
+ * @param  {import('../types').ManifestFields} [fields={}] Manifest fields
+ * @returns {import('../types').ManifestFields}             Sanitized Manifest fields
+ */
+
+
+var sanitizeEncrypted = function sanitizeEncrypted(fields) {
+  var sanitized = (0, _cloneDeep2.default)(fields);
+
+  for (var fieldName in sanitized) {
+    var field = sanitized[fieldName];
+    if (typeof field.encrypted !== 'boolean') field.encrypted = field.type === 'password' || legacyEncryptedFields.includes(fieldName);
+  }
+
+  return sanitized;
+};
+/**
+ * Sanitizes manifest fields with multiple rules
+ *
+ * @param  {import('../types').ManifestFields} [fields={}] Manifest fields
+ * @returns {import('../types').ManifestFields}            Sanitized manifest fields
+ */
+
+
+var sanitizeFields = (0, _flow2.default)([removeOldFields, sanitizeIdentifier, sanitizeRequired, sanitizeEncrypted]);

package/dist/models/manifest.spec.js

@@ -0,0 +1,446 @@
+import {
+  sanitizeCategories,
+  sanitize as sanitizeManifest,
+  getIdentifier
+} from './manifest'
+
+describe('sanitizeCategories', () => {
+  it('should return the list of the provided expected categories correctly', () => {
+    // all of these categories is authorized by config/categories.json
+    // so it won't be filtered
+    const categories = [
+      'cozy',
+      'isp',
+      'partners',
+      'press',
+      'shopping',
+      'telecom'
+    ]
+    expect(sanitizeCategories(categories)).toEqual(categories)
+  })
+  it('should filter unwanted categories', () => {
+    // pressingggg is not allowed as category
+    const categories = [
+      'cozy',
+      'isp',
+      'partners',
+      'pressingggg',
+      'shopping',
+      'telecom'
+    ]
+    expect(sanitizeCategories(categories)).toEqual(
+      categories.filter(c => c !== 'pressingggg')
+    )
+  })
+  it('should return "others" as category if no categories provided', () => {
+    expect(sanitizeCategories([])).toEqual(['others'])
+    expect(sanitizeCategories(null)).toEqual(['others'])
+  })
+  it('should return "others" as category if categories after filtering is empty', () => {
+    // pressingggg is not allowed as category
+    expect(sanitizeCategories(['pressingggg'])).toEqual(['others'])
+  })
+})
+
+describe('sanitizeManifest', () => {
+  const baseMan = { slug: 'mock' }
+
+  it('should handle legacy category property', () => {
+    const testCategory = 'cozy'
+    expect(
+      sanitizeManifest({ slug: 'mock', category: testCategory })
+    ).toStrictEqual({
+      slug: 'mock',
+      categories: [testCategory]
+    })
+  })
+  it('should handle legacy name property locales ("en" only)', () => {
+    const testName = 'Mock'
+    expect(
+      sanitizeManifest({
+        slug: 'mock',
+        name: {
+          en: testName
+        }
+      })
+    ).toEqual(
+      expect.objectContaining({
+        slug: 'mock',
+        name: testName
+      })
+    )
+  })
+
+  it('should transform available_version property to availableVersion', () => {
+    const testVersion = '3.0.0'
+    const man = sanitizeManifest({
+      slug: 'mock',
+      available_version: testVersion
+    })
+    expect(man.availableVersion).toBe('3.0.0')
+    expect(man).not.toHaveProperty('available_version')
+  })
+
+  it('should remove "fields" if fields is null', () => {
+    const current = {
+      fields: null
+    }
+    const result = sanitizeManifest(current)
+    expect(result.fields).toBe(null)
+  })
+
+  it("shouldn't modify if fields is undefined", () => {
+    const current = {}
+    const result = sanitizeManifest(current)
+    expect(result.fields).toBe(undefined)
+  })
+
+  it('should not mutate source manifest', () => {
+    const current = {
+      fields: {
+        username: {
+          type: 'text',
+          required: {
+            value: 'true'
+          }
+        },
+        passphrase: {
+          type: 'password'
+        },
+        birthdate: {
+          type: 'date'
+        }
+      }
+    }
+
+    sanitizeManifest(current)
+    expect(current).toEqual({
+      fields: {
+        username: {
+          type: 'text',
+          required: {
+            value: 'true'
+          }
+        },
+        passphrase: {
+          type: 'password'
+        },
+        birthdate: {
+          type: 'date'
+        }
+      }
+    })
+  })
+
+  it('should remove old property advancedFields in fields', () => {
+    const oldManifest = {
+      fields: {
+        login: {
+          type: 'text'
+        },
+        password: {
+          type: 'password'
+        },
+        advancedFields: {
+          folderPath: {
+            advanced: true,
+            isRequired: false
+          }
+        }
+      }
+    }
+
+    const result = sanitizeManifest(oldManifest)
+    expect(result.fields.advancedFields).toBeUndefined()
+  })
+
+  it('should not add any identifier', () => {
+    const current = {
+      fields: {
+        passphrase: {
+          required: true,
+          type: 'password'
+        }
+      }
+    }
+
+    const result = sanitizeManifest(current)
+    expect(result.fields.passphrase.role).not.toBe('identifier')
+    expect(Object.keys(result.fields).length).toBe(1)
+  })
+
+  it('should set role=identifier for login', () => {
+    const current = {
+      fields: {
+        login: { type: 'text' },
+        password: { type: 'password' }
+      }
+    }
+    const result = sanitizeManifest(current)
+    expect(result.fields.login.role).toBe('identifier')
+  })
+
+  it('should set first non-password field as role=identifier', () => {
+    const current = {
+      fields: {
+        password: { type: 'password' },
+        plop: { type: 'text' },
+        foo: { type: 'date' }
+      }
+    }
+    const result = sanitizeManifest(current)
+    expect(result.fields.plop.role).toBe('identifier')
+    expect(result.fields.foo.role).not.toBe('identifier')
+  })
+
+  const legacyLoginFieldsTest = [
+    'login',
+    'identifier',
+    'new_identifier',
+    'email'
+  ]
+  for (let name of legacyLoginFieldsTest) {
+    let inputLegacy = {
+      fields: {
+        password: { type: 'password' },
+        plop: { type: 'text' }
+      }
+    }
+    inputLegacy.fields[name] = { type: 'text' }
+    it('should set role=identifier to ' + name, () => {
+      const result = sanitizeManifest(inputLegacy)
+      expect(result.fields[name].role).toBe('identifier')
+      expect(result.fields.plop.role).not.toBe('identifier')
+    })
+  }
+
+  it('should set only one identifier', () => {
+    const current = {
+      fields: {
+        identifier: { type: 'text' },
+        mail: { type: 'email' },
+        login: { type: 'text' },
+        new_identifier: { type: 'text' }
+      }
+    }
+    const result = sanitizeManifest(current)
+    const identifiers = Object.keys(result.fields).filter(
+      name => result.fields[name].role === 'identifier'
+    )
+    expect(identifiers.length).toBe(1)
+  })
+
+  it('should set only one identifier even if there is many role=identifier in the manifest', () => {
+    const current = {
+      fields: {
+        identifier: { type: 'text' },
+        mail: { type: 'email', role: 'identifier' },
+        login: { type: 'text', role: 'identifier' },
+        new_identifier: { type: 'text', role: 'identifier' }
+      }
+    }
+    const result = sanitizeManifest(current)
+    const identifiers = Object.keys(result.fields).filter(
+      name => result.fields[name].role === 'identifier'
+    )
+    expect(identifiers.length).toBe(1)
+  })
+
+  it('should set only one identifier even if there is no password fields', () => {
+    const current = {
+      fields: {
+        plop1: { type: 'text' },
+        plop2: { type: 'text' },
+        plop3: { type: 'text' },
+        plop4: { type: 'text' }
+      }
+    }
+    const result = sanitizeManifest(current)
+    const identifiers = Object.keys(result.fields).filter(
+      name => result.fields[name].role === 'identifier'
+    )
+    expect(identifiers.length).toBe(1)
+  })
+
+  it('should keep the identifier priority', () => {
+    const current = {
+      fields: {
+        identifier: { type: 'text' },
+        mail: { type: 'email' },
+        login: { type: 'text' },
+        new_identifier: { type: 'text' }
+      }
+    }
+    const result = sanitizeManifest(current)
+    expect(result.fields.login.required).toBe(true)
+  })
+
+  it('should set required=true as default value in fields', () => {
+    const current = {
+      fields: {
+        login: { type: 'text' },
+        password: { type: 'password' },
+        gender: { type: 'text', required: false },
+        country: { type: 'text' }
+      }
+    }
+    const result = sanitizeManifest(current)
+    expect(result.fields.login.required).toBe(true)
+    expect(result.fields.password.required).toBe(true)
+    expect(result.fields.gender.required).toBe(false)
+    expect(result.fields.country.required).toBe(true)
+  })
+
+  it('should handle legacy property isRequired in fields', () => {
+    const current = {
+      fields: {
+        login: { type: 'text' },
+        password: { type: 'password' },
+        gender: { type: 'text', isRequired: false },
+        country: { type: 'text' }
+      }
+    }
+    const result = sanitizeManifest(current)
+    expect(result.fields.login.required).toBe(true)
+    expect(result.fields.password.required).toBe(true)
+    expect(result.fields.gender.required).toBe(false)
+    expect(result.fields.country.required).toBe(true)
+  })
+
+  it('should set encrypted for type=password fields', () => {
+    const current = {
+      fields: {
+        username: { type: 'text' },
+        passphrase: { type: 'password' }
+      }
+    }
+
+    const result = sanitizeManifest(current)
+    expect(result.fields.passphrase.encrypted).toBe(true)
+  })
+
+  const legacyEncryptedFieldsTest = [
+    'secret',
+    'dob',
+    'code',
+    'answer',
+    'access_token',
+    'refresh_token',
+    'appSecret'
+  ]
+
+  for (let name of legacyEncryptedFieldsTest) {
+    let legacyManifest = {
+      fields: {
+        [name]: { type: 'text' },
+        password: { type: 'password' },
+        plop: { type: 'text' }
+      }
+    }
+
+    it('should set encrypted=true to ' + name, () => {
+      const result = sanitizeManifest(legacyManifest)
+      expect(result.fields[name].encrypted).toBe(true)
+    })
+
+    it('should keep encrypted value', () => {
+      const current = {
+        fields: {
+          [name]: { type: 'text', encrypted: false },
+          passphrase: { type: 'password', encrypted: true }
+        }
+      }
+      const result = sanitizeManifest(current)
+      expect(result.fields[name].encrypted).toBe(false)
+      expect(result.fields.passphrase.encrypted).toBe(true)
+    })
+  }
+
+  describe('terms', () => {
+    it('should remove incomplete terms', () => {
+      const incompleteTerms = {
+        id: 'mock-terms'
+      }
+      expect(
+        sanitizeManifest({ ...baseMan, terms: incompleteTerms })
+      ).not.toHaveProperty('terms')
+      expect(sanitizeManifest({ ...baseMan, terms: {} })).not.toHaveProperty(
+        'terms'
+      )
+    })
+
+    it('should keep complete terms', () => {
+      const completeTerms = {
+        id: 'mock-terms',
+        url: 'mock://terms',
+        version: 'mock001'
+      }
+      const man = { ...baseMan, terms: completeTerms }
+
+      expect(sanitizeManifest(man)).toEqual(expect.objectContaining(man))
+    })
+  })
+
+  describe('partnership', () => {
+    it('should remove incomplete', () => {
+      const incompletePartnership = {
+        icon: 'icon.svg' // icon is optional
+      }
+
+      expect(
+        sanitizeManifest({
+          ...baseMan,
+          partnership: {}
+        })
+      ).not.toHaveProperty('partnership')
+
+      expect(
+        sanitizeManifest({
+          ...baseMan,
+          partnership: incompletePartnership
+        })
+      ).not.toHaveProperty('partnership')
+    })
+
+    it('should keep complete', () => {
+      const completePartnership = {
+        description: 'A partnership text here' // description is mandatory
+      }
+
+      const man = { ...baseMan, partnership: completePartnership }
+      expect(sanitizeManifest(man)).toEqual(expect.objectContaining(man))
+    })
+  })
+})
+
+describe('getIdentifier', () => {
+  it('should return field having role=identifier', () => {
+    const fields = {
+      username: {
+        type: 'text'
+      },
+      id: {
+        type: 'text',
+        role: 'identifier'
+      }
+    }
+    expect(getIdentifier(fields)).toBe('id')
+  })
+
+  it('should return the first field', () => {
+    const fields = {
+      username: {
+        type: 'text'
+      },
+      id: {
+        type: 'text'
+      }
+    }
+
+    expect(getIdentifier(fields)).toBe('username')
+  })
+
+  it('should return null if there is no match', () => {
+    expect(getIdentifier({})).toBe(null)
+  })
+})

package/dist/types.js

@@ -34,6 +34,22 @@ var _dsl = require("./queries/dsl");
  * @typedef {object} Token
  * @typedef {object} ClientResponse
  * @typedef {object} Manifest
+ * @typedef {object} SanitizedManifest
+ */
+
+/**
+ * @typedef {Object} ManifestField
+ * @property {String} [type] - field type : can be "text" or "hidden" or "date" or "dropdown" or "password"
+ * @property {String} [role] - field role : with "identifier" value
+ * @property {Boolean} [required] - is the field required or not
+ * @property {Boolean} [isRequired] - is the field required or not (legacy)
+ * @property {Boolean} [encrypted] - encrypted value of the field (legacy)
+ */
+
+/**
+ * @typedef {{
+ *   [key: string]: ManifestField;
+ * }} ManifestFields
  */
 
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cozy-client",
-  "version": "34.11.0",
+  "version": "35.0.0",
   "license": "MIT",
   "main": "dist/index.node.js",
   "browser": "dist/index.js",
@@ -18,7 +18,7 @@
     "@types/jest": "^26.0.20",
     "@types/lodash": "^4.14.170",
     "btoa": "^1.2.1",
-    "cozy-stack-client": "^34.11.0",
+    "cozy-stack-client": "^35.0.0",
     "date-fns": "2.29.3",
     "json-stable-stringify": "^1.0.1",
     "lodash": "^4.17.13",
@@ -73,5 +73,5 @@
     "react-native-ios11-devicecheck": "https://github.com/cozy/react-native-devicecheck#app-attest-v0.1"
   },
   "sideEffects": false,
-  "gitHead": "eddc8bbd475912c0a7de8b136e04b0248c15dd12"
+  "gitHead": "261c75d0ee603b66b2da046a9d04d6876a17eec6"
 }

package/types/CozyClient.d.ts

@@ -284,7 +284,7 @@ declare class CozyClient {
      * Emits
      *
      * - "beforeLogout" at the beginning, before links have been reset
-     * - "login" when the client is fully logged out and links have been reset
+     * - "logout" when the client is fully logged out and links have been reset
      *
      * @returns {Promise} - Resolves when all links have been reset and client is fully logged out
      */

package/types/index.d.ts

@@ -13,7 +13,7 @@ export { default as fetchPolicies } from "./policies";
 export * from "./mock";
 export * from "./hooks";
 export { BulkEditError } from "./errors";
-import * as manifest from "./manifest";
+import * as manifest from "./models/manifest";
 import * as models from "./models";
 export { manifest, models };
 export { QueryDefinition, Q, Mutations, MutationTypes, getDoctypeFromOperation } from "./queries/dsl";

package/types/index.node.d.ts

@@ -9,7 +9,7 @@ export * from "./mock";
 export * from "./cli";
 export { BulkEditError } from "./errors";
 export { default as fetchPolicies } from "./policies";
-import * as manifest from "./manifest";
+import * as manifest from "./models/manifest";
 import * as models from "./models";
 export { manifest, models };
 export { QueryDefinition, Mutations, MutationTypes, getDoctypeFromOperation, Q } from "./queries/dsl";

package/types/models/manifest.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Filters unauthorized categories. Defaults to ['others'] if no suitable category.
+ *
+ * @param {Array<Object>} categories - Array of categories
+ * @returns {Array<Object>} sanitized categories
+ */
+export function sanitizeCategories(categories: Array<any>): Array<any>;
+export function areTermsValid(terms: any): boolean;
+export function isPartnershipValid(partnership: any): boolean;
+/**
+ * Normalize app manifest, retro-compatibility for old manifests
+ *
+ * @param  {import('../types').Manifest} manifest - app manifest to normalize
+ * @returns {import('../types').SanitizedManifest}
+ */
+export function sanitize(manifest: import('../types').Manifest): import('../types').SanitizedManifest;
+export const ROLE_IDENTIFIER: "identifier";
+/**
+ * Legacy login fields declared by some konnectors
+ */
+export const legacyLoginFields: string[];
+export function sanitizeIdentifier(fields: import('../types').ManifestFields): import('../types').ManifestFields;
+export function getIdentifier(fields?: import('../types').ManifestFields): string | null;

package/types/types.d.ts

@@ -20,6 +20,32 @@ export type ReduxStore = any;
 export type Token = any;
 export type ClientResponse = any;
 export type Manifest = any;
+export type SanitizedManifest = any;
+export type ManifestField = {
+    /**
+     * - field type : can be "text" or "hidden" or "date" or "dropdown" or "password"
+     */
+    type?: string;
+    /**
+     * - field role : with "identifier" value
+     */
+    role?: string;
+    /**
+     * - is the field required or not
+     */
+    required?: boolean;
+    /**
+     * - is the field required or not (legacy)
+     */
+    isRequired?: boolean;
+    /**
+     * - encrypted value of the field (legacy)
+     */
+    encrypted?: boolean;
+};
+export type ManifestFields = {
+    [key: string]: ManifestField;
+};
 export type OldCozyClient = any;
 export type NodeEnvironment = any;
 export type QueryFetchStatus = "failed" | "loading" | "pending" | "loaded";

package/dist/manifest.js

@@ -1,83 +0,0 @@
-"use strict";
-
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.sanitizeCategories = sanitizeCategories;
-exports.areTermsValid = areTermsValid;
-exports.isPartnershipValid = isPartnershipValid;
-exports.sanitize = sanitize;
-
-var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
-
-var _types = require("./types");
-
-function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
-
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
-
-var APP_CATEGORIES = ['banking', 'cozy', 'energy', 'health', 'host_provider', 'insurance', 'isp', 'mes_infos', 'online_services', 'others', 'partners', 'press', 'productivity', 'ptnb', 'public_service', 'shopping', 'social', 'telecom', 'transport'];
-/** Filters unauthorized categories. Defaults to ['others'] if no suitable category. */
-
-function sanitizeCategories(categories) {
-  if (!categories) return ['others'];
-  var filteredList = categories.filter(function (c) {
-    return APP_CATEGORIES.includes(c);
-  });
-  if (!filteredList.length) return ['others'];
-  return filteredList;
-}
-
-function areTermsValid(terms) {
-  return Boolean(terms && terms.id && terms.url && terms.version);
-}
-
-function isPartnershipValid(partnership) {
-  return Boolean(partnership && partnership.description);
-}
-/**
- * Normalize app manifest, retro-compatibility for old manifests
- *
- * @param  {Manifest} manifest - app manifest to normalize
- * @returns {Manifest}
- */
-
-
-function sanitize(manifest) {
-  var sanitized = _objectSpread({}, manifest); // Make categories an array and delete category attribute if it exists
-
-
-  if (!manifest.categories && manifest.category && typeof manifest.category === 'string') {
-    sanitized.categories = [manifest.category];
-    delete sanitized.category;
-  }
-
-  sanitized.categories = sanitizeCategories(sanitized.categories); // manifest name is not an object
-
-  if (typeof manifest.name === 'object') sanitized.name = manifest.name.en; // Fix camelCase from cozy-stack
-
-  if (manifest.available_version) {
-    sanitized.availableVersion = manifest.available_version;
-    delete sanitized.available_version;
-  } // Fix camelCase from cozy-stack
-
-
-  if (manifest.latest_version) {
-    sanitized.latestVersion = manifest.latestVersion;
-    delete sanitized.latest_version;
-  } // Remove invalid terms
-
-
-  if (sanitized.terms && !areTermsValid(sanitized.terms)) {
-    delete sanitized.terms;
-  } // Remove invalid partnership
-
-
-  if (sanitized.partnership && !isPartnershipValid(sanitized.partnership)) {
-    delete sanitized.partnership;
-  }
-
-  return sanitized;
-}

package/dist/manifest.spec.js

@@ -1,135 +0,0 @@
-import { sanitizeCategories, sanitize as sanitizeManifest } from './manifest'
-
-describe('sanitizeCategories', () => {
-  it('should return the list of the provided expected categories correctly', () => {
-    // all of these categories is authorized by config/categories.json
-    // so it won't be filtered
-    const categories = [
-      'cozy',
-      'isp',
-      'partners',
-      'press',
-      'shopping',
-      'telecom'
-    ]
-    expect(sanitizeCategories(categories)).toEqual(categories)
-  })
-  it('should filter unwanted categories', () => {
-    // pressingggg is not allowed as category
-    const categories = [
-      'cozy',
-      'isp',
-      'partners',
-      'pressingggg',
-      'shopping',
-      'telecom'
-    ]
-    expect(sanitizeCategories(categories)).toEqual(
-      categories.filter(c => c !== 'pressingggg')
-    )
-  })
-  it('should return "others" as category if no categories provided', () => {
-    expect(sanitizeCategories([])).toEqual(['others'])
-    expect(sanitizeCategories(null)).toEqual(['others'])
-  })
-  it('should return "others" as category if categories after filtering is empty', () => {
-    // pressingggg is not allowed as category
-    expect(sanitizeCategories(['pressingggg'])).toEqual(['others'])
-  })
-})
-
-describe('sanitizeManifest', () => {
-  const baseMan = { slug: 'mock' }
-
-  it('should handle legacy category property', () => {
-    const testCategory = 'cozy'
-    expect(
-      sanitizeManifest({ slug: 'mock', category: testCategory })
-    ).toStrictEqual({
-      slug: 'mock',
-      categories: [testCategory]
-    })
-  })
-  it('should handle legacy name property locales ("en" only)', () => {
-    const testName = 'Mock'
-    expect(
-      sanitizeManifest({
-        slug: 'mock',
-        name: {
-          en: testName
-        }
-      })
-    ).toEqual(
-      expect.objectContaining({
-        slug: 'mock',
-        name: testName
-      })
-    )
-  })
-
-  it('should transform available_version property to availableVersion', () => {
-    const testVersion = '3.0.0'
-    const man = sanitizeManifest({
-      slug: 'mock',
-      available_version: testVersion
-    })
-    expect(man.availableVersion).toBe('3.0.0')
-    expect(man).not.toHaveProperty('available_version')
-  })
-
-  describe('terms', () => {
-    it('should remove incomplete terms', () => {
-      const incompleteTerms = {
-        id: 'mock-terms'
-      }
-      expect(
-        sanitizeManifest({ ...baseMan, terms: incompleteTerms })
-      ).not.toHaveProperty('terms')
-      expect(sanitizeManifest({ ...baseMan, terms: {} })).not.toHaveProperty(
-        'terms'
-      )
-    })
-
-    it('should keep complete terms', () => {
-      const completeTerms = {
-        id: 'mock-terms',
-        url: 'mock://terms',
-        version: 'mock001'
-      }
-      const man = { ...baseMan, terms: completeTerms }
-
-      expect(sanitizeManifest(man)).toEqual(expect.objectContaining(man))
-    })
-  })
-
-  describe('partnership', () => {
-    it('should remove incomplete', () => {
-      const incompletePartnership = {
-        icon: 'icon.svg' // icon is optional
-      }
-
-      expect(
-        sanitizeManifest({
-          ...baseMan,
-          partnership: {}
-        })
-      ).not.toHaveProperty('partnership')
-
-      expect(
-        sanitizeManifest({
-          ...baseMan,
-          partnership: incompletePartnership
-        })
-      ).not.toHaveProperty('partnership')
-    })
-
-    it('should keep complete', () => {
-      const completePartnership = {
-        description: 'A partnership text here' // description is mandatory
-      }
-
-      const man = { ...baseMan, partnership: completePartnership }
-      expect(sanitizeManifest(man)).toEqual(expect.objectContaining(man))
-    })
-  })
-})

package/types/manifest.d.ts

@@ -1,12 +0,0 @@
-/** Filters unauthorized categories. Defaults to ['others'] if no suitable category. */
-export function sanitizeCategories(categories: any): any;
-export function areTermsValid(terms: any): boolean;
-export function isPartnershipValid(partnership: any): boolean;
-/**
- * Normalize app manifest, retro-compatibility for old manifests
- *
- * @param  {Manifest} manifest - app manifest to normalize
- * @returns {Manifest}
- */
-export function sanitize(manifest: Manifest): Manifest;
-import { Manifest } from "./types";