cozy-client 57.3.0 → 57.4.0

package/dist/CozyClient.js

@@ -85,6 +85,8 @@ var _promiseCache = _interopRequireDefault(require("./promise-cache"));
 
 var _flagshipCertification = require("./flagship-certification/flagship-certification");
 
+var _storage = require("./storage");
+
 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; }
@@ -1618,7 +1620,7 @@ var CozyClient = /*#__PURE__*/function () {
               case 2:
                 mainResponse = _context11.sent;
                 _context11.next = 5;
-                return this.persistVirtualDocuments(definition, mainResponse.data);
+                return (0, _storage.persistVirtualDocuments)(this, definition, mainResponse.data);
 
               case 5:
                 if (definition.includes) {
@@ -1662,7 +1664,7 @@ var CozyClient = /*#__PURE__*/function () {
     key: "persistVirtualDocuments",
     value: function () {
       var _persistVirtualDocuments = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee12(definition, data) {
-        var enforceList, enforce, _iterator5, _step5, _document;
+        var enforceList, enforce, documentsToPersist, _iterator5, _step5, _document;
 
         return _regenerator.default.wrap(function _callee12$(_context12) {
           while (1) {
@@ -1697,52 +1699,65 @@ var CozyClient = /*#__PURE__*/function () {
                 return this.persistVirtualDocument(data, enforce);
 
               case 9:
-                _context12.next = 28;
+                _context12.next = 29;
                 break;
 
               case 11:
-                _iterator5 = _createForOfIteratorHelper(data);
-                _context12.prev = 12;
+                documentsToPersist = data.filter(function (document) {
+                  var _document$meta;
+
+                  if (!document || document.cozyLocalOnly) {
+                    return false;
+                  }
+
+                  if (!((_document$meta = document.meta) !== null && _document$meta !== void 0 && _document$meta.rev) && !document._rev || enforce) {
+                    return true;
+                  }
+
+                  return false;
+                });
+                _iterator5 = _createForOfIteratorHelper(documentsToPersist);
+                _context12.prev = 13;
 
                 _iterator5.s();
 
-              case 14:
+              case 15:
                 if ((_step5 = _iterator5.n()).done) {
-                  _context12.next = 20;
+                  _context12.next = 21;
                   break;
                 }
 
                 _document = _step5.value;
-                _context12.next = 18;
+                _context12.next = 19;
                 return this.persistVirtualDocument(_document, enforce);
 
-              case 18:
-                _context12.next = 14;
+              case 19:
+                _context12.next = 15;
                 break;
 
-              case 20:
-                _context12.next = 25;
+              case 21:
+                _context12.next = 26;
                 break;
 
-              case 22:
-                _context12.prev = 22;
-                _context12.t0 = _context12["catch"](12);
+              case 23:
+                _context12.prev = 23;
+                _context12.t0 = _context12["catch"](13);
 
                 _iterator5.e(_context12.t0);
 
-              case 25:
-                _context12.prev = 25;
+              case 26:
+                _context12.prev = 26;
 
                 _iterator5.f();
 
-                return _context12.finish(25);
+                return _context12.finish(26);
 
-              case 28:
+              case 29:
               case "end":
                 return _context12.stop();
             }
           }
-        }, _callee12, this, [[12, 22, 25, 28]]);
+        }, _callee12, this, [[13, 23, 26, 29]]);
       }));
 
       function persistVirtualDocuments(_x14, _x15) {
@@ -1764,7 +1779,7 @@ var CozyClient = /*#__PURE__*/function () {
     key: "persistVirtualDocument",
     value: function () {
       var _persistVirtualDocument = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee13(document, enforce) {
-        var _document$meta;
+        var _document$meta2;
 
         return _regenerator.default.wrap(function _callee13$(_context13) {
           while (1) {
@@ -1778,7 +1793,7 @@ var CozyClient = /*#__PURE__*/function () {
                 return _context13.abrupt("return");
 
               case 2:
-                if (!(!((_document$meta = document.meta) !== null && _document$meta !== void 0 && _document$meta.rev) && !document._rev || enforce)) {
+                if (!(!((_document$meta2 = document.meta) !== null && _document$meta2 !== void 0 && _document$meta2.rev) && !document._rev || enforce)) {
                   _context13.next = 5;
                   break;
                 }
@@ -3097,7 +3112,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 = "57.3.0";
+CozyClient.version = "57.4.0";
 
 _microee.default.mixin(CozyClient);
 

package/dist/storage.js

@@ -0,0 +1,205 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.persistVirtualDocuments = exports.shouldDocumentBePersisted = exports.shouldEnforcePersist = exports.ENFORCE_LIST = void 0;
+
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+
+var _CozyClient = _interopRequireDefault(require("./CozyClient"));
+
+var _dsl = require("./queries/dsl");
+
+function _createForOfIteratorHelper(o, allowArrayLike) { var it; if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = o[Symbol.iterator](); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+var ENFORCE_LIST = ['io.cozy.files.shortcuts'];
+/**
+ * @typedef {import("./types").CozyClientDocument} CozyClientDocument
+ */
+
+exports.ENFORCE_LIST = ENFORCE_LIST;
+
+var shouldEnforcePersist = function shouldEnforcePersist(definition) {
+  return ENFORCE_LIST.includes(definition.doctype);
+};
+/**
+ * Whether or not a document should be locally persisted
+ *
+ * @param {CozyClientDocument} document - The document to evaluate
+ * @returns {boolean} whether or not the doc should be persisted
+ */
+
+
+exports.shouldEnforcePersist = shouldEnforcePersist;
+
+var shouldDocumentBePersisted = function shouldDocumentBePersisted(document) {
+  var _document$meta;
+
+  var shouldEnforce = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+
+  if (!document || document.cozyLocalOnly) {
+    return false;
+  }
+
+  if (!((_document$meta = document.meta) !== null && _document$meta !== void 0 && _document$meta.rev) && !document._rev || shouldEnforce) {
+    return true;
+  }
+
+  return false;
+};
+/**
+ * Save the document or array of documents into the persisted storage (if any)
+ *
+ * @param {CozyClient} client - Cozy client instance
+ * @param {QueryDefinition} definition - The query definition
+ * @param {CozyClientDocument | Array<CozyClientDocument>} data - Document or array of documents to be saved
+ * @returns {Promise<void>}
+ */
+
+
+exports.shouldDocumentBePersisted = shouldDocumentBePersisted;
+
+var persistVirtualDocuments = /*#__PURE__*/function () {
+  var _ref = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee(client, definition, data) {
+    var enforce, documentsToPersist, _iterator, _step, document;
+
+    return _regenerator.default.wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            enforce = shouldEnforcePersist(definition);
+
+            if (!(definition.doctype === 'io.cozy.apps_registry')) {
+              _context.next = 5;
+              break;
+            }
+
+            _context.next = 4;
+            return persistVirtualDocument(client, {
+              _type: 'io.cozy.apps_registry',
+              _id: definition.id,
+              // @ts-ignore
+              cozyPouchData: data
+            }, enforce);
+
+          case 4:
+            return _context.abrupt("return", _context.sent);
+
+          case 5:
+            if (Array.isArray(data)) {
+              _context.next = 10;
+              break;
+            }
+
+            _context.next = 8;
+            return persistVirtualDocument(client, data, enforce);
+
+          case 8:
+            _context.next = 28;
+            break;
+
+          case 10:
+            documentsToPersist = data.filter(function (document) {
+              return shouldDocumentBePersisted(document, enforce);
+            });
+            _iterator = _createForOfIteratorHelper(documentsToPersist);
+            _context.prev = 12;
+
+            _iterator.s();
+
+          case 14:
+            if ((_step = _iterator.n()).done) {
+              _context.next = 20;
+              break;
+            }
+
+            document = _step.value;
+            _context.next = 18;
+            return persistVirtualDocument(client, document, enforce);
+
+          case 18:
+            _context.next = 14;
+            break;
+
+          case 20:
+            _context.next = 25;
+            break;
+
+          case 22:
+            _context.prev = 22;
+            _context.t0 = _context["catch"](12);
+
+            _iterator.e(_context.t0);
+
+          case 25:
+            _context.prev = 25;
+
+            _iterator.f();
+
+            return _context.finish(25);
+
+          case 28:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee, null, [[12, 22, 25, 28]]);
+  }));
+
+  return function persistVirtualDocuments(_x, _x2, _x3) {
+    return _ref.apply(this, arguments);
+  };
+}();
+/**
+ * Save the document or array of documents into the persisted storage (if any)
+ *
+ * This relies on the fact that there are some "virtual" documents returned
+ * by the stack, in the sense that they are not CouchDB documents, but rather
+ * are computed on the fly by the server.
+ * To ensure we can use those documents locally, i.e. without the stack,
+ * we allow the possibility to persist them.
+ *
+ * @param {CozyClient} client - Cozy client instance
+ * @param {CozyClientDocument} document - Document to be saved
+ * @param {boolean} enforce - When true, save the document no matter its content
+ * @returns {Promise<void>}
+ */
+
+
+exports.persistVirtualDocuments = persistVirtualDocuments;
+
+var persistVirtualDocument = /*#__PURE__*/function () {
+  var _ref2 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee2(client, document, enforce) {
+    return _regenerator.default.wrap(function _callee2$(_context2) {
+      while (1) {
+        switch (_context2.prev = _context2.next) {
+          case 0:
+            if (!shouldDocumentBePersisted(document, enforce)) {
+              _context2.next = 3;
+              break;
+            }
+
+            _context2.next = 3;
+            return client.chain.persistCozyData(document);
+
+          case 3:
+          case "end":
+            return _context2.stop();
+        }
+      }
+    }, _callee2);
+  }));
+
+  return function persistVirtualDocument(_x4, _x5, _x6) {
+    return _ref2.apply(this, arguments);
+  };
+}();

package/dist/storage.spec.js

@@ -0,0 +1,31 @@
+import { shouldDocumentBePersisted } from './storage'
+
+const BASE_DOC = {
+  _id: '123',
+  name: 'saymy'
+}
+
+describe('shouldDocumentBePersisted', () => {
+  it('should not persist a doc with cozyLocalOnly flag', () => {
+    const doc = { ...BASE_DOC, cozyLocalOnly: true }
+    expect(shouldDocumentBePersisted(doc)).toBe(false)
+  })
+
+  it('should not persist a doc with rev', () => {
+    const doc1 = { ...BASE_DOC, _rev: '123' }
+    expect(shouldDocumentBePersisted(doc1)).toBe(false)
+
+    const doc2 = { ...BASE_DOC, meta: { rev: '123' } }
+    expect(shouldDocumentBePersisted(doc2)).toBe(false)
+  })
+
+  it('should persist if we enforce it', () => {
+    const doc = { ...BASE_DOC, _rev: '123' }
+    expect(shouldDocumentBePersisted(doc, true)).toBe(true)
+  })
+
+  it('should persist if there is not revision', () => {
+    const doc = { ...BASE_DOC }
+    expect(shouldDocumentBePersisted(doc)).toBe(true)
+  })
+})

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cozy-client",
-  "version": "57.3.0",
+  "version": "57.4.0",
   "license": "MIT",
   "main": "dist/index.node.js",
   "browser": "dist/index.js",
@@ -74,5 +74,5 @@
     "react-native-ios11-devicecheck": "https://github.com/cozy/react-native-devicecheck#app-attest-v0.1"
   },
   "sideEffects": false,
-  "gitHead": "aa4094d6cb80bbd4173cc82fb1a2a06406718b5e"
+  "gitHead": "97e956957de48f36a29d0d55adf3cb0e248f0141"
 }

package/types/storage.d.ts

@@ -0,0 +1,48 @@
+export const ENFORCE_LIST: string[];
+export function shouldEnforcePersist(definition: any): boolean;
+export function shouldDocumentBePersisted(document: CozyClientDocument, shouldEnforce?: boolean): boolean;
+export function persistVirtualDocuments(client: CozyClient, definition: QueryDefinition, data: CozyClientDocument | Array<CozyClientDocument>): Promise<void>;
+export type CozyClientDocument = {
+    /**
+     * - Id of the document
+     */
+    _id?: string;
+    /**
+     * - Id of the document
+     */
+    id?: string;
+    /**
+     * - Type of the document
+     */
+    _type?: string;
+    /**
+     * - Current revision of the document
+     */
+    _rev?: string;
+    /**
+     * - When the document has been deleted
+     */
+    _deleted?: boolean;
+    /**
+     * - Relationships of the document
+     */
+    relationships?: import("./types").ReferencedByRelationship;
+    /**
+     * - referenced by of another document
+     */
+    referenced_by?: import("./types").Reference[];
+    /**
+     * - Cozy Metadata
+     */
+    cozyMetadata?: import("./types").CozyMetadata;
+    /**
+     * - Pouch Metadata
+     */
+    meta?: import("./types").CozyClientDocumentMeta;
+    /**
+     * - When true the document should NOT be replicated to the remote database
+     */
+    cozyLocalOnly?: boolean;
+};
+import CozyClient from "./CozyClient";
+import { QueryDefinition } from "./queries/dsl";