cozy-client 34.11.1 → 35.1.0

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/models/trigger.js

@@ -7,43 +7,92 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.triggers = exports.triggerStates = void 0;
 
-var _get = _interopRequireDefault(require("lodash/get"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
 
 var _account = require("./account");
 
 var _logger = _interopRequireDefault(require("../logger"));
 
+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 actionableErrors = ['CHALLENGE_ASKED', 'DISK_QUOTA_EXCEEDED', 'TERMS_VERSION_MISMATCH', 'USER_ACTION_NEEDED', 'USER_ACTION_NEEDED.CHANGE_PASSWORD', 'USER_ACTION_NEEDED.ACCOUNT_REMOVED', 'USER_ACTION_NEEDED.WEBAUTH_REQUIRED', 'USER_ACTION_NEEDED.SCA_REQUIRED', 'LOGIN_FAILED'];
 /** Trigger states come from /jobs/triggers */
 
 var triggerStates = {
-  /** Returns when the trigger was last executed. Need a trigger */
-  getLastExecution: function getLastExecution(triggerState) {
-    return (0, _get.default)(triggerState, 'current_state.last_execution');
+  /**
+   * Returns when the trigger was last executed
+   *
+   * @param {import('../types').IOCozyTrigger} trigger - trigger object
+   * @returns {String} last execution date of any job related to the given trigger
+   */
+  getLastExecution: function getLastExecution(trigger) {
+    var _trigger$current_stat;
+
+    return trigger === null || trigger === void 0 ? void 0 : (_trigger$current_stat = trigger.current_state) === null || _trigger$current_stat === void 0 ? void 0 : _trigger$current_stat.last_execution;
   },
-  getLastsuccess: function getLastsuccess(triggerState) {
-    _logger.default.warn('Deprecated, please use getLastSuccess instead of getLastsuccess');
 
-    return (0, _get.default)(triggerState, 'current_state.last_success');
+  /**
+   * Returns when the trigger was last executed with success
+   *
+   * @param {import('../types').IOCozyTrigger} trigger - trigger object
+   * @returns {String} last execution date of any job related to the given trigger and with success
+   */
+  getLastSuccess: function getLastSuccess(trigger) {
+    var _trigger$current_stat2;
+
+    return trigger === null || trigger === void 0 ? void 0 : (_trigger$current_stat2 = trigger.current_state) === null || _trigger$current_stat2 === void 0 ? void 0 : _trigger$current_stat2.last_success;
   },
 
-  /** Returns when the trigger was last successfully executed. */
-  getLastSuccess: function getLastSuccess(triggerState) {
-    return (0, _get.default)(triggerState, 'current_state.last_success');
+  /**
+   * Returns when the trigger was last executed with success
+   *
+   * @param {import('../types').IOCozyTrigger} trigger - trigger object
+   * @returns {String} last execution date of any job related to the given trigger and with success
+   */
+  getLastsuccess: function getLastsuccess(trigger) {
+    var _trigger$current_stat3;
+
+    _logger.default.warn('Deprecated, please use getLastSuccess instead of getLastsuccess');
+
+    return trigger === null || trigger === void 0 ? void 0 : (_trigger$current_stat3 = trigger.current_state) === null || _trigger$current_stat3 === void 0 ? void 0 : _trigger$current_stat3.last_success;
   },
 
-  /** Returns whether last job failed */
-  isErrored: function isErrored(triggerState) {
-    return (0, _get.default)(triggerState, 'current_state.status') === 'errored';
+  /**
+   * Returns whether last job failed
+   *
+   * @param {import('../types').IOCozyTrigger} trigger - trigger object
+   * @returns {Boolean}
+   */
+  isErrored: function isErrored(trigger) {
+    var _trigger$current_stat4;
+
+    return (trigger === null || trigger === void 0 ? void 0 : (_trigger$current_stat4 = trigger.current_state) === null || _trigger$current_stat4 === void 0 ? void 0 : _trigger$current_stat4.status) === 'errored';
   },
 
-  /** Returns the type of the last error to occur */
-  getLastErrorType: function getLastErrorType(triggerState) {
-    return (0, _get.default)(triggerState, 'current_state.last_error');
+  /**
+   * Returns the type of the last error to occur
+   *
+   * @param {import('../types').IOCozyTrigger} trigger - trigger object
+   * @returns {String}
+   */
+  getLastErrorType: function getLastErrorType(trigger) {
+    var _trigger$current_stat5;
+
+    return trigger === null || trigger === void 0 ? void 0 : (_trigger$current_stat5 = trigger.current_state) === null || _trigger$current_stat5 === void 0 ? void 0 : _trigger$current_stat5.last_error;
   }
 };
 exports.triggerStates = triggerStates;
+var DEFAULT_CRON = '0 0 0 * * 0'; // Once a week, sunday at midnight
+
 var triggers = {
+  /**
+   * Returns whether the given trigger is associated to a konnector or not
+   *
+   * @param {import('../types').IOCozyTrigger} trigger - trigger object
+   * @returns {Boolean}
+   */
   isKonnectorWorker: function isKonnectorWorker(trigger) {
     return trigger.worker === 'konnector';
   },
@@ -51,7 +100,7 @@ var triggers = {
   /**
    * Returns the konnector slug that executed a trigger
    *
-   * @param {object} trigger io.cozy.triggers
+   * @param {import('../types').IOCozyTrigger} trigger - io.cozy.triggers
    *
    * @returns {string|void} A konnector slug
    */
@@ -72,28 +121,32 @@ var triggers = {
   /**
    * getAccountId - Returns the account id for a trigger
    *
-   * @param {object} trigger io.cozy.triggers
+   * @param {import('../types').IOCozyTrigger} trigger io.cozy.triggers
    *
-   * @returns {string} Id for an io.cozy.accounts
+   * @returns {String} Id for an io.cozy.accounts
    */
   getAccountId: function getAccountId(trigger) {
-    var legacyData = (0, _get.default)(trigger, 'message.Data');
+    var _trigger$message;
+
+    var legacyData = trigger === null || trigger === void 0 ? void 0 : (_trigger$message = trigger.message) === null || _trigger$message === void 0 ? void 0 : _trigger$message.Data;
 
     if (legacyData) {
       var message = JSON.parse(atob(legacyData));
       return message.account;
     } else {
-      return (0, _get.default)(trigger, 'message.account');
+      var _trigger$message2;
+
+      return trigger === null || trigger === void 0 ? void 0 : (_trigger$message2 = trigger.message) === null || _trigger$message2 === void 0 ? void 0 : _trigger$message2.account;
     }
   },
 
   /**
    * Checks if the triggers current error has been muted in the corresponding io.cozy.accounts
    *
-   * @param {object} trigger      io.cozy.triggers
-   * @param {object} account      io.cozy.accounts used by the trigger
+   * @param {import('../types').IOCozyTrigger} trigger      io.cozy.triggers
+   * @param {import('../types').IOCozyAccount} account      io.cozy.accounts used by the trigger
    *
-   * @returns {boolean} Whether the error is muted or not
+   * @returns {Boolean} Whether the error is muted or not
    */
   isLatestErrorMuted: function isLatestErrorMuted(trigger, account) {
     var lastErrorType = triggerStates.getLastErrorType(trigger);
@@ -109,12 +162,52 @@ var triggers = {
   /**
    * Returns whether the error in trigger can be solved by the user
    *
-   * @param {object} trigger      io.cozy.triggers
+   * @param {import('../types').IOCozyTrigger} trigger      io.cozy.triggers
    *
-   * @returns {boolean} Whether the error is muted or not
+   * @returns {Boolean} Whether the error is muted or not
    */
   hasActionableError: function hasActionableError(trigger) {
-    return actionableErrors.includes(trigger.current_state.last_error);
+    var _trigger$current_stat6;
+
+    return actionableErrors.includes(trigger === null || trigger === void 0 ? void 0 : (_trigger$current_stat6 = trigger.current_state) === null || _trigger$current_stat6 === void 0 ? void 0 : _trigger$current_stat6.last_error);
+  },
+
+  /**
+   * Build trigger attributes given konnector and account
+   *
+   * @param  {Object} options - options object
+   * @param  {import('../types').IOCozyKonnector} options.konnector - konnector object
+   * @param  {import('../types').IOCozyAccount} options.account - account object
+   * @param  {String} [options.cron] - cron string. Defaults to '0 0 0 * * 0'
+   * @param  {object} [options.folder] - folder object
+   * @returns {import('../types').IOCozyTrigger} created trigger
+   */
+  buildTriggerAttributes: function buildTriggerAttributes(_ref) {
+    var account = _ref.account,
+        _ref$cron = _ref.cron,
+        cron = _ref$cron === void 0 ? DEFAULT_CRON : _ref$cron,
+        folder = _ref.folder,
+        konnector = _ref.konnector;
+    var message = {
+      account: account._id,
+      konnector: konnector.slug
+    };
+
+    if (folder) {
+      message['folder_to_save'] = folder._id;
+    }
+
+    var result = {
+      worker: 'konnector',
+      message: message
+    };
+    var options = konnector.clientSide ? {
+      type: '@client'
+    } : {
+      type: '@cron',
+      arguments: cron
+    };
+    return _objectSpread(_objectSpread({}, result), options);
   }
 };
 exports.triggers = triggers;