cozy-client 49.1.1 → 49.3.0

package/dist/CozyClient.js

@@ -2997,7 +2997,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 = "49.1.1";
+CozyClient.version = "49.3.0";
 
 _microee.default.mixin(CozyClient);
 

package/dist/RealTimeQueries.js

@@ -17,12 +17,14 @@ var _useClient = _interopRequireDefault(require("./hooks/useClient"));
 
 var _realtime = require("./store/realtime");
 
+var _realtime2 = require("./helpers/realtime");
+
 /**
  * Component that subscribes to a doctype changes and keep the
  * internal store updated.
  *
- * @param  {object} options - Options
- * @param  {import("./types").Doctype} options.doctype - The doctype to watch
+ * @param {object} options - Options
+ * @param {import("./types").Doctype} options.doctype - The doctype to watch
  * @returns {null} The component does not display anything.
  */
 var RealTimeQueries = function RealTimeQueries(_ref) {
@@ -35,6 +37,24 @@ var RealTimeQueries = function RealTimeQueries(_ref) {
       throw new Error('You must include the realtime plugin to use RealTimeQueries');
     }
 
+    var options = {};
+
+    if (doctype === 'io.cozy.files') {
+      options.enhanceDocFn = _realtime2.ensureFilePath;
+    }
+
+    var handleCreated = function handleCreated(data) {
+      (0, _realtime.dispatchCreate)(client, doctype, data, options);
+    };
+
+    var handleUpdated = function handleUpdated(data) {
+      (0, _realtime.dispatchUpdate)(client, doctype, data, options);
+    };
+
+    var handleDeleted = function handleDeleted(data) {
+      (0, _realtime.dispatchDelete)(client, doctype, data, options);
+    };
+
     var subscribe = /*#__PURE__*/function () {
       var _ref2 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee() {
         return _regenerator.default.wrap(function _callee$(_context) {
@@ -42,21 +62,15 @@ var RealTimeQueries = function RealTimeQueries(_ref) {
             switch (_context.prev = _context.next) {
               case 0:
                 _context.next = 2;
-                return realtime.subscribe('created', doctype, function (data) {
-                  return (0, _realtime.dispatchCreate)(client, doctype, data);
-                });
+                return realtime.subscribe('created', doctype, handleCreated);
 
               case 2:
                 _context.next = 4;
-                return realtime.subscribe('updated', doctype, function (data) {
-                  return (0, _realtime.dispatchUpdate)(client, doctype, data);
-                });
+                return realtime.subscribe('updated', doctype, handleUpdated);
 
               case 4:
                 _context.next = 6;
-                return realtime.subscribe('deleted', doctype, function (data) {
-                  return (0, _realtime.dispatchDelete)(client, doctype, data);
-                });
+                return realtime.subscribe('deleted', doctype, handleDeleted);
 
               case 6:
               case "end":

package/dist/RealTimeQueries.spec.jsx

@@ -6,7 +6,26 @@ import CozyProvider from './Provider'
 
 const setup = async doctype => {
   const realtimeCallbacks = {}
-  const client = new createMockClient({})
+  const client = new createMockClient({
+    queries: {
+      'io.cozy.files/parent': {
+        doctype: 'io.cozy.files',
+        definition: {
+          doctype: 'io.cozy.files',
+          id: 'parent'
+        },
+        data: [
+          {
+            _id: 'parent',
+            _type: 'io.cozy.files',
+            name: 'Parent folder',
+            path: '/Parent'
+          }
+        ]
+      }
+    }
+  })
+
   client.plugins.realtime = {
     subscribe: jest.fn((event, doctype, callback) => {
       realtimeCallbacks[event] = callback
@@ -29,17 +48,26 @@ const setup = async doctype => {
 }
 
 describe('RealTimeQueries', () => {
-  it('notifies the cozy-client store', async () => {
+  it('should dispatch CREATE_DOCUMENT mutation for created io.cozy.files', async () => {
     const { client, realtimeCallbacks, unmount } = await setup('io.cozy.files')
 
-    realtimeCallbacks['created']({ _id: 'mock-created', type: 'file' })
-    expect(client.dispatch).toHaveBeenCalledWith(
-      expect.objectContaining({
+    realtimeCallbacks['created']({
+      _id: 'mock-created',
+      type: 'file',
+      name: 'mock-created',
+      dir_id: 'parent'
+    })
+
+    await waitFor(() => {
+      expect(client.dispatch).toHaveBeenCalledWith({
         definition: {
           document: {
             _id: 'mock-created',
-            id: 'mock-created',
             _type: 'io.cozy.files',
+            dir_id: 'parent',
+            id: 'mock-created',
+            name: 'mock-created',
+            path: '/Parent/mock-created',
             type: 'file'
           },
           mutationType: 'CREATE_DOCUMENT'
@@ -48,103 +76,152 @@ describe('RealTimeQueries', () => {
         response: {
           data: {
             _id: 'mock-created',
-            id: 'mock-created',
             _type: 'io.cozy.files',
+            dir_id: 'parent',
+            id: 'mock-created',
+            name: 'mock-created',
+            path: '/Parent/mock-created',
             type: 'file'
           }
         },
         type: 'RECEIVE_MUTATION_RESULT'
       })
-    )
+    })
 
-    realtimeCallbacks['updated']({ _id: 'mock-updated', type: 'file' })
-    expect(client.dispatch).toHaveBeenCalledWith({
-      definition: {
-        document: {
-          _id: 'mock-updated',
-          id: 'mock-updated',
-          _type: 'io.cozy.files',
-          type: 'file'
-        },
-        mutationType: 'UPDATE_DOCUMENT'
-      },
-      mutationId: '2',
-      response: {
-        data: {
-          _id: 'mock-updated',
-          id: 'mock-updated',
-          _type: 'io.cozy.files',
-          type: 'file'
-        }
-      },
-      type: 'RECEIVE_MUTATION_RESULT'
+    unmount()
+    await waitFor(() => {
+      expect(client.plugins.realtime.unsubscribe).toHaveBeenCalledTimes(3)
+    })
+  })
+
+  it('should dispatch UPDATE_DOCUMENT mutation for updated io.cozy.files', async () => {
+    const { client, realtimeCallbacks, unmount } = await setup('io.cozy.files')
+
+    realtimeCallbacks['updated']({
+      _id: 'mock-updated',
+      type: 'file',
+      name: 'mock-updated',
+      dir_id: 'parent'
     })
 
-    realtimeCallbacks['deleted']({ _id: 'mock-deleted', type: 'file' })
-    expect(client.dispatch).toHaveBeenCalledWith({
-      definition: {
-        document: {
-          _id: 'mock-deleted',
-          id: 'mock-deleted',
-          _type: 'io.cozy.files',
-          type: 'file',
-          _deleted: true
+    await waitFor(() => {
+      expect(client.dispatch).toHaveBeenCalledWith({
+        definition: {
+          document: {
+            _id: 'mock-updated',
+            _type: 'io.cozy.files',
+            dir_id: 'parent',
+            id: 'mock-updated',
+            name: 'mock-updated',
+            path: '/Parent/mock-updated',
+            type: 'file'
+          },
+          mutationType: 'UPDATE_DOCUMENT'
         },
-        mutationType: 'DELETE_DOCUMENT'
-      },
-      mutationId: '3',
-      response: {
-        data: {
-          _id: 'mock-deleted',
-          id: 'mock-deleted',
-          _type: 'io.cozy.files',
-          type: 'file',
-          _deleted: true
-        }
-      },
-      type: 'RECEIVE_MUTATION_RESULT'
+        mutationId: '1',
+        response: {
+          data: {
+            _id: 'mock-updated',
+            _type: 'io.cozy.files',
+            dir_id: 'parent',
+            id: 'mock-updated',
+            name: 'mock-updated',
+            path: '/Parent/mock-updated',
+            type: 'file'
+          }
+        },
+        type: 'RECEIVE_MUTATION_RESULT'
+      })
     })
 
     unmount()
     expect(client.plugins.realtime.unsubscribe).toHaveBeenCalledTimes(3)
   })
 
-  it('deals with other doctypes than io.cozy.files', async () => {
-    const { client, realtimeCallbacks, unmount } = await setup(
-      'io.cozy.oauth.clients'
-    )
+  it('should dispatch DELETE_DOCUMENT mutation for deleted io.cozy.files', async () => {
+    const { client, realtimeCallbacks, unmount } = await setup('io.cozy.files')
 
-    realtimeCallbacks['created']({
-      _id: 'mock-created',
-      client_kind: 'desktop',
-      client_name: 'Cozy Drive (hostname)'
+    realtimeCallbacks['deleted']({
+      _id: 'mock-deleted',
+      type: 'file',
+      name: 'mock-deleted',
+      dir_id: 'parent'
     })
-    expect(client.dispatch).toHaveBeenCalledWith(
-      expect.objectContaining({
+
+    await waitFor(() => {
+      expect(client.dispatch).toHaveBeenCalledWith({
         definition: {
           document: {
-            _id: 'mock-created',
-            id: 'mock-created',
-            _type: 'io.cozy.oauth.clients',
-            client_kind: 'desktop',
-            client_name: 'Cozy Drive (hostname)'
+            _deleted: true,
+            _type: 'io.cozy.files',
+            _id: 'mock-deleted',
+            dir_id: 'parent',
+            id: 'mock-deleted',
+            name: 'mock-deleted',
+            path: '/Parent/mock-deleted',
+            type: 'file'
           },
-          mutationType: 'CREATE_DOCUMENT'
+          mutationType: 'DELETE_DOCUMENT'
         },
         mutationId: '1',
         response: {
           data: {
-            _id: 'mock-created',
-            id: 'mock-created',
-            _type: 'io.cozy.oauth.clients',
-            client_kind: 'desktop',
-            client_name: 'Cozy Drive (hostname)'
+            _deleted: true,
+            _type: 'io.cozy.files',
+            _id: 'mock-deleted',
+            dir_id: 'parent',
+            id: 'mock-deleted',
+            name: 'mock-deleted',
+            path: '/Parent/mock-deleted',
+            type: 'file'
           }
         },
         type: 'RECEIVE_MUTATION_RESULT'
       })
+    })
+
+    unmount()
+    expect(client.plugins.realtime.unsubscribe).toHaveBeenCalledTimes(3)
+  })
+
+  it('should handle realtime events for other doctypes than io.cozy.files', async () => {
+    const { client, realtimeCallbacks, unmount } = await setup(
+      'io.cozy.oauth.clients'
     )
 
+    realtimeCallbacks['created']({
+      _id: 'mock-created',
+      client_kind: 'desktop',
+      client_name: 'Cozy Drive (hostname)'
+    })
+    await waitFor(() => {
+      expect(client.dispatch).toHaveBeenCalledWith(
+        expect.objectContaining({
+          definition: {
+            document: {
+              _id: 'mock-created',
+              id: 'mock-created',
+              _type: 'io.cozy.oauth.clients',
+              client_kind: 'desktop',
+              client_name: 'Cozy Drive (hostname)'
+            },
+            mutationType: 'CREATE_DOCUMENT'
+          },
+          mutationId: '1',
+          response: {
+            data: {
+              _id: 'mock-created',
+              id: 'mock-created',
+              _type: 'io.cozy.oauth.clients',
+              client_kind: 'desktop',
+              client_name: 'Cozy Drive (hostname)'
+            }
+          },
+          type: 'RECEIVE_MUTATION_RESULT'
+        })
+      )
+    })
+
     unmount()
   })
 })

package/dist/helpers/realtime.js

@@ -0,0 +1,106 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ensureFilePath = void 0;
+
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+
+var _dsl = require("../queries/dsl");
+
+var _CozyClient = _interopRequireDefault(require("../CozyClient"));
+
+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; }
+
+var buildFileByIdQuery = function buildFileByIdQuery(id) {
+  return {
+    definition: function definition() {
+      return (0, _dsl.Q)('io.cozy.files').getById(id);
+    },
+    options: {
+      as: "io.cozy.files/".concat(id),
+      singleDocData: true,
+      fetchPolicy: _CozyClient.default.fetchPolicies.olderThan(30 * 1000)
+    }
+  };
+};
+/**
+ * Ensures existence of `path` inside the io.cozy.files document
+ *
+ * @public
+ * @param {import("../types").IOCozyFile} couchDBDoc - object representing the document
+ * @param {object} options Options
+ * @param {string} [options.doctype] - Doctype of the document
+ * @param {CozyClient} [options.client] - CozyClient instance
+ *
+ * @returns {Promise<import("../types").CozyClientDocument>} full normalized document
+ */
+
+
+var ensureFilePath = /*#__PURE__*/function () {
+  var _ref = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee(couchDBDoc) {
+    var options,
+        parentQuery,
+        parentResult,
+        path,
+        _args = arguments;
+    return _regenerator.default.wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            options = _args.length > 1 && _args[1] !== undefined ? _args[1] : {};
+
+            if (!couchDBDoc.path) {
+              _context.next = 3;
+              break;
+            }
+
+            return _context.abrupt("return", couchDBDoc);
+
+          case 3:
+            parentQuery = buildFileByIdQuery(couchDBDoc.dir_id);
+            _context.next = 6;
+            return options.client.fetchQueryAndGetFromState({
+              definition: parentQuery.definition(),
+              options: parentQuery.options
+            });
+
+          case 6:
+            parentResult = _context.sent;
+
+            if (!(!parentResult.data || !parentResult.data.path)) {
+              _context.next = 9;
+              break;
+            }
+
+            throw new Error("Could not define a file path for ".concat(couchDBDoc._id || couchDBDoc.id));
+
+          case 9:
+            path = parentResult.data.path + '/' + couchDBDoc.name;
+            return _context.abrupt("return", _objectSpread({
+              path: path
+            }, couchDBDoc));
+
+          case 11:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee);
+  }));
+
+  return function ensureFilePath(_x) {
+    return _ref.apply(this, arguments);
+  };
+}();
+
+exports.ensureFilePath = ensureFilePath;

package/dist/store/realtime.js

@@ -7,6 +7,10 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.dispatchDelete = exports.dispatchUpdate = exports.dispatchCreate = void 0;
 
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+
 var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
 
 var _dsl = require("../queries/dsl");
@@ -24,6 +28,7 @@ function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { va
  *
  * @public
  * @param {import("../types").CouchDBDocument} couchDBDoc - object representing the document
+ * @param {string} doctype - Doctype of the document
  * @returns {import("../types").CozyClientDocument} full normalized document
  */
 var normalizeDoc = function normalizeDoc(couchDBDoc, doctype) {
@@ -32,65 +37,211 @@ var normalizeDoc = function normalizeDoc(couchDBDoc, doctype) {
     _type: doctype
   }, couchDBDoc);
 };
+/**
+ * Enhances a document with additional attributes
+ *
+ * @async
+ * @param {import("../types").CozyClientDocument} doc - The document to enhance
+ * @param {Object} options - Options for enhancing the document
+ * @param {Function} [options.enhanceDocFn] - Function to enhance document attributes
+ * @param {object} options.client - CozyClient instance
+ * @returns {Promise<import("../types").CozyClientDocument>} Enhanced document
+ */
+
+
+var enhanceDoc = /*#__PURE__*/function () {
+  var _ref = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee(doc, options) {
+    return _regenerator.default.wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            if (!(typeof options.enhanceDocFn === 'function')) {
+              _context.next = 4;
+              break;
+            }
+
+            _context.next = 3;
+            return options.enhanceDocFn(doc, {
+              client: options.client
+            });
+
+          case 3:
+            return _context.abrupt("return", _context.sent);
+
+          case 4:
+            return _context.abrupt("return", doc);
+
+          case 5:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee);
+  }));
+
+  return function enhanceDoc(_x, _x2) {
+    return _ref.apply(this, arguments);
+  };
+}();
 /**
  * DispatchChange
  *
- * @param {object} client CozyClient instane
- * @param {import("../types").Doctype} doctype Doctype of the document to update
- * @param {import("../types").CouchDBDocument} couchDBDoc Document to update
+ * @param {object} client CozyClient instance
+ * @param {import("../types").CozyClientDocument} document Document to update
  * @param {import("../types").Mutation} mutationDefinitionCreator Mutation to apply
+ *
  */
 
 
-var dispatchChange = function dispatchChange(client, doctype, couchDBDoc, mutationDefinitionCreator) {
-  var data = normalizeDoc(couchDBDoc, doctype);
+var dispatchChange = function dispatchChange(client, document, mutationDefinitionCreator) {
   var response = {
-    data: data
+    data: document
   };
   var options = {};
-  client.dispatch((0, _mutations.receiveMutationResult)(client.generateRandomId(), response, options, mutationDefinitionCreator(data)));
+  client.dispatch((0, _mutations.receiveMutationResult)(client.generateRandomId(), response, options, mutationDefinitionCreator(document)));
 };
+/**
+ * @typedef {Object} DispatchOptions
+ * @property {function} [enhanceDocFn] Optional function to enhance the document attributes before dispatch
+ */
+
 /**
  * Dispatches a create action for a document to update CozyClient store from realtime callbacks.
  *
  * @param {object} client - CozyClient instance
  * @param {import("../types").Doctype} doctype - Doctype of the document to create
  * @param {import("../types").CouchDBDocument} couchDBDoc - Document to create
+ * @param {DispatchOptions} [options] Options
  */
 
 
-var dispatchCreate = function dispatchCreate(client, doctype, couchDBDoc) {
-  dispatchChange(client, doctype, couchDBDoc, _dsl.Mutations.createDocument);
-};
+var dispatchCreate = /*#__PURE__*/function () {
+  var _ref2 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee2(client, doctype, couchDBDoc) {
+    var options,
+        normalizedDoc,
+        enhancedDoc,
+        _args2 = arguments;
+    return _regenerator.default.wrap(function _callee2$(_context2) {
+      while (1) {
+        switch (_context2.prev = _context2.next) {
+          case 0:
+            options = _args2.length > 3 && _args2[3] !== undefined ? _args2[3] : {};
+            normalizedDoc = normalizeDoc(couchDBDoc, doctype);
+            _context2.next = 4;
+            return enhanceDoc(normalizedDoc, {
+              client: client,
+              enhanceDocFn: options === null || options === void 0 ? void 0 : options.enhanceDocFn
+            });
+
+          case 4:
+            enhancedDoc = _context2.sent;
+            dispatchChange(client, enhancedDoc, _dsl.Mutations.createDocument);
+
+          case 6:
+          case "end":
+            return _context2.stop();
+        }
+      }
+    }, _callee2);
+  }));
+
+  return function dispatchCreate(_x3, _x4, _x5) {
+    return _ref2.apply(this, arguments);
+  };
+}();
 /**
  * Dispatches a update action for a document to update CozyClient store from realtime callbacks.
  *
  * @param {object} client - CozyClient instance
  * @param {import("../types").Doctype} doctype - Doctype of the document to create
  * @param {import("../types").CouchDBDocument} couchDBDoc - Document to create
+ * @param {DispatchOptions} [options] Options
  */
 
 
 exports.dispatchCreate = dispatchCreate;
 
-var dispatchUpdate = function dispatchUpdate(client, doctype, couchDBDoc) {
-  dispatchChange(client, doctype, couchDBDoc, _dsl.Mutations.updateDocument);
-};
+var dispatchUpdate = /*#__PURE__*/function () {
+  var _ref3 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee3(client, doctype, couchDBDoc) {
+    var options,
+        normalizedDoc,
+        enhancedDoc,
+        _args3 = arguments;
+    return _regenerator.default.wrap(function _callee3$(_context3) {
+      while (1) {
+        switch (_context3.prev = _context3.next) {
+          case 0:
+            options = _args3.length > 3 && _args3[3] !== undefined ? _args3[3] : {};
+            normalizedDoc = normalizeDoc(couchDBDoc, doctype);
+            _context3.next = 4;
+            return enhanceDoc(normalizedDoc, {
+              client: client,
+              enhanceDocFn: options === null || options === void 0 ? void 0 : options.enhanceDocFn
+            });
+
+          case 4:
+            enhancedDoc = _context3.sent;
+            dispatchChange(client, enhancedDoc, _dsl.Mutations.updateDocument);
+
+          case 6:
+          case "end":
+            return _context3.stop();
+        }
+      }
+    }, _callee3);
+  }));
+
+  return function dispatchUpdate(_x6, _x7, _x8) {
+    return _ref3.apply(this, arguments);
+  };
+}();
 /**
  * Dispatches a delete action for a document to update CozyClient store from realtime callbacks.
  *
  * @param {object} client - CozyClient instance
  * @param {import("../types").Doctype} doctype - Doctype of the document to create
  * @param {import("../types").CouchDBDocument} couchDBDoc - Document to create
+ * @param {DispatchOptions} [options] Options
  */
 
 
 exports.dispatchUpdate = dispatchUpdate;
 
-var dispatchDelete = function dispatchDelete(client, doctype, couchDBDoc) {
-  dispatchChange(client, doctype, _objectSpread(_objectSpread({}, couchDBDoc), {}, {
-    _deleted: true
-  }), _dsl.Mutations.deleteDocument);
-};
+var dispatchDelete = /*#__PURE__*/function () {
+  var _ref4 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee4(client, doctype, couchDBDoc) {
+    var options,
+        normalizedDoc,
+        enhancedDoc,
+        _args4 = arguments;
+    return _regenerator.default.wrap(function _callee4$(_context4) {
+      while (1) {
+        switch (_context4.prev = _context4.next) {
+          case 0:
+            options = _args4.length > 3 && _args4[3] !== undefined ? _args4[3] : {};
+            normalizedDoc = normalizeDoc(_objectSpread(_objectSpread({}, couchDBDoc), {}, {
+              _deleted: true
+            }), doctype);
+            _context4.next = 4;
+            return enhanceDoc(normalizedDoc, {
+              client: client,
+              enhanceDocFn: options === null || options === void 0 ? void 0 : options.enhanceDocFn
+            });
+
+          case 4:
+            enhancedDoc = _context4.sent;
+            dispatchChange(client, enhancedDoc, _dsl.Mutations.deleteDocument);
+
+          case 6:
+          case "end":
+            return _context4.stop();
+        }
+      }
+    }, _callee4);
+  }));
+
+  return function dispatchDelete(_x9, _x10, _x11) {
+    return _ref4.apply(this, arguments);
+  };
+}();
 
 exports.dispatchDelete = dispatchDelete;

package/dist/types.js

@@ -472,6 +472,7 @@ var _dsl = require("./queries/dsl");
  * @property {string} [target.category] - The category of the application
  * @property {object} [externalDataSource] - Additional information to maintain link with external data source
  * @property {string} [externalDataSource.source] - The space to which the application belongs
+ * @property {string} [externalDataSource.creator] - The creator of the data source
  */
 
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cozy-client",
-  "version": "49.1.1",
+  "version": "49.3.0",
   "license": "MIT",
   "main": "dist/index.node.js",
   "browser": "dist/index.js",
@@ -75,5 +75,5 @@
     "react-native-ios11-devicecheck": "https://github.com/cozy/react-native-devicecheck#app-attest-v0.1"
   },
   "sideEffects": false,
-  "gitHead": "1743f0008b06d89bacda019231dd2292748c68d5"
+  "gitHead": "d4e710d23db0b18a50f17bd1b2e22e5f082a7635"
 }

package/types/helpers/realtime.d.ts

@@ -0,0 +1,5 @@
+export function ensureFilePath(couchDBDoc: import("../types").IOCozyFile, options?: {
+    doctype: string;
+    client: CozyClient;
+}): Promise<import("../types").CozyClientDocument>;
+import CozyClient from "../CozyClient";

package/types/store/realtime.d.ts

@@ -1,3 +1,9 @@
-export function dispatchCreate(client: object, doctype: import("../types").Doctype, couchDBDoc: import("../types").CouchDBDocument): void;
-export function dispatchUpdate(client: object, doctype: import("../types").Doctype, couchDBDoc: import("../types").CouchDBDocument): void;
-export function dispatchDelete(client: object, doctype: import("../types").Doctype, couchDBDoc: import("../types").CouchDBDocument): void;
+export function dispatchCreate(client: object, doctype: import("../types").Doctype, couchDBDoc: import("../types").CouchDBDocument, options?: DispatchOptions): Promise<void>;
+export function dispatchUpdate(client: object, doctype: import("../types").Doctype, couchDBDoc: import("../types").CouchDBDocument, options?: DispatchOptions): Promise<void>;
+export function dispatchDelete(client: object, doctype: import("../types").Doctype, couchDBDoc: import("../types").CouchDBDocument, options?: DispatchOptions): Promise<void>;
+export type DispatchOptions = {
+    /**
+     * Optional function to enhance the document attributes before dispatch
+     */
+    enhanceDocFn?: Function;
+};

package/types/types.d.ts

@@ -823,6 +823,7 @@ export type FileMetadata = {
      */
     externalDataSource?: {
         source: string;
+        creator: string;
     };
 };
 /**