cozy-pouch-link 54.0.1 → 55.1.0

package/dist/CozyPouchLink.js

@@ -551,12 +551,20 @@ var PouchLink = /*#__PURE__*/function (_CozyLink) {
   }, {
     key: "_startReplication",
     value: function _startReplication() {
+      var _ref2 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
+          _ref2$waitForReplicat = _ref2.waitForReplications,
+          waitForReplications = _ref2$waitForReplicat === void 0 ? true : _ref2$waitForReplicat;
+
       this.client.emit('pouchlink:sync:start');
 
       if (this.periodicSync) {
+        // FIXME: this API is kind of weird, one should be able to manually replicate
+        // even if a periodicSync is enabled
         this.pouches.startReplicationLoop();
       } else {
-        this.pouches.replicateOnce();
+        this.pouches.replicateOnce({
+          waitForReplications: waitForReplications
+        });
       }
 
       if (this.options.onStartReplication) {
@@ -570,14 +578,26 @@ var PouchLink = /*#__PURE__*/function (_CozyLink) {
      * Emits pouchlink:sync:start event when the replication begins
      *
      * @public
+     *
+     * @param {object} options - The options
+     * @param {boolean|null} [options.waitForReplications=true] - Whether the others replication process should be waited
      * @returns {void}
      */
 
   }, {
     key: "startReplication",
     value: function startReplication() {
-      this.startReplicationDebounced.cancel();
-      return this._startReplication();
+      var _ref3 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
+          _ref3$waitForReplicat = _ref3.waitForReplications,
+          waitForReplications = _ref3$waitForReplicat === void 0 ? true : _ref3$waitForReplicat;
+
+      if (!waitForReplications) {
+        this.startReplicationDebounced.cancel();
+      }
+
+      return this._startReplication({
+        waitForReplications: waitForReplications
+      });
     }
     /**
      * Debounced version of startReplication() method
@@ -585,17 +605,25 @@ var PouchLink = /*#__PURE__*/function (_CozyLink) {
      * Debounce delay can be configured through constructor's `syncDebounceDelayInMs` option
      *
      * @public
+     * @param {object} options - The options
+     * @param {boolean|null} [options.waitForReplications=true] - Whether the others replication process should be waited
      * @returns {void}
      */
 
   }, {
     key: "startReplicationWithDebounce",
     value: function startReplicationWithDebounce() {
+      var _ref4 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
+          _ref4$waitForReplicat = _ref4.waitForReplications,
+          waitForReplications = _ref4$waitForReplicat === void 0 ? true : _ref4$waitForReplicat;
+
       if (this.periodicSync) {
         throw new Error('createDebounceableReplication cannot be called when periodic sync is configured');
       }
 
-      return this.startReplicationDebounced();
+      return this.startReplicationDebounced({
+        waitForReplications: waitForReplications
+      });
     }
     /**
      * User of the link can call this to stop ongoing replications.
@@ -1086,7 +1114,7 @@ var PouchLink = /*#__PURE__*/function (_CozyLink) {
     key: "createIndex",
     value: function () {
       var _createIndex = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee12(fields) {
-        var _ref2,
+        var _ref5,
             partialFilter,
             indexName,
             doctype,
@@ -1099,7 +1127,7 @@ var PouchLink = /*#__PURE__*/function (_CozyLink) {
           while (1) {
             switch (_context12.prev = _context12.next) {
               case 0:
-                _ref2 = _args12.length > 1 && _args12[1] !== undefined ? _args12[1] : {}, partialFilter = _ref2.partialFilter, indexName = _ref2.indexName, doctype = _ref2.doctype;
+                _ref5 = _args12.length > 1 && _args12[1] !== undefined ? _args12[1] : {}, partialFilter = _ref5.partialFilter, indexName = _ref5.indexName, doctype = _ref5.doctype;
                 absName = "".concat(doctype, "/").concat(indexName);
                 db = this.pouches.getPouch(doctype);
                 _context12.next = 5;
@@ -1225,14 +1253,14 @@ var PouchLink = /*#__PURE__*/function (_CozyLink) {
   }, {
     key: "executeQuery",
     value: function () {
-      var _executeQuery = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee14(_ref3) {
+      var _executeQuery = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee14(_ref6) {
         var doctype, selector, sort, fields, limit, id, ids, skip, indexedFields, partialFilter, markName, db, res, withRows, _markName, _markName2, _markName3, findSelector, findOpts, index, _markName4, jsonResult;
 
         return _regenerator.default.wrap(function _callee14$(_context14) {
           while (1) {
             switch (_context14.prev = _context14.next) {
               case 0:
-                doctype = _ref3.doctype, selector = _ref3.selector, sort = _ref3.sort, fields = _ref3.fields, limit = _ref3.limit, id = _ref3.id, ids = _ref3.ids, skip = _ref3.skip, indexedFields = _ref3.indexedFields, partialFilter = _ref3.partialFilter;
+                doctype = _ref6.doctype, selector = _ref6.selector, sort = _ref6.sort, fields = _ref6.fields, limit = _ref6.limit, id = _ref6.id, ids = _ref6.ids, skip = _ref6.skip, indexedFields = _ref6.indexedFields, partialFilter = _ref6.partialFilter;
                 markName = this.performanceApi.mark('executeQuery');
                 db = this.getPouch(doctype);
 

package/dist/PouchManager.js

@@ -329,19 +329,41 @@ var PouchManager = /*#__PURE__*/function () {
 
       this.replicationLoop.scheduleImmediateTask();
     }
-    /** Starts replication */
+    /**
+     * Starts replication
+     *
+     * @param {object} options - The options
+     * @param {boolean|null} [options.waitForReplications=true] - Whether the others replication process should be waited
+     * @returns {Promise<any>} the replication result
+     */
 
   }, {
     key: "replicateOnce",
     value: function () {
       var _replicateOnce2 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee5() {
+        var _ref,
+            _ref$waitForReplicati,
+            waitForReplications,
+            _args5 = arguments;
+
         return _regenerator.default.wrap(function _callee5$(_context5) {
           while (1) {
             switch (_context5.prev = _context5.next) {
               case 0:
+                _ref = _args5.length > 0 && _args5[0] !== undefined ? _args5[0] : {}, _ref$waitForReplicati = _ref.waitForReplications, waitForReplications = _ref$waitForReplicati === void 0 ? true : _ref$waitForReplicati;
+
+                if (!waitForReplications) {
+                  _context5.next = 4;
+                  break;
+                }
+
+                _context5.next = 4;
+                return this.waitForCurrentReplications();
+
+              case 4:
                 return _context5.abrupt("return", (0, _replicateOnce3.replicateOnce)(this));
 
-              case 1:
+              case 5:
               case "end":
                 return _context5.stop();
             }
@@ -395,7 +417,7 @@ var PouchManager = /*#__PURE__*/function () {
         return Promise.resolve();
       }
 
-      return Promise.all(Object.values(this.replications));
+      return (0, _utils.allSettled)(Object.values(this.replications));
     }
   }, {
     key: "getPouch",
@@ -506,7 +528,7 @@ var PouchManager = /*#__PURE__*/function () {
                 _context9.prev = 1;
                 _context9.next = 4;
                 return Promise.all(queries.map( /*#__PURE__*/function () {
-                  var _ref = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee8(query) {
+                  var _ref2 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee8(query) {
                     var def;
                     return _regenerator.default.wrap(function _callee8$(_context8) {
                       while (1) {
@@ -534,7 +556,7 @@ var PouchManager = /*#__PURE__*/function () {
                   }));
 
                   return function (_x4) {
-                    return _ref.apply(this, arguments);
+                    return _ref2.apply(this, arguments);
                   };
                 }()));
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cozy-pouch-link",
-  "version": "54.0.1",
+  "version": "55.1.0",
   "license": "MIT",
   "main": "dist/index.js",
   "types": "types/index.d.ts",
@@ -13,7 +13,7 @@
     "url": "git+https://github.com/cozy/cozy-client.git"
   },
   "dependencies": {
-    "cozy-client": "^54.0.1",
+    "cozy-client": "^55.0.0",
     "pouchdb-browser": "^7.2.2",
     "pouchdb-find": "^7.2.2"
   },
@@ -39,5 +39,5 @@
     "typecheck": "tsc -p tsconfig.json"
   },
   "sideEffects": false,
-  "gitHead": "e13858880dcf65ac3f7cc33e2f5ed4311fd1ac00"
+  "gitHead": "dd645b50178ce079af9f5304e9373c387c1fe8d3"
 }

package/types/CozyPouchLink.d.ts

@@ -147,18 +147,27 @@ declare class PouchLink extends CozyLink {
      * Emits pouchlink:sync:start event when the replication begins
      *
      * @public
+     *
+     * @param {object} options - The options
+     * @param {boolean|null} [options.waitForReplications=true] - Whether the others replication process should be waited
      * @returns {void}
      */
-    public startReplication(): void;
+    public startReplication({ waitForReplications }?: {
+        waitForReplications: boolean | null;
+    }): void;
     /**
      * Debounced version of startReplication() method
      *
      * Debounce delay can be configured through constructor's `syncDebounceDelayInMs` option
      *
      * @public
+     * @param {object} options - The options
+     * @param {boolean|null} [options.waitForReplications=true] - Whether the others replication process should be waited
      * @returns {void}
      */
-    public startReplicationWithDebounce(): void;
+    public startReplicationWithDebounce({ waitForReplications }?: {
+        waitForReplications: boolean | null;
+    }): void;
     /**
      * User of the link can call this to stop ongoing replications.
      * Typically, it can be used when the applications loses focus.

package/types/PouchManager.d.ts

@@ -30,8 +30,16 @@ declare class PouchManager {
     startReplicationLoop(): Promise<Loop | void>;
     /** Stop periodic syncing of the pouches */
     stopReplicationLoop(): void;
-    /** Starts replication */
-    replicateOnce(): Promise<any>;
+    /**
+     * Starts replication
+     *
+     * @param {object} options - The options
+     * @param {boolean|null} [options.waitForReplications=true] - Whether the others replication process should be waited
+     * @returns {Promise<any>} the replication result
+     */
+    replicateOnce({ waitForReplications }?: {
+        waitForReplications: boolean | null;
+    }): Promise<any>;
     executeQuery: any;
     /** @type {import('./types').CancelablePromise[]} - Stores replication promises */
     replications: import('./types').CancelablePromise[];
@@ -53,7 +61,7 @@ declare class PouchManager {
     syncImmediately(): void;
     handleReplicationError(err: any): void;
     cancelCurrentReplications(): void;
-    waitForCurrentReplications(): Promise<void> | Promise<any[]>;
+    waitForCurrentReplications(): Promise<void> | Promise<(import("./utils").FulfilledPromise | import("./utils").RejectedPromise)[]>;
     getPouch(doctype: any): any;
     /**
      * Update the Sync info for the specifed doctype