cozy-client 27.11.0 → 27.14.0

package/CHANGELOG.md

@@ -3,6 +3,47 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# [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)
+
+
+### Features
+
+* Add fetchBlobFileById function ([eb37b1a](https://github.com/cozy/cozy-client/commit/eb37b1af091d3e95372a0540ad0f14ba59e74a4c))
+
+
+
+
+
+# [27.12.0](https://github.com/cozy/cozy-client/compare/v27.11.1...v27.12.0) (2022-01-14)
+
+
+### Features
+
+* Use lib alias for safetynet ([f937db5](https://github.com/cozy/cozy-client/commit/f937db5eaedf4d41e88f7380ffbe79867941af59))
+
+
+
+
+
+## [27.11.1](https://github.com/cozy/cozy-client/compare/v27.11.0...v27.11.1) (2022-01-14)
+
+**Note:** Version bump only for package cozy-client
+
+
+
+
+
 # [27.11.0](https://github.com/cozy/cozy-client/compare/v27.10.0...v27.11.0) (2022-01-13)
 
 

package/dist/CozyClient.js

@@ -2463,7 +2463,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.11.0";
+CozyClient.version = "27.14.0";
 
 _microee.default.mixin(CozyClient);
 

package/dist/flagship-certification/README.md

@@ -50,13 +50,13 @@ The `attestation`'s content is described in the `AppAttest`'s documentation: htt
 
 ## Client's configuration
 
-In order to configure `flagship` certification on an app, the OAuth property of `cozy-client` must contain `shouldRequireFlagshipPermissions` property set to `true` and `certificationConfig` property filled with required API keys.
+In order to configure `flagship` certification on an app, the OAuth property of `cozy-client` must contain `shouldRequireFlagshipPermissions` property set to `true` and `certificationConfig` property filled with required API keys. In that case, the OAuth client can claims "*" as scope
 
 Example of `cozy-client` configuration:
 ```js
 const client = await initClient(uri, {
     scope: [
-      'io.cozy.apps'
+      '*'
     ],
     oauth: {
       redirectURI: 'REDIRECT_URI',

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

@@ -8,7 +8,7 @@ Object.defineProperty(exports, "__esModule", {
 exports.normalize = normalize;
 exports.ensureFilePath = ensureFilePath;
 exports.getParentFolderId = getParentFolderId;
-exports.isFromKonnector = exports.hasCertifications = exports.hasQualifications = exports.isPlainText = exports.doMobileUpload = exports.readMobileFile = exports.uploadFileWithConflictStrategy = exports.generateFileNameForRevision = exports.generateNewFileNameOnConflict = exports.overrideFileForPath = exports.move = exports.getFullpath = exports.hasMetadataAttribute = exports.isReferencedByAlbum = exports.fetchFilesByQualificationRules = exports.saveFileQualification = exports.isSharingShorcutNew = exports.isSharingShortcutNew = exports.isSharingShorcut = exports.isSharingShortcut = exports.getSharingShortcutTargetDoctype = exports.getSharingShortcutTargetMime = exports.getSharingShortcutStatus = exports.isShortcut = exports.shouldBeOpenedByOnlyOffice = exports.isOnlyOfficeFile = exports.isNote = exports.isDirectory = exports.isFile = exports.splitFilename = exports.ALBUMS_DOCTYPE = void 0;
+exports.fetchBlobFileById = exports.isFromKonnector = exports.hasCertifications = exports.hasQualifications = exports.isPlainText = exports.doMobileUpload = exports.readMobileFile = exports.uploadFileWithConflictStrategy = exports.generateFileNameForRevision = exports.generateNewFileNameOnConflict = exports.overrideFileForPath = exports.move = exports.getFullpath = exports.hasMetadataAttribute = exports.isReferencedByAlbum = exports.fetchFilesByQualificationRules = exports.saveFileQualification = exports.isSharingShorcutNew = exports.isSharingShortcutNew = exports.isSharingShorcut = exports.isSharingShortcut = exports.getSharingShortcutTargetDoctype = exports.getSharingShortcutTargetMime = exports.getSharingShortcutStatus = exports.isShortcut = exports.shouldBeOpenedByOnlyOffice = exports.isOnlyOfficeFile = exports.isNote = exports.isDirectory = exports.isFile = exports.splitFilename = exports.ALBUMS_DOCTYPE = void 0;
 
 var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
 
@@ -1023,5 +1023,46 @@ exports.hasCertifications = hasCertifications;
 var isFromKonnector = function isFromKonnector(file) {
   return (0, _has.default)(file, 'cozyMetadata.sourceAccount');
 };
+/**
+ * @param {CozyClient} client - Instance of CozyClient
+ * @param {string} fileId - Id of io.cozy.files document
+ * @returns {Promise<Blob>}
+ */
+
+
+exports.isFromKonnector = isFromKonnector;
+
+var fetchBlobFileById = /*#__PURE__*/function () {
+  var _ref13 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee12(client, fileId) {
+    var fileColl, fileBin, fileBlob;
+    return _regenerator.default.wrap(function _callee12$(_context12) {
+      while (1) {
+        switch (_context12.prev = _context12.next) {
+          case 0:
+            fileColl = client.collection(_const.DOCTYPE_FILES);
+            _context12.next = 3;
+            return fileColl.fetchFileContentById(fileId);
+
+          case 3:
+            fileBin = _context12.sent;
+            _context12.next = 6;
+            return fileBin.blob();
+
+          case 6:
+            fileBlob = _context12.sent;
+            return _context12.abrupt("return", fileBlob);
+
+          case 8:
+          case "end":
+            return _context12.stop();
+        }
+      }
+    }, _callee12);
+  }));
+
+  return function fetchBlobFileById(_x25, _x26) {
+    return _ref13.apply(this, arguments);
+  };
+}();
 
-exports.isFromKonnector = isFromKonnector;
+exports.fetchBlobFileById = fetchBlobFileById;

package/dist/models/file.spec.js

@@ -15,6 +15,7 @@ const statByPathSpy = jest.fn().mockName('statByPath')
 const updateFileMetadataSpy = jest.fn().mockName('updateFileMetadata')
 const createFileSpy = jest.fn().mockName('createFileSpy')
 const updateFileSpy = jest.fn().mockName('updateFileSpy')
+const fetchFileContentByIdSpy = jest.fn().mockName('fetchFileContentById')
 
 beforeAll(() => {
   cozyClient.stackClient.collection.mockReturnValue({
@@ -23,7 +24,8 @@ beforeAll(() => {
     statByPath: statByPathSpy,
     updateFileMetadata: updateFileMetadataSpy,
     createFile: createFileSpy,
-    updateFile: updateFileSpy
+    updateFile: updateFileSpy,
+    fetchFileContentById: fetchFileContentByIdSpy
   })
 })
 
@@ -702,6 +704,21 @@ describe('File Model', () => {
       })
     })
   })
+
+  describe('fetchBlobFileById', () => {
+    const mockData = { _id: '001', name: 'file01' }
+
+    it('should return Blob data', async () => {
+      fetchFileContentByIdSpy.mockImplementation(() => ({
+        blob: jest.fn().mockReturnValue(new Blob([mockData]))
+      }))
+      const res = await fileModel.fetchBlobFileById(cozyClient, mockData._id)
+
+      expect(fetchFileContentByIdSpy).toHaveBeenCalledWith('001')
+      expect(res instanceof Blob).toEqual(true)
+      expect(res.size).toBeGreaterThan(0)
+    })
+  })
 })
 
 describe('File qualification', () => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cozy-client",
-  "version": "27.11.0",
+  "version": "27.14.0",
   "license": "MIT",
   "main": "dist/index.node.js",
   "browser": "dist/index.js",
@@ -66,10 +66,10 @@
     "cozy-ui": ">34.0.0",
     "react": "^16.7.0",
     "react-native": "^0.65.0",
-    "react-native-google-safetynet": "0.0.4",
+    "react-native-google-safetynet": "npm:cozy-react-native-google-safetynet@^1.0.0",
     "react-native-inappbrowser-reborn": "^3.5.1",
     "react-native-ios11-devicecheck": "https://github.com/cozy/react-native-devicecheck#app-attest-v0.1"
   },
   "sideEffects": false,
-  "gitHead": "97bc6226b59db1d7c41b96cffc0d48ce68d182ef"
+  "gitHead": "f8e408f1835b82e486c15d2a3ff122067313f552"
 }

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";

package/types/models/file.d.ts

@@ -61,6 +61,7 @@ export function isPlainText(mimeType?: string, fileName?: string): boolean;
 export function hasQualifications(file: IOCozyFile): boolean;
 export function hasCertifications(file: IOCozyFile): boolean;
 export function isFromKonnector(file: IOCozyFile): boolean;
+export function fetchBlobFileById(client: CozyClient, fileId: string): Promise<Blob>;
 export type FileUploadOptions = {
     /**
      * - The file name to upload