cozy-client 45.10.0 → 45.11.0

package/dist/CozyClient.js

@@ -2703,7 +2703,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 = "45.10.0";
+CozyClient.version = "45.11.0";
 
 _microee.default.mixin(CozyClient);
 

package/dist/models/folder.js

@@ -17,6 +17,8 @@ var _CozyClient = _interopRequireDefault(require("../CozyClient"));
 
 var _const = require("../const");
 
+var _dsl = require("../queries/dsl");
+
 var APP_DOCTYPE = 'io.cozy.apps';
 var administrative = 'administrative';
 var photos = 'photos';
@@ -168,26 +170,24 @@ exports.createFolderWithReference = createFolderWithReference;
 
 var getReferencedFolder = /*#__PURE__*/function () {
   var _ref3 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee3(client, document) {
-    var _yield$client$collect, included, foldersOutsideTrash;
+    var _yield$client$query, folders;
 
     return _regenerator.default.wrap(function _callee3$(_context3) {
       while (1) {
         switch (_context3.prev = _context3.next) {
           case 0:
             _context3.next = 2;
-            return client.collection(_const.DOCTYPE_FILES).findReferencedBy(document);
+            return client.query((0, _dsl.Q)(_const.DOCTYPE_FILES).partialIndex({
+              type: 'directory',
+              trashed: false
+            }).referencedBy(document));
 
           case 2:
-            _yield$client$collect = _context3.sent;
-            included = _yield$client$collect.included;
-            foldersOutsideTrash = included.filter(function (folder) {
-              return !/^\/\.cozy_trash/.test(folder.path);
-            }); // there can be multiple folders with the same reference in some edge cases
-            // when this happens we return the most recent one
-
-            return _context3.abrupt("return", foldersOutsideTrash.length > 0 ? (0, _sortBy.default)(foldersOutsideTrash, 'created_at').pop() : null);
+            _yield$client$query = _context3.sent;
+            folders = _yield$client$query.included;
+            return _context3.abrupt("return", folders.length > 0 ? (0, _sortBy.default)(folders, 'created_at').pop() : null);
 
-          case 6:
+          case 5:
           case "end":
             return _context3.stop();
         }

package/dist/models/folder.spec.js

@@ -3,6 +3,7 @@ import { MAGIC_FOLDERS, ensureMagicFolder, getReferencedFolder } from './folder'
 describe('Folder model', () => {
   const mockClient = {
     collection: () => mockClient,
+    query: jest.fn(),
     findReferencedBy: jest.fn(),
     ensureDirectoryExists: jest.fn(),
     addReferencesTo: jest.fn(),
@@ -38,7 +39,7 @@ describe('Folder model', () => {
         }
       ]
 
-      mockClient.findReferencedBy.mockResolvedValue({
+      mockClient.query.mockResolvedValueOnce({
         included: existingMagicFolders
       })
 
@@ -66,10 +67,9 @@ describe('Folder model', () => {
     })
 
     it('should create magic folder', async () => {
-      mockClient.findReferencedBy.mockResolvedValue({
+      mockClient.query.mockResolvedValueOnce({
         included: []
       })
-
       mockClient.ensureDirectoryExists.mockResolvedValue('dir-id')
       mockClient.get.mockResolvedValue({ data: {} })
 
@@ -90,24 +90,6 @@ describe('Folder model', () => {
   })
 
   describe('getReferencedFolder', () => {
-    it('should filter trashed folders', async () => {
-      const referencedFolder = {
-        path: '/Reference/Folder'
-      }
-
-      const trashFolder = {
-        path: '/.cozy_trash/Old/Reference/Folder'
-      }
-
-      mockClient.findReferencedBy.mockResolvedValue({
-        included: [referencedFolder, trashFolder]
-      })
-
-      const result = await getReferencedFolder(mockClient, 'ref')
-
-      expect(result).toBe(referencedFolder)
-    })
-
     it('should return the most recently created folder', async () => {
       const oldFolder = {
         path: '/Old/folder',
@@ -118,7 +100,7 @@ describe('Folder model', () => {
         created_at: '2020-03-02T14:57:07.661588+01:00'
       }
 
-      mockClient.findReferencedBy.mockResolvedValue({
+      mockClient.query.mockResolvedValueOnce({
         included: [oldFolder, recentFolder]
       })
 

package/dist/models/konnectorFolder.js

@@ -5,7 +5,7 @@ var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefau
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.buildFolderPermission = exports.buildFolderPath = exports.statDirectoryByPath = exports.createDirectoryByPath = exports.ensureKonnectorFolder = void 0;
+exports.findKonnectorAccountFolderByReference = exports.buildFolderPermission = exports.buildFolderPath = exports.statDirectoryByPath = exports.createDirectoryByPath = exports.ensureKonnectorFolder = void 0;
 
 var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
 
@@ -21,6 +21,8 @@ var _account = require("./account");
 
 var _locales = require("./document/locales");
 
+var _dsl = require("../queries/dsl");
+
 //@ts-check
 var FILES_DOCTYPE = 'io.cozy.files';
 var PERMISSIONS_DOCTYPE = 'io.cozy.permissions'; // Default name for base directory
@@ -39,7 +41,7 @@ var DEFAULT_LOCALIZED_BASE_DIR = 'Administrative';
 
 var ensureKonnectorFolder = /*#__PURE__*/function () {
   var _ref2 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee(client, _ref) {
-    var konnector, account, lang, permissions, files, t, _yield$Promise$all, _yield$Promise$all2, adminFolder, photosFolder, path, folder;
+    var konnector, account, lang, permissions, fileCollection, t, _yield$Promise$all, _yield$Promise$all2, adminFolder, photosFolder, sourceAccountIdentifier, alreadyExistingAccountFolder, alreadyExistingKonnectorMainFolder, path, folder, _yield$fileCollection, konnectorFolder;
 
     return _regenerator.default.wrap(function _callee$(_context) {
       while (1) {
@@ -47,7 +49,7 @@ var ensureKonnectorFolder = /*#__PURE__*/function () {
           case 0:
             konnector = _ref.konnector, account = _ref.account, lang = _ref.lang;
             permissions = client.collection(PERMISSIONS_DOCTYPE);
-            files = client.collection(FILES_DOCTYPE);
+            fileCollection = client.collection(FILES_DOCTYPE);
             t = (0, _locales.getLocalizer)(lang);
             _context.next = 6;
             return Promise.all([(0, _folder.ensureMagicFolder)(client, _folder.MAGIC_FOLDERS.ADMINISTRATIVE, t('MagicFolders.administrative')), (0, _folder.ensureMagicFolder)(client, _folder.MAGIC_FOLDERS.PHOTOS, t('MagicFolders.photos'))]);
@@ -57,40 +59,100 @@ var ensureKonnectorFolder = /*#__PURE__*/function () {
             _yield$Promise$all2 = (0, _slicedToArray2.default)(_yield$Promise$all, 2);
             adminFolder = _yield$Promise$all2[0];
             photosFolder = _yield$Promise$all2[1];
+            sourceAccountIdentifier = (0, _account.getAccountName)(account);
+            _context.next = 13;
+            return findKonnectorAccountFolderByReference({
+              client: client,
+              slug: konnector.slug,
+              sourceAccountIdentifier: sourceAccountIdentifier
+            });
+
+          case 13:
+            alreadyExistingAccountFolder = _context.sent;
+
+            if (!alreadyExistingAccountFolder) {
+              _context.next = 16;
+              break;
+            }
+
+            return _context.abrupt("return", alreadyExistingAccountFolder);
+
+          case 16:
+            _context.next = 18;
+            return findKonnectorMainFolderByReference({
+              client: client,
+              slug: konnector.slug
+            });
+
+          case 18:
+            alreadyExistingKonnectorMainFolder = _context.sent;
+
+            if (!alreadyExistingKonnectorMainFolder) {
+              _context.next = 23;
+              break;
+            }
+
+            _context.next = 22;
+            return saveKonnectorAccountFolder({
+              client: client,
+              mainFolder: alreadyExistingKonnectorMainFolder,
+              konnector: konnector,
+              sourceAccountIdentifier: sourceAccountIdentifier
+            });
+
+          case 22:
+            return _context.abrupt("return", _context.sent);
+
+          case 23:
+            // if the previous shortcuts did not work, create the folders like we did before but with proper references
             path = buildFolderPath(konnector, account, {
               administrative: adminFolder.path,
               photos: photosFolder.path
             });
-            _context.next = 13;
+            _context.next = 26;
             return statDirectoryByPath(client, path);
 
-          case 13:
+          case 26:
             _context.t0 = _context.sent;
 
             if (_context.t0) {
-              _context.next = 18;
+              _context.next = 31;
               break;
             }
 
-            _context.next = 17;
+            _context.next = 30;
             return createDirectoryByPath(client, path);
 
-          case 17:
+          case 30:
             _context.t0 = _context.sent;
 
-          case 18:
+          case 31:
             folder = _context.t0;
-            _context.next = 21;
-            return permissions.add(konnector, buildFolderPermission(folder));
-
-          case 21:
-            _context.next = 23;
-            return files.addReferencesTo(konnector, [folder]);
-
-          case 23:
+            _context.next = 34;
+            return fileCollection.statById(folder.dir_id);
+
+          case 34:
+            _yield$fileCollection = _context.sent;
+            konnectorFolder = _yield$fileCollection.data;
+            _context.next = 38;
+            return Promise.all([permissions.add(konnector, buildFolderPermission(folder)), ensureKonnectorReference({
+              client: client,
+              folder: folder,
+              konnector: konnector
+            }), ensureSourceAccountIdentifierReference({
+              client: client,
+              folder: folder,
+              sourceAccountIdentifier: sourceAccountIdentifier
+            }), ensureKonnectorReference({
+              client: client,
+              folder: konnectorFolder,
+              konnector: konnector
+            })]);
+
+          case 38:
             return _context.abrupt("return", folder);
 
-          case 24:
+          case 39:
           case "end":
             return _context.stop();
         }
@@ -357,7 +419,7 @@ var buildFolderPermission = function buildFolderPermission(folder) {
   return {
     // Legacy name
     saveFolder: {
-      type: 'io.cozy.files',
+      type: FILES_DOCTYPE,
       values: [folder._id],
       verbs: ['GET', 'PATCH', 'POST']
     }
@@ -377,4 +439,289 @@ exports.buildFolderPermission = buildFolderPermission;
 var trim = function trim(str) {
   var c = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '\\s';
   return str.replace(new RegExp("^([".concat(c, "]*)(.*?)([").concat(c, "]*)$")), '$2');
-};
+};
+/**
+ * Test if a given folder has a given konnector reference
+ *
+ * @param {import('../types').IOCozyFolder} folder - folder to test
+ * @param {string} slug -  konnector slug
+ * @returns {boolean}
+ */
+
+
+var hasKonnectorReference = function hasKonnectorReference(folder, slug) {
+  var _folder$referenced_by;
+
+  return Boolean((_folder$referenced_by = folder.referenced_by) === null || _folder$referenced_by === void 0 ? void 0 : _folder$referenced_by.find(function (ref) {
+    return ref.type === 'io.cozy.konnectors' && ref.id === 'io.cozy.konnectors/' + slug;
+  }));
+};
+/**
+ * Test if a given folder has a given source account identifier reference
+ *
+ * @param {import('../types').IOCozyFolder} folder - folder to test
+ * @param {string} [sourceAccountIdentifier] - source account identifier
+ * @returns {boolean}
+ */
+
+
+var hasSourceAccountIdentifierReference = function hasSourceAccountIdentifierReference(folder, sourceAccountIdentifier) {
+  var _folder$referenced_by2;
+
+  return Boolean((_folder$referenced_by2 = folder.referenced_by) === null || _folder$referenced_by2 === void 0 ? void 0 : _folder$referenced_by2.find(function (ref) {
+    return ref.type === 'io.cozy.accounts.sourceAccountIdentifier' && (sourceAccountIdentifier ? ref.id === sourceAccountIdentifier : true);
+  }));
+};
+/**
+ * Ensure that a given folder has the given konnector reference
+ *
+ * @param {object} options - options object
+ * @param {CozyClient} options.client - CozyClient instance
+ * @param {import('../types').IOCozyFolder} options.folder - folder to test
+ * @param {import('../types').IOCozyKonnector} options.konnector - konnector to which we want the reference
+ * @returns {Promise<void>}
+ */
+
+
+var ensureKonnectorReference = /*#__PURE__*/function () {
+  var _ref6 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee4(_ref5) {
+    var client, folder, konnector, fileCollection;
+    return _regenerator.default.wrap(function _callee4$(_context4) {
+      while (1) {
+        switch (_context4.prev = _context4.next) {
+          case 0:
+            client = _ref5.client, folder = _ref5.folder, konnector = _ref5.konnector;
+            fileCollection = client.collection(FILES_DOCTYPE);
+
+            if (hasKonnectorReference(folder, konnector.slug)) {
+              _context4.next = 5;
+              break;
+            }
+
+            _context4.next = 5;
+            return fileCollection.addReferencesTo(konnector, [folder]);
+
+          case 5:
+          case "end":
+            return _context4.stop();
+        }
+      }
+    }, _callee4);
+  }));
+
+  return function ensureKonnectorReference(_x7) {
+    return _ref6.apply(this, arguments);
+  };
+}();
+/**
+ * Ensure that a given folder has the given source account identifier reference
+ *
+ * @param {object} options - options object
+ * @param {CozyClient} options.client - CozyClient instance
+ * @param {import('../types').IOCozyFolder} options.folder - folder to test
+ * @param {string} options.sourceAccountIdentifier - source account identifier to which we want the reference
+ * @returns {Promise<void>}
+ */
+
+
+var ensureSourceAccountIdentifierReference = /*#__PURE__*/function () {
+  var _ref8 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee5(_ref7) {
+    var client, folder, sourceAccountIdentifier, fileCollection;
+    return _regenerator.default.wrap(function _callee5$(_context5) {
+      while (1) {
+        switch (_context5.prev = _context5.next) {
+          case 0:
+            client = _ref7.client, folder = _ref7.folder, sourceAccountIdentifier = _ref7.sourceAccountIdentifier;
+            fileCollection = client.collection(FILES_DOCTYPE);
+
+            if (hasSourceAccountIdentifierReference(folder, sourceAccountIdentifier)) {
+              _context5.next = 5;
+              break;
+            }
+
+            _context5.next = 5;
+            return fileCollection.addReferencesTo({
+              _id: sourceAccountIdentifier,
+              _type: 'io.cozy.accounts.sourceAccountIdentifier'
+            }, [folder]);
+
+          case 5:
+          case "end":
+            return _context5.stop();
+        }
+      }
+    }, _callee5);
+  }));
+
+  return function ensureSourceAccountIdentifierReference(_x8) {
+    return _ref8.apply(this, arguments);
+  };
+}();
+/**
+ * try to find a konnector account folder using file references
+ *
+ * @param {object} options - options object
+ * @param {CozyClient} options.client - CozyClient instance
+ * @param {string} options.slug - konnector slug
+ * @param {string} options.sourceAccountIdentifier - source account identifier
+ * @returns {Promise<import('../types').IOCozyFolder>}
+ */
+
+
+var findKonnectorAccountFolderByReference = /*#__PURE__*/function () {
+  var _ref10 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee6(_ref9) {
+    var client, slug, sourceAccountIdentifier, _yield$client$query, folders;
+
+    return _regenerator.default.wrap(function _callee6$(_context6) {
+      while (1) {
+        switch (_context6.prev = _context6.next) {
+          case 0:
+            client = _ref9.client, slug = _ref9.slug, sourceAccountIdentifier = _ref9.sourceAccountIdentifier;
+            _context6.next = 3;
+            return client.query((0, _dsl.Q)(FILES_DOCTYPE).partialIndex({
+              type: 'directory',
+              trashed: false
+            }).referencedBy({
+              _type: 'io.cozy.konnectors',
+              _id: "io.cozy.konnectors/".concat(slug)
+            }));
+
+          case 3:
+            _yield$client$query = _context6.sent;
+            folders = _yield$client$query.included;
+            return _context6.abrupt("return", folders.find(function (folder) {
+              return hasSourceAccountIdentifierReference(folder, sourceAccountIdentifier);
+            }));
+
+          case 6:
+          case "end":
+            return _context6.stop();
+        }
+      }
+    }, _callee6);
+  }));
+
+  return function findKonnectorAccountFolderByReference(_x9) {
+    return _ref10.apply(this, arguments);
+  };
+}();
+/**
+ * try to find a konnector main folder using file references
+ *
+ * @param {object} options - options object
+ * @param {CozyClient} options.client - CozyClient instance
+ * @param {string} options.slug - konnector slug
+ * @returns {Promise<import('../types').IOCozyFolder>}
+ */
+
+
+exports.findKonnectorAccountFolderByReference = findKonnectorAccountFolderByReference;
+
+var findKonnectorMainFolderByReference = /*#__PURE__*/function () {
+  var _ref12 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee7(_ref11) {
+    var client, slug, _yield$client$query2, files;
+
+    return _regenerator.default.wrap(function _callee7$(_context7) {
+      while (1) {
+        switch (_context7.prev = _context7.next) {
+          case 0:
+            client = _ref11.client, slug = _ref11.slug;
+            _context7.next = 3;
+            return client.query((0, _dsl.Q)(FILES_DOCTYPE).partialIndex({
+              type: 'directory',
+              trashed: false
+            }).referencedBy({
+              _type: 'io.cozy.konnectors',
+              _id: "io.cozy.konnectors/".concat(slug)
+            }));
+
+          case 3:
+            _yield$client$query2 = _context7.sent;
+            files = _yield$client$query2.included;
+            return _context7.abrupt("return", files.find(function (file) {
+              return !hasSourceAccountIdentifierReference(file);
+            }));
+
+          case 6:
+          case "end":
+            return _context7.stop();
+        }
+      }
+    }, _callee7);
+  }));
+
+  return function findKonnectorMainFolderByReference(_x10) {
+    return _ref12.apply(this, arguments);
+  };
+}();
+/**
+ * Will create or update an account folder with proper references
+ *
+ * @param {object} options - options object
+ * @param {CozyClient} options.client - CozyClient instance
+ * @param {import('../types').IOCozyFolder} options.mainFolder - Main konnector folder where the account folder may be created
+ * @param {import('../types').IOCozyKonnector} options.konnector - Konnector associated to the main folder
+ * @param {string} options.sourceAccountIdentifier - source account identifier
+ * @returns {Promise<import('../types').IOCozyFolder>}
+ */
+
+
+function saveKonnectorAccountFolder(_x11) {
+  return _saveKonnectorAccountFolder.apply(this, arguments);
+}
+
+function _saveKonnectorAccountFolder() {
+  _saveKonnectorAccountFolder = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee8(_ref13) {
+    var client, mainFolder, konnector, sourceAccountIdentifier, path, folder;
+    return _regenerator.default.wrap(function _callee8$(_context8) {
+      while (1) {
+        switch (_context8.prev = _context8.next) {
+          case 0:
+            client = _ref13.client, mainFolder = _ref13.mainFolder, konnector = _ref13.konnector, sourceAccountIdentifier = _ref13.sourceAccountIdentifier;
+            path = mainFolder.path + '/' + sourceAccountIdentifier;
+            _context8.next = 4;
+            return statDirectoryByPath(client, path);
+
+          case 4:
+            _context8.t0 = _context8.sent;
+
+            if (_context8.t0) {
+              _context8.next = 9;
+              break;
+            }
+
+            _context8.next = 8;
+            return createDirectoryByPath(client, path);
+
+          case 8:
+            _context8.t0 = _context8.sent;
+
+          case 9:
+            folder = _context8.t0;
+            _context8.next = 12;
+            return ensureKonnectorReference({
+              client: client,
+              folder: folder,
+              konnector: konnector
+            });
+
+          case 12:
+            _context8.next = 14;
+            return ensureSourceAccountIdentifierReference({
+              client: client,
+              folder: folder,
+              sourceAccountIdentifier: sourceAccountIdentifier
+            });
+
+          case 14:
+            return _context8.abrupt("return", folder);
+
+          case 15:
+          case "end":
+            return _context8.stop();
+        }
+      }
+    }, _callee8);
+  }));
+  return _saveKonnectorAccountFolder.apply(this, arguments);
+}

package/dist/models/konnectorFolder.spec.js

@@ -3,8 +3,9 @@ import { ensureKonnectorFolder } from './konnectorFolder'
 describe('ensureKonnectorFolder', () => {
   const mockClient = {
     collection: () => mockClient,
-    findReferencedBy: jest.fn(),
+    query: jest.fn(),
     statByPath: jest.fn(),
+    statById: jest.fn(),
     add: jest.fn(),
     addReferencesTo: jest.fn(),
     createDirectoryByPath: jest.fn()
@@ -17,6 +18,7 @@ describe('ensureKonnectorFolder', () => {
   ]
   const konnector = {
     name: 'konnectorName',
+    slug: 'konnectorSlug',
     folders: [
       {
         defaultDir: '$administrative/$konnector/$account'
@@ -26,7 +28,10 @@ describe('ensureKonnectorFolder', () => {
 
   const account = { auth: { accountName: 'testAccountName' } }
   beforeEach(() => {
-    mockClient.findReferencedBy.mockResolvedValue({
+    mockClient.query.mockResolvedValueOnce({
+      included: existingMagicFolder
+    })
+    mockClient.query.mockResolvedValueOnce({
       included: existingMagicFolder
     })
   })
@@ -36,10 +41,17 @@ describe('ensureKonnectorFolder', () => {
   })
 
   it('should create a folder when it does not exist and return it', async () => {
+    mockClient.query.mockResolvedValue({
+      included: []
+    })
     mockClient.statByPath.mockRejectedValueOnce({ status: 404 })
+    mockClient.statById.mockResolvedValueOnce({
+      data: { _id: 'parentfolderid' }
+    })
     mockClient.createDirectoryByPath.mockResolvedValueOnce({
       data: {
-        _id: 'createdfolderid'
+        _id: 'createdfolderid',
+        dir_id: 'parentfolderid'
       }
     })
     const result = await ensureKonnectorFolder(mockClient, {
@@ -47,7 +59,10 @@ describe('ensureKonnectorFolder', () => {
       account,
       lang: 'fr'
     })
-    expect(result).toStrictEqual({ _id: 'createdfolderid' })
+    expect(result).toStrictEqual({
+      _id: 'createdfolderid',
+      dir_id: 'parentfolderid'
+    })
     expect(mockClient.statByPath).toHaveBeenCalledWith(
       '/Administratif/konnectorName/testAccountName'
     )
@@ -62,9 +77,122 @@ describe('ensureKonnectorFolder', () => {
       }
     })
     expect(mockClient.addReferencesTo).toHaveBeenCalledWith(konnector, [
-      { _id: 'createdfolderid' }
+      { _id: 'createdfolderid', dir_id: 'parentfolderid' }
     ])
   })
+  it('should not create any folder if account folder with proper references exists', async () => {
+    const existingAccountFolder = {
+      _id: 'acountFolderId',
+      type: 'directory',
+      referenced_by: [
+        {
+          type: 'io.cozy.konnectors',
+          id: 'io.cozy.konnectors/konnectorSlug'
+        },
+        {
+          type: 'io.cozy.accounts.sourceAccountIdentifier',
+          id: 'testAccountName'
+        }
+      ]
+    }
+    mockClient.query.mockResolvedValueOnce({
+      included: [existingAccountFolder]
+    })
+    const result = await ensureKonnectorFolder(mockClient, {
+      konnector,
+      account,
+      lang: 'fr'
+    })
+    expect(result).toStrictEqual(existingAccountFolder)
+    expect(mockClient.createDirectoryByPath).not.toHaveBeenCalled()
+  })
+  it('should create account folder as a child of folder with konnector reference if any', async () => {
+    const existingKonnectorFolder = {
+      _id: 'konnectorFolderId',
+      type: 'directory',
+      referenced_by: [
+        {
+          type: 'io.cozy.konnectors',
+          id: 'io.cozy.konnectors/konnectorSlug'
+        }
+      ]
+    }
+    mockClient.query.mockResolvedValue({
+      included: [existingKonnectorFolder]
+    })
+    mockClient.statByPath.mockRejectedValueOnce({
+      status: 404
+    })
+    const accountFolder = {
+      _id: 'accountFolderId',
+      dir_id: 'konnectorFolderId'
+    }
+    mockClient.createDirectoryByPath.mockResolvedValueOnce({
+      data: accountFolder
+    })
+
+    const result = await ensureKonnectorFolder(mockClient, {
+      konnector,
+      account,
+      lang: 'fr'
+    })
+    expect(result).toStrictEqual(accountFolder)
+    expect(mockClient.createDirectoryByPath).toHaveBeenCalledTimes(1)
+    expect(mockClient.addReferencesTo).toHaveBeenCalledTimes(2)
+    expect(mockClient.addReferencesTo).toHaveBeenNthCalledWith(1, konnector, [
+      accountFolder
+    ])
+    expect(mockClient.addReferencesTo).toHaveBeenNthCalledWith(
+      2,
+      {
+        _id: 'testAccountName',
+        _type: 'io.cozy.accounts.sourceAccountIdentifier'
+      },
+      [accountFolder]
+    )
+  })
+  it('should add proper references to konnector folder child with proper name if any', async () => {
+    const existingKonnectorFolder = {
+      _id: 'konnectorFolderId',
+      type: 'directory',
+      referenced_by: [
+        {
+          type: 'io.cozy.konnectors',
+          id: 'io.cozy.konnectors/konnectorSlug'
+        }
+      ]
+    }
+    mockClient.query.mockResolvedValue({
+      included: [existingKonnectorFolder]
+    })
+    const accountFolder = {
+      _id: 'accountFolderId',
+      dir_id: 'konnectorFolderId'
+    }
+    mockClient.statByPath.mockResolvedValueOnce({
+      data: accountFolder
+    })
+
+    const result = await ensureKonnectorFolder(mockClient, {
+      konnector,
+      account,
+      lang: 'fr'
+    })
+    expect(result).toStrictEqual(accountFolder)
+    expect(mockClient.createDirectoryByPath).not.toHaveBeenCalled()
+    expect(mockClient.addReferencesTo).toHaveBeenCalledTimes(2)
+    expect(mockClient.addReferencesTo).toHaveBeenNthCalledWith(1, konnector, [
+      accountFolder
+    ])
+    expect(mockClient.addReferencesTo).toHaveBeenNthCalledWith(
+      2,
+      {
+        _id: 'testAccountName',
+        _type: 'io.cozy.accounts.sourceAccountIdentifier'
+      },
+      [accountFolder]
+    )
+  })
   it('should not create a folder if it already exist', async () => {
     const existingMagicFolder = [
       {
@@ -72,12 +200,24 @@ describe('ensureKonnectorFolder', () => {
         created_at: '2023-03-02T14:57:07.661588+01:00'
       }
     ]
-    mockClient.findReferencedBy.mockResolvedValue({
+    mockClient.query.mockResolvedValueOnce({
       included: existingMagicFolder
     })
+    mockClient.query.mockResolvedValueOnce({
+      included: []
+    })
+    mockClient.query.mockResolvedValueOnce({
+      included: []
+    })
+    mockClient.statById.mockResolvedValueOnce({
+      data: {
+        _id: 'parentfolderid'
+      }
+    })
     mockClient.statByPath.mockResolvedValueOnce({
       data: {
-        _id: 'alreadyexistingfolderid'
+        _id: 'alreadyexistingfolderid',
+        dir_id: 'parentfolderid'
       }
     })
     const result = await ensureKonnectorFolder(mockClient, {
@@ -92,22 +232,34 @@ describe('ensureKonnectorFolder', () => {
       account: { auth: { accountName: 'testAccountName' } },
       lang: 'fr'
     })
-    expect(result).toStrictEqual({ _id: 'alreadyexistingfolderid' })
+    expect(result).toStrictEqual({
+      _id: 'alreadyexistingfolderid',
+      dir_id: 'parentfolderid'
+    })
     expect(mockClient.statByPath).toHaveBeenCalledWith(
       '/Administratif/konnectorName/testAccountName'
     )
     expect(mockClient.createDirectoryByPath).not.toHaveBeenCalled()
   })
   it('should recreate a folder when the destination folder is in the trash', async () => {
+    mockClient.query.mockResolvedValue({
+      included: []
+    })
     mockClient.statByPath.mockResolvedValueOnce({
       data: {
         _id: 'folderintrash',
         trashed: true
       }
     })
+    mockClient.statById.mockResolvedValueOnce({
+      data: {
+        _id: 'parentfolderid'
+      }
+    })
     mockClient.createDirectoryByPath.mockResolvedValueOnce({
       data: {
-        _id: 'createdfolderid'
+        _id: 'createdfolderid',
+        dir_id: 'parentfolderid'
       }
     })
     const result = await ensureKonnectorFolder(mockClient, {
@@ -115,7 +267,10 @@ describe('ensureKonnectorFolder', () => {
       account,
       lang: 'fr'
     })
-    expect(result).toStrictEqual({ _id: 'createdfolderid' })
+    expect(result).toStrictEqual({
+      _id: 'createdfolderid',
+      dir_id: 'parentfolderid'
+    })
     expect(mockClient.statByPath).toHaveBeenCalledWith(
       '/Administratif/konnectorName/testAccountName'
     )
@@ -130,7 +285,7 @@ describe('ensureKonnectorFolder', () => {
       }
     })
     expect(mockClient.addReferencesTo).toHaveBeenCalledWith(konnector, [
-      { _id: 'createdfolderid' }
+      { _id: 'createdfolderid', dir_id: 'parentfolderid' }
     ])
   })
 })

package/dist/types.js

@@ -404,6 +404,7 @@ var _dsl = require("./queries/dsl");
 /**
  * @typedef {object} FolderDocument - An io.cozy.files document
  * @property {string} _id - Id of the folder
+ * @property {string} dir_id - Parent folder
  * @property {FilesDoctype} _type - Doctype of the folder
  * @property {string} name - Name of the folder
  * @property {object} metadata - Metadata of the folder

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cozy-client",
-  "version": "45.10.0",
+  "version": "45.11.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": "d981b243e5ea7d4b0e24cb5c6e28245e97f65983"
+  "gitHead": "79b5ecaf281762089293158d3a700ee5ef1bcf0f"
 }

package/types/models/konnectorFolder.d.ts

@@ -9,4 +9,9 @@ export function buildFolderPath(konnector: import('../types').IOCozyKonnector, a
     [x: string]: string;
 }): string;
 export function buildFolderPermission(folder: import('../types').IOCozyFolder): any;
+export function findKonnectorAccountFolderByReference({ client, slug, sourceAccountIdentifier }: {
+    client: CozyClient;
+    slug: string;
+    sourceAccountIdentifier: string;
+}): Promise<import('../types').IOCozyFolder>;
 import CozyClient from "../CozyClient";

package/types/types.d.ts

@@ -744,6 +744,10 @@ export type FolderDocument = {
      * - Id of the folder
      */
     _id: string;
+    /**
+     * - Parent folder
+     */
+    dir_id: string;
     /**
      * - Doctype of the folder
      */