cozy-client 38.11.1 → 40.0.0

package/dist/CozyClient.js

@@ -2263,9 +2263,17 @@ var CozyClient = /*#__PURE__*/function () {
           while (1) {
             switch (_context17.prev = _context17.next) {
               case 0:
+                if (!(this.stackClient instanceof _cozyStackClient.OAuthClient)) {
+                  _context17.next = 4;
+                  break;
+                }
+
                 return _context17.abrupt("return", this.stackClient.checkForRevocation());
 
-              case 1:
+              case 4:
+                throw 'checkForRevocation is only implemented for OAutClient';
+
+              case 5:
               case "end":
                 return _context17.stop();
             }
@@ -2677,7 +2685,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 = "38.11.1";
+CozyClient.version = "40.0.0";
 
 _microee.default.mixin(CozyClient);
 

package/dist/CozyClient.spec.js

@@ -2060,3 +2060,34 @@ describe('document creation', () => {
     expect(updatedDoc.data.relationships.authors.data[0]._id).toBe(1)
   })
 })
+
+describe('CozyClient revocation handling', () => {
+  let client
+  let mockCallback
+
+  beforeEach(() => {
+    client = new CozyClient({})
+    client.stackClient.refreshToken = jest.fn().mockImplementation(() => {
+      client.stackClient.onRevocationChange(true)
+    })
+
+    mockCallback = jest.fn()
+    client.on('revoked', mockCallback)
+  })
+
+  it('should call "revoked" event when token is expired', async () => {
+    await client.stackClient.refreshToken()
+
+    expect(mockCallback).toHaveBeenCalledTimes(1)
+  })
+
+  it('should not call "revoked" event when token is not expired', async () => {
+    client.stackClient.refreshToken = jest.fn().mockImplementation(() => {
+      client.stackClient.onRevocationChange(false)
+    })
+
+    await client.stackClient.refreshToken()
+
+    expect(mockCallback).not.toHaveBeenCalled()
+  })
+})

package/dist/helpers/index.js

@@ -51,6 +51,12 @@ Object.defineProperty(exports, "InvalidProtocolError", {
     return _urlHelper.InvalidProtocolError;
   }
 });
