cozy-client 41.2.1 → 41.3.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 = "41.2.1";
+CozyClient.version = "41.3.0";
 
 _microee.default.mixin(CozyClient);
 

package/dist/models/document/locales/en.json

@@ -144,5 +144,9 @@
       "undefined": "Undefined",
       "work_study": "Work & Study"
     }
+  },
+  "MagicFolders": {
+    "administrative": "Administrative",
+    "photos": "Photos"
   }
 }

package/dist/models/document/locales/fr.json

@@ -144,5 +144,9 @@
       "undefined": "Indéfini",
       "work_study": "Travail & Études"
     }
+  },
+  "MagicFolders": {
+    "administrative": "Administratif",
+    "photos": "Photos"
   }
 }

package/dist/models/document/locales/index.js

@@ -5,7 +5,7 @@ var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefau
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.getBoundT = void 0;
+exports.getLocalizer = exports.getBoundT = void 0;
 
 var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
 
@@ -40,8 +40,7 @@ for (var _i = 0, _langs = langs; _i < _langs.length; _i++) {
 
 
 var getBoundT = function getBoundT(lang) {
-  var polyglot = polyglots[lang] || polyglots['en'];
-  var t = polyglot.t.bind(polyglot);
+  var t = getLocalizer(lang);
   return function (label) {
     var opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
 
@@ -53,5 +52,18 @@ var getBoundT = function getBoundT(lang) {
     return emojiCountry ? "".concat(t(label, newOpts), " ").concat(emojiCountry) : t(label, newOpts);
   };
 };
+/**
+ * @param {string} lang - fr, en, etc
+ * @returns {Function} - localization function
+ */
+
+
+exports.getBoundT = getBoundT;
+
+var getLocalizer = function getLocalizer(lang) {
+  var polyglot = polyglots[lang] || polyglots['en'];
+  var t = polyglot.t.bind(polyglot);
+  return t;
+};
 
-exports.getBoundT = getBoundT;
+exports.getLocalizer = getLocalizer;

package/dist/models/folder.js

@@ -181,7 +181,7 @@ var getReferencedFolder = /*#__PURE__*/function () {
             _yield$client$collect = _context3.sent;
             included = _yield$client$collect.included;
             foldersOutsideTrash = included.filter(function (folder) {
-              return !/^\/\.cozy_trash/.test(folder.attributes.path);
+              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
 

package/dist/models/folder.spec.js

@@ -29,15 +29,11 @@ describe('Folder model', () => {
     it('should return first existing magic folder', async () => {
       const existingMagicFolders = [
         {
-          attributes: {
-            path: '/Administrative'
-          },
+          path: '/Administrative',
           created_at: '2020-03-02T14:57:07.661588+01:00'
         },
         {
-          attributes: {
-            path: '/Administrative2'
-          },
+          path: '/Administrative2',
           created_at: '2019-03-02T14:57:07.661588+01:00'
         }
       ]
@@ -96,15 +92,11 @@ describe('Folder model', () => {
   describe('getReferencedFolder', () => {
     it('should filter trashed folders', async () => {
       const referencedFolder = {
-        attributes: {
-          path: '/Reference/Folder'
-        }
+        path: '/Reference/Folder'
       }
 
       const trashFolder = {
-        attributes: {
-          path: '/.cozy_trash/Old/Reference/Folder'
-        }
+        path: '/.cozy_trash/Old/Reference/Folder'
       }
 
       mockClient.findReferencedBy.mockResolvedValue({
@@ -118,15 +110,11 @@ describe('Folder model', () => {
 
     it('should return the most recently created folder', async () => {
       const oldFolder = {
-        attributes: {
-          path: '/Old/folder'
-        },
+        path: '/Old/folder',
         created_at: '2019-03-02T14:57:07.661588+01:00'
       }
       const recentFolder = {
-        attributes: {
-          path: '/Recent/folder'
-        },
+        path: '/Recent/folder',
         created_at: '2020-03-02T14:57:07.661588+01:00'
       }
 

package/dist/models/index.js

@@ -5,7 +5,7 @@ var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWild
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.user = exports.paper = exports.dacc = exports.sharing = exports.timeseries = exports.document = exports.contact = exports.utils = exports.permission = exports.note = exports.account = exports.folder = exports.file = exports.applications = exports.instance = exports.trigger = exports.accounts = exports.triggers = void 0;
+exports.user = exports.paper = exports.dacc = exports.sharing = exports.timeseries = exports.document = exports.contact = exports.utils = exports.permission = exports.note = exports.account = exports.konnectorFolder = exports.folder = exports.file = exports.applications = exports.instance = exports.trigger = exports.accounts = exports.triggers = void 0;
 
 var trigger = _interopRequireWildcard(require("./trigger"));
 
@@ -27,6 +27,10 @@ var folder = _interopRequireWildcard(require("./folder"));
 
 exports.folder = folder;
 
+var konnectorFolder = _interopRequireWildcard(require("./konnectorFolder"));
+
+exports.konnectorFolder = konnectorFolder;
+
 var account = _interopRequireWildcard(require("./account"));
 
 exports.account = account;

package/dist/models/konnectorFolder.js

@@ -0,0 +1,380 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.buildFolderPermission = exports.buildFolderPath = exports.statDirectoryByPath = exports.createDirectoryByPath = exports.ensureKonnectorFolder = void 0;
+
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+
+var _folder = require("./folder");
+
+var _CozyClient = _interopRequireDefault(require("../CozyClient"));
+
+var _account = require("./account");
+
+var _locales = require("./document/locales");
+
+//@ts-check
+var FILES_DOCTYPE = 'io.cozy.files';
+var PERMISSIONS_DOCTYPE = 'io.cozy.permissions'; // Default name for base directory
+
+var DEFAULT_LOCALIZED_BASE_DIR = 'Administrative';
+/**
+ * Ensures the destination folder of a konnector exists and is initiated with proper permissions and references
+ *
+ * @param {CozyClient} client - CozyClient instance
+ * @param {Object} options - options object
+ * @param {import('../types').IOCozyKonnector} options.konnector - io.cozy.konnectors document
+ * @param {import('../types').IOCozyAccount} options.account - io.cozy.accounts document
+ * @param {String} options.lang - instance current language. ex: 'fr'
+ * @returns {Promise<import('../types').IOCozyFolder>}
+ */
+
+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;
+
+    return _regenerator.default.wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            konnector = _ref.konnector, account = _ref.account, lang = _ref.lang;
+            permissions = client.collection(PERMISSIONS_DOCTYPE);
+            files = 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'))]);
+
+          case 6:
+            _yield$Promise$all = _context.sent;
+            _yield$Promise$all2 = (0, _slicedToArray2.default)(_yield$Promise$all, 2);
+            adminFolder = _yield$Promise$all2[0];
+            photosFolder = _yield$Promise$all2[1];
+            path = buildFolderPath(konnector, account, {
+              administrative: adminFolder.path,
+              photos: photosFolder.path
+            });
+            _context.next = 13;
+            return statDirectoryByPath(client, path);
+
+          case 13:
+            _context.t0 = _context.sent;
+
+            if (_context.t0) {
+              _context.next = 18;
+              break;
+            }
+
+            _context.next = 17;
+            return createDirectoryByPath(client, path);
+
+          case 17:
+            _context.t0 = _context.sent;
+
+          case 18:
+            folder = _context.t0;
+            _context.next = 21;
+            return permissions.add(konnector, buildFolderPermission(folder));
+
+          case 21:
+            _context.next = 23;
+            return files.addReferencesTo(konnector, [folder]);
+
+          case 23:
+            return _context.abrupt("return", folder);
+
+          case 24:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee);
+  }));
+
+  return function ensureKonnectorFolder(_x, _x2) {
+    return _ref2.apply(this, arguments);
+  };
+}();
+/**
+ * Creates a directory from a given path
+ *
+ * @param  {CozyClient}  client CozyClient
+ * @param  {string}  path   Directory path
+ * @returns {Promise<import('../types').IOCozyFolder>}         Directory attributes
+ */
+
+
+exports.ensureKonnectorFolder = ensureKonnectorFolder;
+
+var createDirectoryByPath = /*#__PURE__*/function () {
+  var _ref3 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee2(client, path) {
+    var _yield$client$collect, data;
+
+    return _regenerator.default.wrap(function _callee2$(_context2) {
+      while (1) {
+        switch (_context2.prev = _context2.next) {
+          case 0:
+            _context2.next = 2;
+            return client.collection(FILES_DOCTYPE).createDirectoryByPath(path);
+
+          case 2:
+            _yield$client$collect = _context2.sent;
+            data = _yield$client$collect.data;
+            return _context2.abrupt("return", data);
+
+          case 5:
+          case "end":
+            return _context2.stop();
+        }
+      }
+    }, _callee2);
+  }));
+
+  return function createDirectoryByPath(_x3, _x4) {
+    return _ref3.apply(this, arguments);
+  };
+}();
+/**
+ * Retrieves a directory from its path
+ *
+ * @param  {CozyClient}  client CozyClient
+ * @param  {string}  path   Directory path
+ * @returns {Promise<import('../types').IOCozyFolder|null>}        Created io.cozy.files document
+ * @throws will throw an error on any error without status === 404
+ */
+
+
+exports.createDirectoryByPath = createDirectoryByPath;
+
+var statDirectoryByPath = /*#__PURE__*/function () {
+  var _ref4 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee3(client, path) {
+    var response;
+    return _regenerator.default.wrap(function _callee3$(_context3) {
+      while (1) {
+        switch (_context3.prev = _context3.next) {
+          case 0:
+            _context3.prev = 0;
+            _context3.next = 3;
+            return client.collection(FILES_DOCTYPE).statByPath(path);
+
+          case 3:
+            response = _context3.sent;
+
+            if (!response.data.trashed) {
+              _context3.next = 6;
+              break;
+            }
+
+            return _context3.abrupt("return", null);
+
+          case 6:
+            return _context3.abrupt("return", response.data);
+
+          case 9:
+            _context3.prev = 9;
+            _context3.t0 = _context3["catch"](0);
+
+            if (!(_context3.t0 && _context3.t0.status === 404)) {
+              _context3.next = 13;
+              break;
+            }
+
+            return _context3.abrupt("return", null);
+
+          case 13:
+            throw new Error(_context3.t0.message);
+
+          case 14:
+          case "end":
+            return _context3.stop();
+        }
+      }
+    }, _callee3, null, [[0, 9]]);
+  }));
+
+  return function statDirectoryByPath(_x5, _x6) {
+    return _ref4.apply(this, arguments);
+  };
+}();
+/**
+ * Build folder path for a given konnector and a given account.
+ *
+ * If konnector.folders[0].defaultDir exists, it is used as default directory.
+ *
+ * Occurrences of following strings in base directory are replaced by:
+ * * `$administrative`: Administrative folder
+ * * `$photos`: Photos folder
+ *
+ * Occurrences of following strings in path are replaced by:
+ * * `$account: Account label (id or name)`
+ * * `$konnector`: Konnector name
+ *
+ * If no konnectors.folders[0].defaultDir is set, the default dir used is
+ * *  `$administrative/$konnector/$account`
+ *
+ * @param  {import('../types').IOCozyKonnector} konnector Konnector document
+ * @param  {import('../types').IOCozyAccount} account   Account document
+ * @param  {Object<string, string>} magicFolders   Object containing a mapping from folder
+ * identifiers (ex: $administrative) to their localized values (ex:
+ * Administratif).
+ * @returns {String}           The result path
+ */
+
+
+exports.statDirectoryByPath = statDirectoryByPath;
+
+var buildFolderPath = function buildFolderPath(konnector, account) {
+  var _konnector$folders, _konnector$folders$;
+
+  var magicFolders = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  var fullPath = (konnector === null || konnector === void 0 ? void 0 : (_konnector$folders = konnector.folders) === null || _konnector$folders === void 0 ? void 0 : (_konnector$folders$ = _konnector$folders[0]) === null || _konnector$folders$ === void 0 ? void 0 : _konnector$folders$.defaultDir) || '$administrative/$konnector/$account'; // Trim `/` and avoid multiple `/` characters with regexp
+
+  var sanitizedPath = trim(fullPath.replace(/(\/+)/g, '/'), '/'); // If the konnector doesn't have any of our base dir, we set it to $administrative
+
+  if (!hasBaseDir(sanitizedPath)) {
+    sanitizedPath = '$administrative/' + sanitizedPath;
+  }
+  /**
+   * Now that we have our sanitizedPath, we can split it in two strings
+   * * `baseDir` containing the baseDir path
+   * * `buildedSubDir` containing the rest of the path (ie the path without baseDir)
+   */
+
+
+  var baseDir = sanitizedPath.split('/', 1);
+  var buildedSubDir = buildSubDir(sanitizedPath, baseDir[0]);
+  var renderedBaseDir = renderBaseDir(baseDir[0], magicFolders);
+  var renderedPath = renderSubDir(buildedSubDir, {
+    // When adding a new allowed variable here, please keep documentation
+    // of `renderSubDir` function up to date.
+    konnector: konnector.name,
+    account: (0, _account.getAccountName)(account).replace(sanitizeAccountIdentifierRx, '-')
+  });
+  return "/".concat(renderedBaseDir, "/").concat(renderedPath);
+};
+/**
+ * Check if the provided Path start withs our allowedBaseDirPath to see
+ *
+ * @param {String} path - path to test
+ * @returns {Boolean}
+ */
+
+
+exports.buildFolderPath = buildFolderPath;
+
+var hasBaseDir = function hasBaseDir(path) {
+  return allowedBaseDirVariables.some(function (baseDirVar) {
+    return path.startsWith(baseDirVar);
+  });
+};
+/**
+ * Base directories are directory where konnector may copy their data.
+ * They are expressed as variables which then need to be localized.
+ * Default is `$administrative`.
+ */
+
+
+var allowedBaseDirVariables = ['$administrative', '$photos'];
+/**
+ * This method creates the subDir. We can't have an empty subDir, so we set
+ * it to our default '$konnector/$account'
+ *
+ * @param {String} fullPath String containing potentially the defaultDir
+ * @param {String} defaultDir String to remove from the fullPath
+ * @returns {String}
+ */
+
+var buildSubDir = function buildSubDir(fullPath, defaultDir) {
+  var buildedSubDir = fullPath.substring(defaultDir.length);
+
+  if (buildedSubDir === '') {
+    buildedSubDir = '$konnector/$account';
+  }
+
+  return buildedSubDir;
+};
+/**
+ * Render base directory, based on given magicFolders object.
+ * For example, it will render `$administrative` with the given value passed in
+ * folders object. We expect to find in folders a localized value.
+ *
+ * @param  {String} baseDir base directory variable, expects `$administrative`
+ * or `$photos`
+ * @param  {Object<string, string>} magicFolders Object indexing base directory variable with
+ * corresponding localized name.
+ * @returns {String}         Localized directory
+ */
+
+
+var renderBaseDir = function renderBaseDir(baseDir) {
+  var magicFolders = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  // Look for variable name into folders but without $ prefix
+  var renderedBaseDir = magicFolders[baseDir.slice(1)] || DEFAULT_LOCALIZED_BASE_DIR; // Trim `/` and avoid multiple `/` characters with regexp
+
+  return trim(renderedBaseDir.replace(/(\/+)/g, '/'), '/');
+};
+/**
+ * Render the given folder path using the given `variables` object.
+ * Available variable are `$konnector` (konnector name) and `$account`
+ * (account label, i.e. id or name)
+ *
+ * @param  {String} path      Path to render : ex '/Administratif/$konnector/$account'
+ * @param  {Object} variables Object mapping variable to actual values
+ * @param  {import('../types').IOCozyKonnector['name']} variables.konnector - konnector name
+ * @param  {String} variables.account - account name
+ * @returns {String}           Rendered path
+ */
+
+
+var renderSubDir = function renderSubDir(path, variables) {
+  // Trim `/` and avoid multiple `/` characters with regexp
+  var sanitizedPath = trim(path.replace(/(\/+)/g, '/'), '/'); // Let's get only full variable name limited by '/'. We want to avoid false
+  // positive like parsing `$variableInString` to `valueInString`
+
+  var segments = sanitizedPath.split('/');
+  return segments.map(function (segment) {
+    return (variables === null || variables === void 0 ? void 0 : variables[segment.slice(1)]) || segment;
+  }).join('/');
+};
+
+var sanitizeAccountIdentifierRx = /\//g;
+/**
+ * Returns a permission ready to be passed to
+ * client.collection('io.cozy.permissions').add().
+ *
+ * @param  {import('../types').IOCozyFolder} folder    The folder which the konnector should have access
+ * @returns {Object}           Permission object
+ */
+
+var buildFolderPermission = function buildFolderPermission(folder) {
+  return {
+    // Legacy name
+    saveFolder: {
+      type: 'io.cozy.files',
+      values: [folder._id],
+      verbs: ['GET', 'PATCH', 'POST']
+    }
+  };
+};
+/**
+ * Replacer of the lodash/trim function
+ *
+ * @param {String} str - Input string
+ * @param {String} c - String to trim from the input string
+ * @returns {String}
+ */
+
+
+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');
+};

package/dist/models/konnectorFolder.spec.js

@@ -0,0 +1,136 @@
+import { ensureKonnectorFolder } from './konnectorFolder'
+
+describe('ensureKonnectorFolder', () => {
+  const mockClient = {
+    collection: () => mockClient,
+    findReferencedBy: jest.fn(),
+    statByPath: jest.fn(),
+    add: jest.fn(),
+    addReferencesTo: jest.fn(),
+    createDirectoryByPath: jest.fn()
+  }
+  const existingMagicFolder = [
+    {
+      path: '/Administratif',
+      created_at: '2023-03-02T14:57:07.661588+01:00'
+    }
+  ]
+  const konnector = {
+    name: 'konnectorName',
+    folders: [
+      {
+        defaultDir: '$administrative/$konnector/$account'
+      }
+    ]
+  }
+
+  const account = { auth: { accountName: 'testAccountName' } }
+  beforeEach(() => {
+    mockClient.findReferencedBy.mockResolvedValue({
+      included: existingMagicFolder
+    })
+  })
+
+  afterEach(() => {
+    jest.resetAllMocks()
+  })
+
+  it('should create a folder when it does not exist and return it', async () => {
+    mockClient.statByPath.mockRejectedValueOnce({ status: 404 })
+    mockClient.createDirectoryByPath.mockResolvedValueOnce({
+      data: {
+        _id: 'createdfolderid'
+      }
+    })
+    const result = await ensureKonnectorFolder(mockClient, {
+      konnector,
+      account,
+      lang: 'fr'
+    })
+    expect(result).toStrictEqual({ _id: 'createdfolderid' })
+    expect(mockClient.statByPath).toHaveBeenCalledWith(
+      '/Administratif/konnectorName/testAccountName'
+    )
+    expect(mockClient.createDirectoryByPath).toHaveBeenCalledWith(
+      '/Administratif/konnectorName/testAccountName'
+    )
+    expect(mockClient.add).toHaveBeenCalledWith(konnector, {
+      saveFolder: {
+        type: 'io.cozy.files',
+        values: ['createdfolderid'],
+        verbs: ['GET', 'PATCH', 'POST']
+      }
+    })
+    expect(mockClient.addReferencesTo).toHaveBeenCalledWith(konnector, [
+      { _id: 'createdfolderid' }
+    ])
+  })
+  it('should not create a folder if it already exist', async () => {
+    const existingMagicFolder = [
+      {
+        path: '/Administratif',
+        created_at: '2023-03-02T14:57:07.661588+01:00'
+      }
+    ]
+    mockClient.findReferencedBy.mockResolvedValue({
+      included: existingMagicFolder
+    })
+    mockClient.statByPath.mockResolvedValueOnce({
+      data: {
+        _id: 'alreadyexistingfolderid'
+      }
+    })
+    const result = await ensureKonnectorFolder(mockClient, {
+      konnector: {
+        name: 'konnectorName',
+        folders: [
+          {
+            defaultDir: '$administrative/$konnector/$account'
+          }
+        ]
+      },
+      account: { auth: { accountName: 'testAccountName' } },
+      lang: 'fr'
+    })
+    expect(result).toStrictEqual({ _id: 'alreadyexistingfolderid' })
+    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.statByPath.mockResolvedValueOnce({
+      data: {
+        _id: 'folderintrash',
+        trashed: true
+      }
+    })
+    mockClient.createDirectoryByPath.mockResolvedValueOnce({
+      data: {
+        _id: 'createdfolderid'
+      }
+    })
+    const result = await ensureKonnectorFolder(mockClient, {
+      konnector,
+      account,
+      lang: 'fr'
+    })
+    expect(result).toStrictEqual({ _id: 'createdfolderid' })
+    expect(mockClient.statByPath).toHaveBeenCalledWith(
+      '/Administratif/konnectorName/testAccountName'
+    )
+    expect(mockClient.createDirectoryByPath).toHaveBeenCalledWith(
+      '/Administratif/konnectorName/testAccountName'
+    )
+    expect(mockClient.add).toHaveBeenCalledWith(konnector, {
+      saveFolder: {
+        type: 'io.cozy.files',
+        values: ['createdfolderid'],
+        verbs: ['GET', 'PATCH', 'POST']
+      }
+    })
+    expect(mockClient.addReferencesTo).toHaveBeenCalledWith(konnector, [
+      { _id: 'createdfolderid' }
+    ])
+  })
+})

package/dist/types.js

@@ -312,6 +312,7 @@ var _dsl = require("./queries/dsl");
  * @property {string} name - Name of the folder
  * @property {object} metadata - Metadata of the folder
  * @property {object} type - Type of the folder
+ * @property {string} path - Folder path
  * @typedef {CozyClientDocument & FolderDocument} IOCozyFolder - An io.cozy.files document
  */
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cozy-client",
-  "version": "41.2.1",
+  "version": "41.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": "f637f8b66229a89f5bc41bc4b9ccf8e96345f7c0"
+  "gitHead": "b69af4c4c28456f2d24e3dffa19f7921cb489e4e"
 }

package/types/models/document/locales/index.d.ts

@@ -6,3 +6,8 @@ export function getBoundT(lang: string): (label: string, opts?: {
     country?: string;
     smart_count?: number;
 }) => string;
+/**
+ * @param {string} lang - fr, en, etc
+ * @returns {Function} - localization function
+ */
+export function getLocalizer(lang: string): Function;

package/types/models/index.d.ts

@@ -4,6 +4,7 @@ import * as instance from "./instance";
 import * as applications from "./applications";
 import * as file from "./file";
 import * as folder from "./folder";
+import * as konnectorFolder from "./konnectorFolder";
 import * as note from "./note";
 import * as account from "./account";
 export const accounts: typeof account;
@@ -16,4 +17,4 @@ import * as sharing from "./sharing";
 import * as dacc from "./dacc";
 import * as paper from "./paper";
 import * as user from "./user";
-export { trigger, instance, applications, file, folder, note, account, permission, utils, contact, document, timeseries, sharing, dacc, paper, user };
+export { trigger, instance, applications, file, folder, konnectorFolder, note, account, permission, utils, contact, document, timeseries, sharing, dacc, paper, user };

package/types/models/konnectorFolder.d.ts

@@ -0,0 +1,12 @@
+export function ensureKonnectorFolder(client: CozyClient, { konnector, account, lang }: {
+    konnector: import('../types').IOCozyKonnector;
+    account: import('../types').IOCozyAccount;
+    lang: string;
+}): Promise<import('../types').IOCozyFolder>;
+export function createDirectoryByPath(client: CozyClient, path: string): Promise<import('../types').IOCozyFolder>;
+export function statDirectoryByPath(client: CozyClient, path: string): Promise<import('../types').IOCozyFolder | null>;
+export function buildFolderPath(konnector: import('../types').IOCozyKonnector, account: import('../types').IOCozyAccount, magicFolders?: {
+    [x: string]: string;
+}): string;
+export function buildFolderPermission(folder: import('../types').IOCozyFolder): any;
+import CozyClient from "../CozyClient";

package/types/models/permission.d.ts

@@ -52,7 +52,7 @@ export type Document = {
     _type: string;
     type: string;
 };
-export type PermissionVerb = "POST" | "DELETE" | "PUT" | "GET" | "ALL" | "PATCH";
+export type PermissionVerb = "POST" | "DELETE" | "PUT" | "GET" | "PATCH" | "ALL";
 export type PermissionItem = {
     /**
      * - ALL, GET, PUT, PATCH, DELETE, POST…

package/types/types.d.ts

@@ -579,6 +579,10 @@ export type FolderDocument = {
      * - Type of the folder
      */
     type: object;
+    /**
+     * - Folder path
+     */
+    path: string;
 };
 /**
  * - An io.cozy.files document