cozy-client 27.13.0 → 27.14.3

package/CHANGELOG.md

@@ -3,6 +3,44 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [27.14.3](https://github.com/cozy/cozy-client/compare/v27.14.2...v27.14.3) (2022-01-28)
+
+
+### Bug Fixes
+
+* **qualification:** Fix typo in identity ([e89aa8d](https://github.com/cozy/cozy-client/commit/e89aa8de0b6b25d5eecd8dc1ba41baa80dff5ec2))
+
+
+
+
+
+## [27.14.2](https://github.com/cozy/cozy-client/compare/v27.14.1...v27.14.2) (2022-01-28)
+
+**Note:** Version bump only for package cozy-client
+
+
+
+
+
+## [27.14.1](https://github.com/cozy/cozy-client/compare/v27.14.0...v27.14.1) (2022-01-28)
+
+**Note:** Version bump only for package cozy-client
+
+
+
+
+
+# [27.14.0](https://github.com/cozy/cozy-client/compare/v27.13.0...v27.14.0) (2022-01-25)
+
+
+### Features
+
+* Add rootCozyUrl helper ([ca09e71](https://github.com/cozy/cozy-client/commit/ca09e71a7b687bf28055ed0764d08c4dbd7e70cc))
+
+
+
+
+
 # [27.13.0](https://github.com/cozy/cozy-client/compare/v27.12.0...v27.13.0) (2022-01-24)
 
 

package/dist/CozyClient.js

@@ -2293,6 +2293,7 @@ var CozyClient = /*#__PURE__*/function () {
      * At any time put an error function
      *
      * @param {Function} [onError] - Set a callback for queries which are errored
+     * @throws {Error} onError should not have been defined yet
      */
 
   }, {
@@ -2463,7 +2464,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 = "27.13.0";
+CozyClient.version = "27.14.3";
 
 _microee.default.mixin(CozyClient);
 

package/dist/CozyClient.spec.js

@@ -1140,7 +1140,7 @@ describe('CozyClient', () => {
     })
 
     it('should first dispatch a INIT_QUERY action', async () => {
-      requestHandler.mockReturnValueOnce(Promise.resolve(fakeResponse))
+      requestHandler.mockResolvedValueOnce(fakeResponse)
       await client.query(query, { as: 'allTodos' })
       expect(client.store.dispatch.mock.calls[0][0]).toEqual(
         initQuery('allTodos', { doctype: 'io.cozy.todos' }, { as: 'allTodos' })
@@ -1148,7 +1148,7 @@ describe('CozyClient', () => {
     })
 
     it('should then dispatch a RECEIVE_QUERY_RESULT action', async () => {
-      requestHandler.mockReturnValueOnce(Promise.resolve(fakeResponse))
+      requestHandler.mockResolvedValueOnce(fakeResponse)
       await client.query(query, { as: 'allTodos' })
       const dispatchCalls = client.store.dispatch.mock.calls
       const lastDispatchCall = dispatchCalls[dispatchCalls.length - 1]
@@ -1159,7 +1159,7 @@ describe('CozyClient', () => {
 
     it('should dispatch a RECEIVE_QUERY_ERROR action if an error occurs', async () => {
       const error = new Error('Fake error')
-      requestHandler.mockReturnValueOnce(Promise.reject(error))
+      requestHandler.mockRejectedValueOnce(error)
       try {
         await client.query(query, { as: 'allTodos' })
       } catch (e) {} // eslint-disable-line no-empty
@@ -1169,13 +1169,13 @@ describe('CozyClient', () => {
     })
 
     it('should resolve to the query response', async () => {
-      requestHandler.mockReturnValueOnce(Promise.resolve(fakeResponse))
+      requestHandler.mockResolvedValueOnce(fakeResponse)
       const resp = await client.query(query)
       expect(resp).toEqual(fakeResponse)
     })
 
     it('should call the link with the query', async () => {
-      requestHandler.mockReturnValueOnce(Promise.resolve(fakeResponse))
+      requestHandler.mockResolvedValueOnce(fakeResponse)
       await client.query(query)
       expect(requestHandler).toHaveBeenCalledTimes(1)
       expect(requestHandler.mock.calls[0][0]).toBe(query)
@@ -1200,8 +1200,8 @@ describe('CozyClient', () => {
             ]
           })
         )
-        .mockReturnValueOnce(Promise.resolve({ data: [], included: [] }))
-        .mockReturnValueOnce(Promise.resolve({ data: [], included: [] }))
+        .mockResolvedValueOnce({ data: [], included: [] })
+        .mockResolvedValueOnce({ data: [], included: [] })
 
       const resp = await client.query(
         Q('io.cozy.todos').include(['attachments'])
@@ -1246,7 +1246,7 @@ describe('CozyClient', () => {
     })
 
     it('should set the correct name to the query', async () => {
-      requestHandler.mockReturnValueOnce(Promise.resolve(fakeResponse))
+      requestHandler.mockResolvedValueOnce(fakeResponse)
       const getById = Q('io.cozy.files').getById('1')
       await client.query(getById)
       expect(client.store.dispatch.mock.calls[0][0]).toEqual(
@@ -1256,7 +1256,7 @@ describe('CozyClient', () => {
       )
     })
     it('should use the name passed as an argument', async () => {
-      requestHandler.mockReturnValueOnce(Promise.resolve(fakeResponse))
+      requestHandler.mockResolvedValueOnce(fakeResponse)
       const getById = Q('io.cozy.files').getById('1')
       await client.query(getById, { as: 'toto' })
       expect(client.store.dispatch.mock.calls[0][0]).toEqual(
@@ -1266,7 +1266,7 @@ describe('CozyClient', () => {
       )
     })
     it('should name the query correctly', async () => {
-      requestHandler.mockReturnValueOnce(Promise.resolve(fakeResponse))
+      requestHandler.mockResolvedValueOnce(fakeResponse)
       await client.query(query, { as: 'allTodos' })
       expect(client.store.dispatch.mock.calls[0][0]).toEqual(
         initQuery('allTodos', { doctype: 'io.cozy.todos' }, { as: 'allTodos' })
@@ -1353,7 +1353,7 @@ describe('CozyClient', () => {
     })
 
     it('should dispatch a INIT_QUERY action if status is not loaded', async () => {
-      requestHandler.mockReturnValueOnce(Promise.resolve(fakeResponse))
+      requestHandler.mockResolvedValueOnce(fakeResponse)
       getQueryFromState.mockReturnValueOnce({
         fetchStatus: 'pending'
       })
@@ -1364,7 +1364,7 @@ describe('CozyClient', () => {
     })
 
     it('should dispatch a INIT_QUERY action if no skip and no bookmark', async () => {
-      requestHandler.mockReturnValueOnce(Promise.resolve(fakeResponse))
+      requestHandler.mockResolvedValueOnce(fakeResponse)
       getQueryFromState.mockReturnValueOnce({
         fetchStatus: 'loaded'
       })
@@ -1375,7 +1375,7 @@ describe('CozyClient', () => {
     })
 
     it('should dispatch a RECEIVE_QUERY_RESULT action if query has skip', async () => {
-      requestHandler.mockReturnValueOnce(Promise.resolve(fakeResponse))
+      requestHandler.mockResolvedValueOnce(fakeResponse)
       getQueryFromState.mockReturnValueOnce({
         fetchStatus: 'loaded'
       })
@@ -1389,7 +1389,7 @@ describe('CozyClient', () => {
     })
 
     it('should dispatch a RECEIVE_QUERY_RESULT action if query has bookmark', async () => {
-      requestHandler.mockReturnValueOnce(Promise.resolve(fakeResponse))
+      requestHandler.mockResolvedValueOnce(fakeResponse)
       getQueryFromState.mockReturnValueOnce({
         fetchStatus: 'loaded'
       })
@@ -1402,52 +1402,54 @@ describe('CozyClient', () => {
       )
     })
 
-    const setupOnError = () => {
-      const error = new TypeError('Failed to fetch')
-      requestHandler.mockReturnValueOnce(Promise.reject(error))
-      const onError = jest.fn().mockReturnValueOnce(() => true)
-      return onError
-    }
+    describe('setupOnError', () => {
+      const setupOnError = () => {
+        const error = new TypeError('Failed to fetch')
+        requestHandler.mockRejectedValueOnce(error)
+        return jest.fn().mockReturnValueOnce(() => true)
+      }
 
-    it('should call onError callback when an error is thrown. Callback passed as argument', async () => {
-      const onError = setupOnError()
+      it('should call onError callback when an error is thrown. Callback passed as argument', async () => {
+        const onError = setupOnError()
 
-      await client.query(query, { as: 'allTodos', onError })
-      expect(onError).toBeCalled()
-    })
+        await client.query(query, { as: 'allTodos', onError })
+        expect(onError).toBeCalled()
+      })
 
-    it('should call onError callback when an error is catched. It is passed during instantiation', async () => {
-      const onError = setupOnError()
-      const client = new CozyClient({ onError })
+      it('should call onError callback when an error is caught. It is passed during instantiation', async () => {
+        const setupOnError = () => jest.fn().mockReturnValueOnce(() => true)
+        const onError = setupOnError()
+        const client = new CozyClient({ onError })
 
-      await client.query(query, { as: 'allTodos' })
-      expect(onError).toBeCalled()
-    })
+        await client.query(query, { as: 'allTodos' })
+        expect(onError).toBeCalled()
+      })
 
-    it('should call onError callback when an error is catched. It is passed with setOnError', async () => {
-      const onError = setupOnError()
-      client.setOnError(onError)
+      it('should call onError callback when an error is catched. It is passed with setOnError', async () => {
+        const onError = setupOnError()
+        client.setOnError(onError)
 
-      await client.query(query, { as: 'allTodos' })
-      expect(onError).toBeCalled()
-    })
+        await client.query(query, { as: 'allTodos' })
+        expect(onError).toBeCalled()
+      })
 
-    it('should throw an error when we call setOnError twice (or several times)', async () => {
-      const client = new CozyClient({})
-      const onError = () => true
+      it('should throw an error when we call setOnError twice (or several times)', async () => {
+        const client = new CozyClient({})
+        const onError = () => true
 
-      const funcShouldThrow = () => client.setOnError(onError)
-      expect(funcShouldThrow).not.toThrow()
-      expect(funcShouldThrow).toThrow('On Error is already defined')
-    })
+        const funcShouldThrow = () => client.setOnError(onError)
+        expect(funcShouldThrow).not.toThrow()
+        expect(funcShouldThrow).toThrow('On Error is already defined')
+      })
 
-    it('should throw an error when there is no onError callback', async () => {
-      const error = new TypeError('Failed to fetch')
-      requestHandler.mockReturnValueOnce(Promise.reject(error))
+      it('should throw an error when there is no onError callback', async () => {
+        const error = new TypeError('Failed to fetch')
+        requestHandler.mockRejectedValueOnce(error)
 
-      await expect(client.query(query, { as: 'allTodos' })).rejects.toThrow(
-        'Failed to fetch'
-      )
+        await expect(client.query(query, { as: 'allTodos' })).rejects.toThrow(
+          'Failed to fetch'
+        )
+      })
     })
   })
 
@@ -1546,7 +1548,7 @@ describe('CozyClient', () => {
     })
 
     it('should then dispatch a RECEIVE_MUTATION_RESULT action', async () => {
-      requestHandler.mockReturnValueOnce(Promise.resolve(fakeResponse))
+      requestHandler.mockResolvedValueOnce(fakeResponse)
       await client.mutate(mutation, { as: 'updateTodo' })
       expect(client.store.dispatch.mock.calls[1][0]).toEqual(
         receiveMutationResult('updateTodo', fakeResponse, {}, mutation)
@@ -1554,14 +1556,14 @@ describe('CozyClient', () => {
     })
 
     it('should resolve to the mutation response', async () => {
-      requestHandler.mockReturnValueOnce(Promise.resolve(fakeResponse))
+      requestHandler.mockResolvedValueOnce(fakeResponse)
       const resp = await client.mutate(mutation)
       expect(resp).toEqual(fakeResponse)
     })
 
     it('should dispatch a RECEIVE_MUTATION_ERROR action if an error occurs', async () => {
       const error = new Error('Fake error')
-      requestHandler.mockReturnValueOnce(Promise.reject(error))
+      requestHandler.mockRejectedValueOnce(error)
       try {
         await client.mutate(mutation, { as: 'updateTodo' })
       } catch (e) {} // eslint-disable-line no-empty
@@ -1573,7 +1575,7 @@ describe('CozyClient', () => {
     it('should handle an array of mutations (including mutation creators)', async () => {
       const FAKE_MUTATION_1 = { mutationType: 'FAKE_1' }
       const FAKE_MUTATION_2 = resp => ({ mutationType: 'FAKE_2', resp })
-      requestHandler.mockReturnValue(Promise.resolve(fakeResponse))
+      requestHandler.mockResolvedValue(fakeResponse)
       await client.mutate([mutation, FAKE_MUTATION_1, FAKE_MUTATION_2])
       expect(requestHandler).toHaveBeenCalledTimes(3)
       expect(requestHandler.mock.calls[0][0]).toBe(mutation)

package/dist/assets/qualifications.json

@@ -216,7 +216,7 @@
       "purpose": "attestation",
       "sourceCategory": "gov",
       "sourceSubCategory": "transport",
-      "subjects": ["vehicule", "indentity", "right"]
+      "subjects": ["vehicule", "identity", "right"]
     },
     {
       "label": "car_insurance",

package/dist/associations.spec.js

@@ -119,7 +119,7 @@ describe('Associations', () => {
         ],
         next: false
       }
-      requestHandler.mockReturnValueOnce(Promise.resolve(FAKE_RESPONSE))
+      requestHandler.mockResolvedValueOnce(FAKE_RESPONSE)
 
       const queryBefore = getQueryFromStore(client.store, 'allTodos')
       await getTodo(TODO_1._id).attachments.fetchMore()

package/dist/helpers.js

@@ -5,12 +5,34 @@ var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefau
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.generateWebLink = exports.dehydrate = void 0;
+exports.rootCozyUrl = exports.InvalidCozyUrlError = exports.InvalidProtocolError = exports.generateWebLink = exports.dehydrate = void 0;
+
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+
+var _toArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toArray"));
+
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+
+var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
+
+var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
+
+var _wrapNativeSuper2 = _interopRequireDefault(require("@babel/runtime/helpers/wrapNativeSuper"));
 
 var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
 
 var _associations = require("./associations");
 
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = (0, _getPrototypeOf2.default)(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = (0, _getPrototypeOf2.default)(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return (0, _possibleConstructorReturn2.default)(this, result); }; }
+
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } }
+
 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); }
@@ -103,4 +125,275 @@ var generateWebLink = function generateWebLink(_ref3) {
   return url.toString();
 };
 
-exports.generateWebLink = generateWebLink;
+exports.generateWebLink = generateWebLink;
+
+var InvalidProtocolError = /*#__PURE__*/function (_Error) {
+  (0, _inherits2.default)(InvalidProtocolError, _Error);
+
+  var _super = _createSuper(InvalidProtocolError);
+
+  function InvalidProtocolError(url) {
+    var _this;
+
+    (0, _classCallCheck2.default)(this, InvalidProtocolError);
+    _this = _super.call(this, "Invalid URL protocol ".concat(url.protocol));
+    _this.url = url;
+    return _this;
+  }
+
+  return InvalidProtocolError;
+}( /*#__PURE__*/(0, _wrapNativeSuper2.default)(Error));
+
+exports.InvalidProtocolError = InvalidProtocolError;
+
+var InvalidCozyUrlError = /*#__PURE__*/function (_Error2) {
+  (0, _inherits2.default)(InvalidCozyUrlError, _Error2);
+
+  var _super2 = _createSuper(InvalidCozyUrlError);
+
+  function InvalidCozyUrlError(url) {
+    var _this2;
+
+    (0, _classCallCheck2.default)(this, InvalidCozyUrlError);
+    _this2 = _super2.call(this, "URL ".concat(url.toString(), " does not seem to be a valid Cozy URL"));
+    _this2.url = url;
+    return _this2;
+  }
+
+  return InvalidCozyUrlError;
+}( /*#__PURE__*/(0, _wrapNativeSuper2.default)(Error));
+/* uri - Returns a well formed URL origin from a protocol, a hostname and a port
+ *
+ * If the protocol and/or port are omitted from the argument, the function will
+ * default to HTTPS and omit the port in the returned origin.
+ *
+ * @param {object} url          Object of URL elements
+ * @param {string} url.protocol Protocol to use in the origin (e.g. http)
+ * @param {string} url.hostname Hostname to use in the origin (e.g. claude.mycozy.cloud)
+ * @param {string} url.port     Port to use in the origin (e.g. 8080)
+ *
+ * @returns {string} Generated URL origin
+ */
+
+
+exports.InvalidCozyUrlError = InvalidCozyUrlError;
+
+var uri = function uri(_ref4) {
+  var protocol = _ref4.protocol,
+      hostname = _ref4.hostname,
+      port = _ref4.port;
+  return (protocol !== '' ? "".concat(protocol, "//") : 'https://') + hostname + (port !== '' ? ":".concat(port) : '');
+};
+/* wellKnownUrl - Returns a valid URL string to a Well Known password change page
+ *
+ * The built URL will point to the origin generated from the given protocol,
+ * hostname and port.
+ *
+ * @param {object} url          Object of URL elements
+ * @param {string} url.protocol Protocol to use in the origin (e.g. http)
+ * @param {string} url.hostname Hostname to use in the origin (e.g. claude.mycozy.cloud)
+ * @param {string} url.port     Port to use in the origin (e.g. 8080)
+ *
+ * @returns {string} Generated Well Known password change URL string
+ */
+
+
+var wellKnownUrl = function wellKnownUrl(url) {
+  return uri(url) + '/.well-known/change-password';
+};
+/* isValidOrigin - Checks whether a given URL is a valid Cozy origin
+ *
+ * This method tries to fetch the Well Known change password page of the Cozy
+ * supposedly at the given origin. This allows us to determine whether the given
+ * origin is the root URL of a Cozy or not via the status of the response:
+ * - a 200 response status means there's an actual Well Known password change
+ *   page accessible from the given origin so we suppose it's a valid Cozy
+ *   origin (i.e. it could be another site altogether though)
+ * - a 401 response status means the pointed page requires authentication so the
+ *   origin is probably pointing to a Cozy app
+ * - another status means there aren't any Cozy behind to the given origin
+ *
+ * @param {object} url          Object of URL elements
+ * @param {string} url.protocol Protocol to use in the origin (e.g. http)
+ * @param {string} url.hostname Hostname to use in the origin (e.g. claude.mycozy.cloud)
+ * @param {string} url.port     Port to use in the origin (e.g. 8080)
+ *
+ * @returns {Promise<boolean>} True if we believe there's a Cozy behind the given origin
+ * @throws {InvalidCozyUrlError} Thrown when we know for sure there aren't any Cozy behind the given origin
+ */
+
+
+var isValidOrigin = /*#__PURE__*/function () {
+  var _ref5 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee(url) {
+    var _yield$fetch, status;
+
+    return _regenerator.default.wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            _context.next = 2;
+            return fetch(wellKnownUrl(url));
+
+          case 2:
+            _yield$fetch = _context.sent;
+            status = _yield$fetch.status;
+
+            if (!(status === 404)) {
+              _context.next = 6;
+              break;
+            }
+
+            throw new InvalidCozyUrlError(url);
+
+          case 6:
+            return _context.abrupt("return", status === 200);
+
+          case 7:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee);
+  }));
+
+  return function isValidOrigin(_x) {
+    return _ref5.apply(this, arguments);
+  };
+}();
+/**
+ * rootCozyUrl - Get the root URL of a Cozy from more precise ones
+ *
+ * The goal is to allow users to use any URL copied from their browser as their
+ * Cozy URL rather than trying to explain to them what we expect (e.g. when
+ * requesting the Cozy URL to connect an app).
+ * If we can't get the root URL either because there's no Cozy or the domain
+ * does not exist or anything else, we'll throw an InvalidCozyUrlError.
+ * Also, since we communicate only via HTTP or HTTPS, we'll throw an
+ * InvalidProtocolError if any other protocol is used.
+ *
+ * This function expects a fully qualified URL thus with a protocol and a valid
+ * hostname. If your application accepts Cozy intances as input (e.g. `claude`
+ * when the Cozy can be found at `https://claude.mycozy.cloud`), it is your
+ * responsibility to add the appropriate domain to the hostname before calling
+ * this function.
+ *
+ * Examples:
+ *
+ * 1. getting the root URL when your user gives you its instance name
+ *
+ *   const userInput = 'claude'
+ *   const rootUrl = await rootCozyUrl(new URL(`https://${userInput}.mycozy.cloud`))
+ *   // → returns new URL('https://claude.mycozy.cloud')
+ *
+ * 2. getting the root URL when your user gives you a Cozy Drive URL
+ *
+ *   const userInput = 'https://claude-drive.mycozy.cloud/#/folder/io.cozy.files.root-dir'
+ *   const rootUrl = await rootCozyUrl(new URL(userInput))
+ *   // → returns new URL('https://claude.mycozy.cloud')
+ *
+ * 3. getting the root URL when the Cozy uses nested sub-domains
+ *
+ *   const userInput = 'http://photos.camille.nimbus.com:8080/#/album/1234567890'
+ *   const rootCozyUrl = await rootCozyUrl(new URL(userInput))
+ *   // → returns new URL('http://camille.nimbus.com:8080')
+ *
+ * @param {URL} url The URL from which we'll try to get the root Cozy URL
+ *
+ * @returns {Promise<URL>} The root Cozy URL
+ */
+
+
+var rootCozyUrl = /*#__PURE__*/function () {
+  var _ref6 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee2(url) {
+    var _url$hostname$split, _url$hostname$split2, subDomain, domain, _hostname, hostname;
+
+    return _regenerator.default.wrap(function _callee2$(_context2) {
+      while (1) {
+        switch (_context2.prev = _context2.next) {
+          case 0:
+            if (['http:', 'https:'].includes(url.protocol)) {
+              _context2.next = 2;
+              break;
+            }
+
+            throw new InvalidProtocolError(url);
+
+          case 2:
+            _context2.next = 4;
+            return isValidOrigin(url);
+
+          case 4:
+            if (!_context2.sent) {
+              _context2.next = 6;
+              break;
+            }
+
+            return _context2.abrupt("return", url);
+
+          case 6:
+            if (!/^[^.-][^.]+-[^.-]+\./.test(url.hostname)) {
+              _context2.next = 13;
+              break;
+            }
+
+            _url$hostname$split = url.hostname.split('.'), _url$hostname$split2 = (0, _toArray2.default)(_url$hostname$split), subDomain = _url$hostname$split2[0], domain = _url$hostname$split2.slice(1);
+            _hostname = [subDomain.replace(/-.+/, '')].concat((0, _toConsumableArray2.default)(domain)).join('.');
+            _context2.next = 11;
+            return isValidOrigin({
+              protocol: url.protocol,
+              hostname: _hostname,
+              port: url.port
+            });
+
+          case 11:
+            if (!_context2.sent) {
+              _context2.next = 13;
+              break;
+            }
+
+            return _context2.abrupt("return", new URL(uri({
+              protocol: url.protocol,
+              hostname: _hostname,
+              port: url.port
+            })));
+
+          case 13:
+            // Try to remove the first sub-domain in case its a nested app name
+            // eslint-disable-next-line no-unused-vars
+            hostname = url.hostname.split('.').splice(1).join('.');
+            _context2.next = 16;
+            return isValidOrigin({
+              protocol: url.protocol,
+              hostname: hostname,
+              port: url.port
+            });
+
+          case 16:
+            if (!_context2.sent) {
+              _context2.next = 18;
+              break;
+            }
+
+            return _context2.abrupt("return", new URL(uri({
+              protocol: url.protocol,
+              hostname: hostname,
+              port: url.port
+            })));
+
+          case 18:
+            throw new InvalidCozyUrlError(url);
+
+          case 19:
+          case "end":
+            return _context2.stop();
+        }
+      }
+    }, _callee2);
+  }));
+
+  return function rootCozyUrl(_x2) {
+    return _ref6.apply(this, arguments);
+  };
+}();
+
+exports.rootCozyUrl = rootCozyUrl;

package/dist/helpers.spec.js

@@ -1,4 +1,12 @@
-import { dehydrate, generateWebLink } from './helpers'
+import { enableFetchMocks, disableFetchMocks } from 'jest-fetch-mock'
+
+import {
+  dehydrate,
+  generateWebLink,
+  rootCozyUrl,
+  InvalidCozyUrlError,
+  InvalidProtocolError
+} from './helpers'
 
 import {
   HasManyInPlace,
@@ -141,3 +149,234 @@ describe('generateWebLink', () => {
     ).toEqual(`https://drive.alice.cozy.tools/public/#/files/432432`)
   })
 })
+
+describe('rootCozyUrl', () => {
+  beforeAll(() => {
+    enableFetchMocks()
+  })
+
+  afterAll(() => {
+    disableFetchMocks()
+  })
+
+  it('should handle cozy-hosted https', async () => {
+    fetch.mockOnceIf(
+      'https://camillenimbus.mycozy.cloud/.well-known/change-password',
+      {},
+      { status: 200 }
+    )
+
+    await expect(
+      rootCozyUrl(new URL('https://camillenimbus.mycozy.cloud'))
+    ).resolves.toEqual(new URL('https://camillenimbus.mycozy.cloud'))
+  })
+
+  it('should handle cozy-hosted https trailing slash', async () => {
+    fetch.mockOnceIf(
+      'https://camillenimbus.mycozy.cloud/.well-known/change-password',
+      {},
+      { status: 200 }
+    )
+
+    await expect(
+      rootCozyUrl(new URL('https://camillenimbus.mycozy.cloud/'))
+    ).resolves.toEqual(new URL('https://camillenimbus.mycozy.cloud'))
+  })
+
+  it('should handle cozy-hosted https trailing path', async () => {
+    fetch.mockOnceIf(
+      'https://camillenimbus.mycozy.cloud/.well-known/change-password',
+      {},
+      { status: 200 }
+    )
+
+    await expect(
+      rootCozyUrl(new URL('https://camillenimbus.mycozy.cloud/some-path'))
+    ).resolves.toEqual(new URL('https://camillenimbus.mycozy.cloud'))
+  })
+
+  it('should handle cozy-hosted drive web app url', async () => {
+    fetch.mockOnceIf(
+      'https://camillenimbus-drive.mycozy.cloud/.well-known/change-password',
+      {},
+      { status: 401 }
+    )
+    fetch.mockOnceIf(
+      'https://camillenimbus.mycozy.cloud/.well-known/change-password',
+      {},
+      { status: 200 }
+    )
+
+    await expect(
+      rootCozyUrl(new URL('https://camillenimbus-drive.mycozy.cloud/#/folder'))
+    ).resolves.toEqual(new URL('https://camillenimbus.mycozy.cloud'))
+  })
+
+  it('should handle cozy-hosted photos album url', async () => {
+    fetch.mockOnceIf(
+      'https://camillenimbus-photos.mycozy.cloud/.well-known/change-password',
+      {},
+      { status: 401 }
+    )
+    fetch.mockOnceIf(
+      'https://camillenimbus.mycozy.cloud/.well-known/change-password',
+      {},
+      { status: 200 }
+    )
+
+    await expect(
+      rootCozyUrl(
+        new URL(
+          'https://camillenimbus-photos.mycozy.cloud/#/albums/68b5cda502ae29f5fa73fd89f1be4f92'
+        )
+      )
+    ).resolves.toEqual(new URL('https://camillenimbus.mycozy.cloud'))
+  })
+
+  it('should handle cozy-hosted app name', async () => {
+    fetch.mockOnceIf(
+      'https://camillenimbus-drive.mycozy.cloud/.well-known/change-password',
+      {},
+      { status: 401 }
+    )
+    fetch.mockOnceIf(
+      'https://camillenimbus.mycozy.cloud/.well-known/change-password',
+      {},
+      { status: 200 }
+    )
+
+    await expect(
+      rootCozyUrl(new URL('https://camillenimbus-drive.mycozy.cloud'))
+    ).resolves.toEqual(new URL('https://camillenimbus.mycozy.cloud'))
+  })
+
+  it('should handle self-hosted https', async () => {
+    fetch.mockOnceIf(
+      'https://camillenimbus.com/.well-known/change-password',
+      {},
+      { status: 200 }
+    )
+
+    await expect(
+      rootCozyUrl(new URL('https://camillenimbus.com'))
+    ).resolves.toEqual(new URL('https://camillenimbus.com'))
+  })
+
+  it('should handle self-hosted with dash', async () => {
+    fetch.mockOnceIf(
+      'https://camille-nimbus.com/.well-known/change-password',
+      {},
+      {
+        status: 200
+      }
+    )
+
+    await expect(
+      rootCozyUrl(new URL('https://camille-nimbus.com'))
+    ).resolves.toEqual(new URL('https://camille-nimbus.com'))
+  })
+
+  it('should handle self-hosted http', async () => {
+    fetch.mockOnceIf(
+      'http://camille-nimbus.com/.well-known/change-password',
+      {},
+      {
+        status: 200
+      }
+    )
+
+    await expect(
+      rootCozyUrl(new URL('http://camille-nimbus.com'))
+    ).resolves.toEqual(new URL('http://camille-nimbus.com'))
+  })
+
+  it('should handle self-hosted https with port', async () => {
+    fetch.mockOnceIf(
+      'https://camillenimbus.com:666/.well-known/change-password',
+      {},
+      {
+        status: 200
+      }
+    )
+
+    await expect(
+      rootCozyUrl(new URL('https://camillenimbus.com:666'))
+    ).resolves.toEqual(new URL('https://camillenimbus.com:666'))
+  })
+
+  it('should handle self-hosted nested drive web app url', async () => {
+    fetch.mockOnceIf(
+      'https://drive.camillenimbus.com/.well-known/change-password',
+      {},
+      {
+        status: 401
+      }
+    )
+    fetch.mockOnceIf(
+      'https://camillenimbus.com/.well-known/change-password',
+      {},
+      {
+        status: 200
+      }
+    )
+
+    await expect(
+      rootCozyUrl(new URL('https://drive.camillenimbus.com/#/folder'))
+    ).resolves.toEqual(new URL('https://camillenimbus.com'))
+  })
+
+  it('should handle self-hosted flat drive web app url', async () => {
+    fetch.mockOnceIf(
+      'https://camille-drive.nimbus.com/.well-known/change-password',
+      {},
+      {
+        status: 401
+      }
+    )
+    fetch.mockOnceIf(
+      'https://camille.nimbus.com/.well-known/change-password',
+      {},
+      {
+        status: 200
+      }
+    )
+
+    await expect(
+      rootCozyUrl(new URL('https://camille-drive.nimbus.com/#/folder'))
+    ).resolves.toEqual(new URL('https://camille.nimbus.com'))
+  })
+
+  it('should handle cozy.localhost', async () => {
+    await expect(
+      rootCozyUrl(new URL('http://cozy.localhost:8080'))
+    ).resolves.toEqual(new URL('http://cozy.localhost:8080'))
+  })
+
+  it('expects an http or https protocol', async () => {
+    fetch.mockOnceIf(
+      'ftp://camillenimbus.com',
+      {},
+      {
+        status: 200
+      }
+    )
+
+    await expect(
+      rootCozyUrl(new URL('ftp://camillenimbus.com'))
+    ).rejects.toBeInstanceOf(InvalidProtocolError)
+  })
+
+  it('rejects if URL points to a valid cozy-stack but no valid Cozy instance', async () => {
+    fetch.mockOnceIf(
+      'https://missing.mycozy.cloud',
+      {},
+      {
+        status: 404
+      }
+    )
+
+    await expect(
+      rootCozyUrl(new URL('https://missing.mycozy.cloud'))
+    ).rejects.toBeInstanceOf(InvalidCozyUrlError)
+  })
+})

package/dist/hooks/useQuery.spec.jsx

@@ -214,7 +214,7 @@ describe('use query', () => {
       links: [new CozyLink(requestHandler)]
     })
     const error = new TypeError('Failed to fetch')
-    requestHandler.mockReturnValue(Promise.reject(error))
+    requestHandler.mockRejectedValue(error)
     const onError = jest.fn().mockReturnValue(() => true)
     setupQuery({
       customClient: client,

package/dist/index.js

@@ -28,6 +28,9 @@ var _exportNames = {
   getReferencedById: true,
   dehydrate: true,
   generateWebLink: true,
+  rootCozyUrl: true,
+  InvalidCozyUrlError: true,
+  InvalidProtocolError: true,
   cancelable: true,
   isQueryLoading: true,
   hasQueryBeenLoaded: true,
@@ -172,6 +175,24 @@ Object.defineProperty(exports, "generateWebLink", {
     return _helpers2.generateWebLink;
   }
 });
+Object.defineProperty(exports, "rootCozyUrl", {
+  enumerable: true,
+  get: function get() {
+    return _helpers2.rootCozyUrl;
+  }
+});
+Object.defineProperty(exports, "InvalidCozyUrlError", {
+  enumerable: true,
+  get: function get() {
+    return _helpers2.InvalidCozyUrlError;
+  }
+});
+Object.defineProperty(exports, "InvalidProtocolError", {
+  enumerable: true,
+  get: function get() {
+    return _helpers2.InvalidProtocolError;
+  }
+});
 Object.defineProperty(exports, "cancelable", {
   enumerable: true,
   get: function get() {

package/dist/index.node.js

@@ -24,6 +24,9 @@ var _exportNames = {
   HasManyTriggers: true,
   dehydrate: true,
   generateWebLink: true,
+  rootCozyUrl: true,
+  InvalidCozyUrlError: true,
+  InvalidProtocolError: true,
   cancelable: true,
   getQueryFromState: true,
   Registry: true,
@@ -133,6 +136,24 @@ Object.defineProperty(exports, "generateWebLink", {
     return _helpers.generateWebLink;
   }
 });
+Object.defineProperty(exports, "rootCozyUrl", {
+  enumerable: true,
+  get: function get() {
+    return _helpers.rootCozyUrl;
+  }
+});
+Object.defineProperty(exports, "InvalidCozyUrlError", {
+  enumerable: true,
+  get: function get() {
+    return _helpers.InvalidCozyUrlError;
+  }
+});
+Object.defineProperty(exports, "InvalidProtocolError", {
+  enumerable: true,
+  get: function get() {
+    return _helpers.InvalidProtocolError;
+  }
+});
 Object.defineProperty(exports, "cancelable", {
   enumerable: true,
   get: function get() {

package/dist/utils.spec.js

@@ -22,6 +22,7 @@ describe('cancelable', () => {
   })
 
   it('should reject with the rejection of the promise', done => {
+    jest.spyOn(console, 'log').mockImplementation()
     const error = 'normal-rejection-from-cancelable-test'
     const { reject, wrapped } = setup()
     expect.assertions(1)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cozy-client",
-  "version": "27.13.0",
+  "version": "27.14.3",
   "license": "MIT",
   "main": "dist/index.node.js",
   "browser": "dist/index.js",
@@ -21,7 +21,7 @@
     "cozy-device-helper": "^1.12.0",
     "cozy-flags": "2.7.1",
     "cozy-logger": "^1.6.0",
-    "cozy-stack-client": "^27.9.0",
+    "cozy-stack-client": "^27.14.1",
     "json-stable-stringify": "^1.0.1",
     "lodash": "^4.17.13",
     "microee": "^0.0.6",
@@ -71,5 +71,5 @@
     "react-native-ios11-devicecheck": "https://github.com/cozy/react-native-devicecheck#app-attest-v0.1"
   },
   "sideEffects": false,
-  "gitHead": "722612063fc639ce573a2b4239970cd13e61d2fb"
+  "gitHead": "786f6d73d3d1cc0f423776e2af642f8bdd3fba2c"
 }

package/types/CozyClient.d.ts

@@ -652,6 +652,7 @@ declare class CozyClient {
      * At any time put an error function
      *
      * @param {Function} [onError] - Set a callback for queries which are errored
+     * @throws {Error} onError should not have been defined yet
      */
     setOnError(onError?: Function): void;
     toJSON(): SnapshotClient;

package/types/helpers.d.ts

@@ -7,3 +7,12 @@ export function generateWebLink({ cozyUrl, searchParams: searchParamsOption, pat
     slug: string;
     subDomainType: string;
 }): string;
+export class InvalidProtocolError extends Error {
+    constructor(url: any);
+    url: any;
+}
+export class InvalidCozyUrlError extends Error {
+    constructor(url: any);
+    url: any;
+}
+export function rootCozyUrl(url: URL): Promise<URL>;

package/types/index.d.ts

@@ -19,6 +19,6 @@ export { manifest, models };
 export { QueryDefinition, Q, Mutations, MutationTypes, getDoctypeFromOperation } from "./queries/dsl";
 export { Association, HasMany, HasOne, HasOneInPlace, HasManyInPlace, HasManyTriggers } from "./associations";
 export { isReferencedBy, isReferencedById, getReferencedBy, getReferencedById } from "./associations/helpers";
-export { dehydrate, generateWebLink } from "./helpers";
+export { dehydrate, generateWebLink, rootCozyUrl, InvalidCozyUrlError, InvalidProtocolError } from "./helpers";
 export { cancelable, isQueryLoading, hasQueryBeenLoaded } from "./utils";
 export { queryConnect, queryConnectFlat, withClient } from "./hoc";

package/types/index.node.d.ts

@@ -13,4 +13,4 @@ import * as models from "./models";
 export { manifest, models };
 export { QueryDefinition, Mutations, MutationTypes, getDoctypeFromOperation, Q } from "./queries/dsl";
 export { Association, HasMany, HasOne, HasOneInPlace, HasManyInPlace, HasManyTriggers } from "./associations";
-export { dehydrate, generateWebLink } from "./helpers";
+export { dehydrate, generateWebLink, rootCozyUrl, InvalidCozyUrlError, InvalidProtocolError } from "./helpers";