+Object.defineProperty(exports, "BlockedCozyError", {
+  enumerable: true,
+  get: function get() {
+    return _urlHelper.BlockedCozyError;
+  }
+});
 Object.defineProperty(exports, "dehydrate", {
   enumerable: true,
   get: function get() {

package/dist/helpers/urlHelper.js

@@ -5,7 +5,7 @@ var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefau
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.rootCozyUrl = exports.InvalidCozyUrlError = exports.InvalidProtocolError = exports.InvalidRedirectLinkError = exports.deconstructRedirectLink = exports.deconstructCozyWebLinkWithSlug = exports.generateWebLink = exports.ensureFirstSlash = void 0;
+exports.rootCozyUrl = exports.InvalidCozyUrlError = exports.BlockedCozyError = exports.InvalidProtocolError = exports.InvalidRedirectLinkError = exports.deconstructRedirectLink = exports.deconstructCozyWebLinkWithSlug = exports.generateWebLink = exports.ensureFirstSlash = void 0;
 
 var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
 
@@ -206,20 +206,39 @@ var InvalidProtocolError = /*#__PURE__*/function (_Error2) {
 
 exports.InvalidProtocolError = InvalidProtocolError;
 
-var InvalidCozyUrlError = /*#__PURE__*/function (_Error3) {
-  (0, _inherits2.default)(InvalidCozyUrlError, _Error3);
+var BlockedCozyError = /*#__PURE__*/function (_Error3) {
+  (0, _inherits2.default)(BlockedCozyError, _Error3);
 
-  var _super3 = _createSuper(InvalidCozyUrlError);
+  var _super3 = _createSuper(BlockedCozyError);
 
-  function InvalidCozyUrlError(url) {
+  function BlockedCozyError(url) {
     var _this3;
 
-    (0, _classCallCheck2.default)(this, InvalidCozyUrlError);
-    _this3 = _super3.call(this, "URL ".concat(url.toString(), " does not seem to be a valid Cozy URL"));
+    (0, _classCallCheck2.default)(this, BlockedCozyError);
+    _this3 = _super3.call(this, "Blocked cozy ".concat(url.toString()));
     _this3.url = url;
     return _this3;
   }
 
+  return BlockedCozyError;
+}( /*#__PURE__*/(0, _wrapNativeSuper2.default)(Error));
+
+exports.BlockedCozyError = BlockedCozyError;
+
+var InvalidCozyUrlError = /*#__PURE__*/function (_Error4) {
+  (0, _inherits2.default)(InvalidCozyUrlError, _Error4);
+
+  var _super4 = _createSuper(InvalidCozyUrlError);
+
+  function InvalidCozyUrlError(url) {
+    var _this4;
+
+    (0, _classCallCheck2.default)(this, InvalidCozyUrlError);
+    _this4 = _super4.call(this, "URL ".concat(url.toString(), " does not seem to be a valid Cozy URL"));
+    _this4.url = url;
+    return _this4;
+  }
+
   return InvalidCozyUrlError;
 }( /*#__PURE__*/(0, _wrapNativeSuper2.default)(Error));
 /* uri - Returns a well formed URL origin from a protocol, a hostname and a port
@@ -270,7 +289,12 @@ var wellKnownUrl = function wellKnownUrl(url) {
  *   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
+ *   origin is probably pointing to a cozy-app. In that case we should consider this
+ *   URL to be invalid
+ * - a 503 response status with a "Blocked" reason means the pointed page is a Cozy
+ *   but it is blocked. In that case we consider that the url is a valid Cozy origin
+ *   but we want the method to throw as we cannot verify if the URL points to the
+ *   Cozy's root or to a specifc slug. The caller is responsible to handle that exception
  * - another status means there aren't any Cozy behind to the given origin
  *
  * @param {object} url          Object of URL elements
@@ -280,13 +304,13 @@ var wellKnownUrl = function wellKnownUrl(url) {
  *
  * @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
+ * @throws {BlockedCozyError} Thrown when we know for sure there is Cozy behind the given origin but it is in a "Blocked" state
  */
 
 
 var isValidOrigin = /*#__PURE__*/function () {
   var _ref3 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee(url) {
-    var _yield$fetch, status;
-
+    var response, status;
     return _regenerator.default.wrap(function _callee$(_context) {
       while (1) {
         switch (_context.prev = _context.next) {
@@ -295,8 +319,8 @@ var isValidOrigin = /*#__PURE__*/function () {
             return fetch(wellKnownUrl(url));
 
           case 2:
-            _yield$fetch = _context.sent;
-            status = _yield$fetch.status;
+            response = _context.sent;
+            status = response.status;
 
             if (!(status === 404)) {
               _context.next = 6;
@@ -306,9 +330,21 @@ var isValidOrigin = /*#__PURE__*/function () {
             throw new InvalidCozyUrlError(url);
 
           case 6:
+            _context.next = 8;
+            return isResponseAboutBlockedCozy(response);
+
+          case 8:
+            if (!_context.sent) {
+              _context.next = 10;
+              break;
+            }
+
+            throw new BlockedCozyError(url);
+
+          case 10:
             return _context.abrupt("return", status === 200);
 
-          case 7:
+          case 11:
           case "end":
             return _context.stop();
         }
@@ -455,5 +491,62 @@ var rootCozyUrl = /*#__PURE__*/function () {
     return _ref4.apply(this, arguments);
   };
 }();
+/**
+ * Check if the given response is about a Cozy being blocked
+ *
+ * @param {Response} response - Fetch API response
+ * @returns {Promise<boolean>} true if the response is about a Cozy being blocked, false otherwize
+ */
+
 
-exports.rootCozyUrl = rootCozyUrl;
+exports.rootCozyUrl = rootCozyUrl;
+
+var isResponseAboutBlockedCozy = /*#__PURE__*/function () {
+  var _ref5 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee3(response) {
+    var _data$some;
+
+    var contentType, isJson, data;
+    return _regenerator.default.wrap(function _callee3$(_context3) {
+      while (1) {
+        switch (_context3.prev = _context3.next) {
+          case 0:
+            if (!(response.status !== 503)) {
+              _context3.next = 2;
+              break;
+            }
+
+            return _context3.abrupt("return", false);
+
+          case 2:
+            contentType = response.headers.get('content-type');
+            isJson = contentType && contentType.indexOf('json') >= 0;
+            _context3.next = 6;
+            return isJson ? response.json() : response.text();
+
+          case 6:
+            data = _context3.sent;
+
+            if (!(data !== null && data !== void 0 && (_data$some = data.some) !== null && _data$some !== void 0 && _data$some.call(data, function (reason) {
+              return reason.title === 'Blocked';
+            }))) {
+              _context3.next = 9;
+              break;
+            }
+
+            return _context3.abrupt("return", true);
+
+          case 9:
+            return _context3.abrupt("return", false);
+
+          case 10:
+          case "end":
+            return _context3.stop();
+        }
+      }
+    }, _callee3);
+  }));
+
+  return function isResponseAboutBlockedCozy(_x3) {
+    return _ref5.apply(this, arguments);
+  };
+}();

package/dist/helpers/urlHelper.spec.js

@@ -7,7 +7,8 @@ import {
   rootCozyUrl,
   InvalidRedirectLinkError,
   InvalidCozyUrlError,
-  InvalidProtocolError
+  InvalidProtocolError,
+  BlockedCozyError
 } from './urlHelper'
 
 describe('generateWebLink', () => {
@@ -420,4 +421,60 @@ describe('rootCozyUrl', () => {
       rootCozyUrl(new URL('https://missing.mycozy.cloud'))
     ).rejects.toBeInstanceOf(InvalidCozyUrlError)
   })
+
+  it('should reject if Blocked cozy', async () => {
+    fetch.mockResponse(() => {
+      return Promise.resolve({
+        headers: {
+          'content-type': 'application/json; charset=UTF-8'
+        },
+        body: JSON.stringify([
+          {
+            status: '503',
+            title: 'Blocked',
+            code: 'UNKNOWN',
+            detail: 'The Cozy is blocked for an unknown reason',
+            source: {}
+          }
+        ]),
+        ok: false,
+        status: 503,
+        statusText: '',
+        type: 'default',
+        url: 'https://camillenimbus.com/.well-known/change-password'
+      })
+    })
+
+    await expect(
+      rootCozyUrl(new URL('https://camillenimbus.com'))
+    ).rejects.toBeInstanceOf(BlockedCozyError)
+  })
+
+  it('should reject on 503 error (if not Blocked)', async () => {
+    fetch.mockResponse(() => {
+      return Promise.resolve({
+        headers: {
+          'content-type': 'application/json; charset=UTF-8'
+        },
+        body: JSON.stringify([
+          {
+            status: '503',
+            title: 'Some error',
+            code: 'UNKNOWN',
+            detail: 'Some error description',
+            source: {}
+          }
+        ]),
+        ok: false,
+        status: 503,
+        statusText: '',
+        type: 'default',
+        url: 'https://camillenimbus.com/.well-known/change-password'
+      })
+    })
+
+    await expect(
+      rootCozyUrl(new URL('https://camillenimbus.com'))
+    ).rejects.toBeInstanceOf(InvalidCozyUrlError)
+  })
 })

package/dist/index.js

@@ -35,6 +35,7 @@ var _exportNames = {
   InvalidRedirectLinkError: true,
   InvalidCozyUrlError: true,
   InvalidProtocolError: true,
+  BlockedCozyError: true,
   cancelable: true,
   isQueryLoading: true,
   hasQueryBeenLoaded: true,
@@ -221,6 +222,12 @@ Object.defineProperty(exports, "InvalidProtocolError", {
     return _helpers2.InvalidProtocolError;
   }
 });
+Object.defineProperty(exports, "BlockedCozyError", {
+  enumerable: true,
+  get: function get() {
+    return _helpers2.BlockedCozyError;
+  }
+});
 Object.defineProperty(exports, "cancelable", {
   enumerable: true,
   get: function get() {

package/dist/index.node.js

@@ -30,6 +30,7 @@ var _exportNames = {
   rootCozyUrl: true,
   InvalidCozyUrlError: true,
   InvalidProtocolError: true,
+  BlockedCozyError: true,
   cancelable: true,
   getQueryFromState: true,
   Registry: true,
@@ -176,6 +177,12 @@ Object.defineProperty(exports, "InvalidProtocolError", {
     return _helpers.InvalidProtocolError;
   }
 });
+Object.defineProperty(exports, "BlockedCozyError", {
+  enumerable: true,
+  get: function get() {
+    return _helpers.BlockedCozyError;
+  }
+});
 Object.defineProperty(exports, "cancelable", {
   enumerable: true,
   get: function get() {

package/package.json

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

package/types/helpers/index.d.ts

@@ -1,2 +1,2 @@
 export { dehydrate } from "./dehydrateHelper";
-export { deconstructCozyWebLinkWithSlug, deconstructRedirectLink, generateWebLink, ensureFirstSlash, rootCozyUrl, InvalidRedirectLinkError, InvalidCozyUrlError, InvalidProtocolError } from "./urlHelper";
+export { deconstructCozyWebLinkWithSlug, deconstructRedirectLink, generateWebLink, ensureFirstSlash, rootCozyUrl, InvalidRedirectLinkError, InvalidCozyUrlError, InvalidProtocolError, BlockedCozyError } from "./urlHelper";

package/types/helpers/urlHelper.d.ts

@@ -17,6 +17,10 @@ export class InvalidProtocolError extends Error {
     constructor(url: any);
     url: any;
 }
+export class BlockedCozyError extends Error {
+    constructor(url: any);
+    url: any;
+}
 export class InvalidCozyUrlError extends Error {
     constructor(url: any);
     url: any;

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 { deconstructCozyWebLinkWithSlug, deconstructRedirectLink, dehydrate, generateWebLink, ensureFirstSlash, rootCozyUrl, InvalidRedirectLinkError, InvalidCozyUrlError, InvalidProtocolError } from "./helpers";
+export { deconstructCozyWebLinkWithSlug, deconstructRedirectLink, dehydrate, generateWebLink, ensureFirstSlash, rootCozyUrl, InvalidRedirectLinkError, InvalidCozyUrlError, InvalidProtocolError, BlockedCozyError } from "./helpers";
 export { cancelable, isQueryLoading, hasQueryBeenLoaded } from "./utils";
 export { queryConnect, queryConnectFlat, withClient } from "./hoc";

package/types/index.node.d.ts

@@ -14,4 +14,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 { deconstructCozyWebLinkWithSlug, deconstructRedirectLink, dehydrate, generateWebLink, ensureFirstSlash, rootCozyUrl, InvalidCozyUrlError, InvalidProtocolError } from "./helpers";
+export { deconstructCozyWebLinkWithSlug, deconstructRedirectLink, dehydrate, generateWebLink, ensureFirstSlash, rootCozyUrl, InvalidCozyUrlError, InvalidProtocolError, BlockedCozyError } from "./helpers";