feat: Add contract option to saveFiles

This option can be used in saveFiles options or in saveFiles
entries. saveFiles entries take priority over saveFiles options.

Author: doubleface

packages/cozy-clisk/src/launcher/saveFiles.js

@@ -15,6 +15,9 @@ import { dataUriToArrayBuffer } from '../libs/utils'
  * @property {boolean} [_cozy_file_to_create] - Internal use to count the number of files to download
  * @property {object} [fileAttributes] - metadata attributes to add to the resulting file object
  * @property {string} [subPath] - subPath of the destination folder path where to put the downloaded file
+ * @property {object} [contract] - contract object associated to the file
+ * @property {string} [contract.id] - id of the contract
+ * @property {string} [contract.name] - name of the contract
  * @property {import('cozy-client/types/types').IOCozyFile} [existingFile] - already existing file corresponding to the entry
  * @property {boolean} [shouldReplace] - Internal result of the shouldReplaceFile function on the entry
  * @property {boolean} [forceReplaceFile] - should the konnector force the replace of the current file
@@ -28,6 +31,9 @@ import { dataUriToArrayBuffer } from '../libs/utils'
  * @property {Array<string>} fileIdAttributes - List of entry attributes considered as unique deduplication key
  * @property {Function} log - Logging function coming from the Launcher
  * @property {string} [subPath] - subPath of the destination folder path where to put the downloaded file
+ * @property {object} [contract] - contract object associated to the files
+ * @property {string} [contract.id] - id of the contract
+ * @property {string} [contract.name] - name of the contract
  * @property {string} [contentType] - will force the contentType of the file if any
  * @property {Function} [downloadAndFormatFile] - this callback will download the file and format to be useable by cozy-client
  * @property {string} [qualificationLabel] - qualification label defined in cozy-client which will be used on all given files
@@ -41,6 +47,9 @@ import { dataUriToArrayBuffer } from '../libs/utils'
  * @property {Array<string>} fileIdAttributes - List of entry attributes considered as unique deduplication key
  * @property {Function} log - Logging function coming from the Launcher
  * @property {string} [subPath] - subPath of the destination folder path where to put the downloaded file
+ * @property {object} [contract] - contract object associated to the file
+ * @property {string} [contract.id] - id of the contract
+ * @property {string} [contract.name] - name of the contract
  * @property {string} [contentType] - will force the contentType of the file if any
  * @property {Function} [downloadAndFormatFile] - this callback will download the file and format to be useable by cozy-client
  * @property {string} [qualificationLabel] - qualification label defined in cozy-client which will be used on all given files
@@ -107,6 +116,7 @@ const saveFiles = async (client, entries, folderPath, options) => {
     log,
     retry: options.retry,
     subPath: options.subPath,
+    contract: options.contract,
     fileIdAttributes: options.fileIdAttributes,
     manifest: options.manifest,
     contentType: options.contentType,
@@ -184,7 +194,7 @@ const saveFiles = async (client, entries, folderPath, options) => {
 
 /**
  * Ensure the existence of all destination folders : folderPath, options.subPath and all subPaths
- * which may be present in each entries.
+ * which may be present in each entries + contracts.
  * If the user changes some folders during the execution of saveFile, we will catch and fix the
  * errors.
  *
@@ -201,28 +211,112 @@ async function ensureAllDestinationFolders({
   folderPath,
   options
 }) {
-  const fileCollection = client.collection('io.cozy.files')
+  try {
+    const fileCollection = client.collection('io.cozy.files')
 
-  const pathsList = []
+    const pathsList = []
 
-  // construct an Array with all the paths to ensure the existence of
-  if (options.subPath) {
-    pathsList.push(folderPath + '/' + options.subPath)
-  }
-  const notFilteredEntriesPathList = entries.map(entry =>
-    entry.subPath ? folderPath + '/' + entry.subPath : false
-  )
-  const entriesPathList = Array.from(
-    new Set(notFilteredEntriesPathList)
-  ).filter(Boolean)
-  // @ts-ignore Argument of type 'string | false' is not assignable to parameter of type 'string'.  Type 'boolean' is not assignable to type 'string'.ts(2345)
-  pathsList.push(...entriesPathList)
+    // construct an Array with all the paths to ensure the existence of
+    if (options.subPath) {
+      pathsList.push(folderPath + '/' + options.subPath)
+    }
+    const notFilteredEntriesPathList = entries.map(entry =>
+      entry.subPath ? folderPath + '/' + entry.subPath : false
+    )
+    const entriesPathList = Array.from(
+      new Set(notFilteredEntriesPathList)
+    ).filter(Boolean)
+    // @ts-ignore Argument of type 'string | false' is not assignable to parameter of type 'string'.  Type 'boolean' is not assignable to type 'string'.ts(2345)
+    pathsList.push(...entriesPathList)
+
+    for (const path of pathsList) {
+      await fileCollection.ensureDirectoryExists(path)
+    }
+
+    const slug = options?.manifest?.slug
+    const { included: existingKonnectorFolders } = await client.query(
+      Q('io.cozy.files')
+        .where({})
+        .partialIndex({ type: 'directory', trashed: false })
+        .referencedBy({
+          _type: 'io.cozy.konnectors',
+          _id: `io.cozy.konnectors/${slug}`
+        })
+    )
+
+    const sourceAccountIdentifier =
+      options.sourceAccountOptions?.sourceAccountIdentifier
+    const existingAccountFolders = existingKonnectorFolders.filter(folder =>
+      Boolean(
+        folder.referenced_by?.find(
+          ref =>
+            ref.type === 'io.cozy.accounts.sourceAccountIdentifier' &&
+            (sourceAccountIdentifier
+              ? ref.id === sourceAccountIdentifier
+              : true)
+        )
+      )
+    )
 
-  for (const path of pathsList) {
-    await fileCollection.ensureDirectoryExists(path)
+    const contractsList = Array.from(
+      new Set(entries.map(entry => entry.contract))
+    ).filter(Boolean)
+    if (options.contract) {
+      contractsList.unshift(options.contract)
+    }
+
+    for (const contract of contractsList) {
+      if (
+        !contract ||
+        existingAccountFolders.find(folder =>
+          hasContractReference(folder, contract.id)
+        )
+      ) {
+        continue
+      }
+
+      const { data: folder } = await fileCollection.createDirectoryByPath(
+        folderPath + '/' + contract.name
+      )
+      await Promise.all([
+        fileCollection.addReferencesTo(
+          {
+            _id: `io.cozy.konnectors/${slug}`,
+            _type: 'io.cozy.konnector'
+          },
+          [folder]
+        ),
+        fileCollection.addReferencesTo(
+          {
+            _id: sourceAccountIdentifier,
+            _type: 'io.cozy.accounts.sourceAccountIdentifier'
+          },
+          [folder]
+        ),
+        fileCollection.addReferencesTo(
+          {
+            _id: contract.id,
+            _type: 'io.cozy.accounts.contracts'
+          },
+          [folder]
+        )
+      ])
+    }
+  } catch (err) {
+    throw new Error(
+      `cozy-clisk::saveFiles Error in ensureAllDestinationFolders. Cannot save files: ${err.message}`
+    )
   }
 }
 
+function hasContractReference(folder, contractId) {
+  return Boolean(
+    folder.referenced_by?.find(
+      ref => ref.type === 'io.cozy.accounts.contracts' && ref.id === contractId
+    )
+  )
+}
+
 /**
  * Saves a single file entry
  *
@@ -380,7 +474,11 @@ async function createFileWithFolderOnError(
   method,
   file
 ) {
-  const subPath = entry.subPath || options.subPath
+  const subPath =
+    entry.contract?.name ||
+    options.contract?.name ||
+    entry.subPath ||
+    options.subPath
   const finalPath = subPath
     ? options.folderPath + '/' + subPath
     : options.folderPath

packages/cozy-clisk/src/launcher/saveFiles.spec.js

@@ -22,6 +22,7 @@ describe('saveFiles', function () {
     const existingFilesIndex = new Map([['old file name.txt', fileDocument]])
     const client = {
       save: jest.fn(),
+      query: jest.fn().mockResolvedValue({ included: [], data: null }),
       collection: () => ({
         statByPath: jest.fn().mockImplementation(path => {
           return { data: { _id: path } }
@@ -78,6 +79,7 @@ describe('saveFiles', function () {
       save: jest.fn().mockImplementation(doc => ({
         data: { ...doc, _rev: 'newrev' }
       })),
+      query: jest.fn().mockResolvedValue({ included: [], data: null }),
       collection: () => ({
         statByPath: jest.fn().mockImplementation(path => {
           return { data: { _id: path } }
@@ -142,6 +144,7 @@ describe('saveFiles', function () {
       save: jest.fn().mockImplementation(doc => ({
         data: doc
       })),
+      query: jest.fn().mockResolvedValue({ included: [], data: null }),
       collection: () => ({
         statByPath: jest
           .fn()
@@ -198,6 +201,7 @@ describe('saveFiles', function () {
       save: jest.fn().mockImplementation(doc => ({
         data: doc
       })),
+      query: jest.fn().mockResolvedValue({ included: [], data: null }),
       collection: () => ({
         statByPath: jest.fn().mockImplementation(path => {
           return { data: { _id: path } }
@@ -253,6 +257,7 @@ describe('saveFiles', function () {
       save: jest.fn().mockImplementation(doc => ({
         data: doc
       })),
+      query: jest.fn().mockResolvedValue({ included: [], data: null }),
       collection: () => ({
         statByPath: jest.fn().mockImplementation(path => {
           return { data: { _id: path } }
@@ -298,6 +303,7 @@ describe('saveFiles', function () {
       save: jest.fn().mockImplementation(doc => ({
         data: doc
       })),
+      query: jest.fn().mockResolvedValue({ included: [], data: null }),
       collection: () => ({
         statByPath: jest.fn().mockImplementation(path => {
           return { data: { _id: path } }
@@ -349,6 +355,7 @@ describe('saveFiles', function () {
       save: jest.fn().mockImplementation(doc => ({
         data: doc
       })),
+      query: jest.fn().mockResolvedValue({ included: [], data: null }),
       collection: () => ({
         statByPath: jest.fn().mockImplementation(path => {
           return { data: { _id: path } }
@@ -396,6 +403,7 @@ describe('saveFiles', function () {
         }
         return { data: doc }
       }),
+      query: jest.fn().mockResolvedValue({ included: [], data: null }),
       collection: () => ({
         statByPath: jest.fn().mockImplementation(path => {
           return { data: { _id: path } }
@@ -449,6 +457,7 @@ describe('saveFiles', function () {
 
     const client = {
       save: jest.fn().mockRejectedValueOnce(notExistingDirectoryErr),
+      query: jest.fn().mockResolvedValue({ included: [], data: null }),
       collection: () => ({
         statByPath: jest.fn().mockImplementation(path => {
           return { data: { _id: path } }
@@ -480,6 +489,7 @@ describe('saveFiles', function () {
       save: jest.fn().mockImplementation(doc => ({
         data: doc
       })),
+      query: jest.fn().mockResolvedValue({ included: [], data: null }),
       collection: () => ({
         statByPath: jest
           .fn()
@@ -510,4 +520,60 @@ describe('saveFiles', function () {
     }
     expect(caught).toBe(false)
   })
+  it('should save a file with a contract', async () => {
+    const ensureDirectoryExists = jest
+      .fn()
+      .mockImplementation(async path => path)
+    const createDirectoryByPath = jest
+      .fn()
+      .mockImplementation(async path => ({ data: { path } }))
+    const client = {
+      save: jest.fn().mockImplementation(doc => ({
+        data: doc
+      })),
+      query: jest.fn().mockResolvedValue({ included: [], data: null }),
+      collection: () => ({
+        statByPath: jest.fn().mockImplementation(path => {
+          return { data: { _id: path } }
+        }),
+        ensureDirectoryExists,
+        createDirectoryByPath,
+        addReferencesTo: jest.fn()
+      })
+    }
+    const document = {
+      filestream: 'filestream content',
+      filename: 'file name.txt'
+    }
+    const result = await saveFiles(client, [document], '/test/folder/path', {
+      manifest: {
+        slug: 'testslug'
+      },
+      contract: {
+        id: 'testContractId',
+        name: 'testContractName'
+      },
+      sourceAccount: 'testsourceaccount',
+      sourceAccountIdentifier: 'testsourceaccountidentifier',
+      fileIdAttributes: ['filename'],
+      existingFilesIndex: new Map(),
+      log: jest.fn()
+    })
+    expect(createDirectoryByPath).toHaveBeenCalledWith(
+      '/test/folder/path/testContractName'
+    )
+    expect(client.save).toHaveBeenCalledWith(
+      expect.objectContaining({
+        dirId: '/test/folder/path/testContractName'
+      })
+    )
+    expect(result).toStrictEqual([
+      {
+        filename: 'file name.txt',
+        fileDocument: expect.objectContaining({
+          dirId: '/test/folder/path/testContractName'
+        })
+      }
+    ])
+  })
 })

packages/cozy-konnector-libs/docs/api.md

@@ -494,7 +494,7 @@ Saves the given files in the given folder via the Cozy API.
 
 <a name="exp_module_saveFiles--saveFiles"></a>
 
-### saveFiles(entries, fields, options) ⏏
+### saveFiles(entries, fields, options, [contract]) ⏏
 Saves the files given in the fileurl attribute of each entries
 
 You need the full permission on `io.cozy.files` in your manifest to use this function.
@@ -513,6 +513,9 @@ You need the full permission on `io.cozy.files` in your manifest to use this fun
 | entries.shouldReplaceFile | <code>function</code> | use this function to state if the current entry should be forced to be redownloaded and replaced. Usefull if we know the file content can change and we always want the last version. |
 | entries.fileAttributes | <code>object</code> | ex: `{created_at: new Date()}` sets some additionnal file attributes passed to cozyClient.file.create |
 | entries.subPath | <code>string</code> | A subpath to save all files, will be created if needed. |
+| entries.contract | <code>object</code> | contract object associated to the files |
+| entries.contract.id | <code>string</code> | id of the contract |
+| entries.contract.name | <code>string</code> | name of the contract |
 | fields | <code>object</code> | is the argument given to the main function of your connector by the BaseKonnector.  It especially contains a `folderPath` which is the string path configured by the user in collect/home |
 | options | <code>object</code> | global options |
 | options.timeout | <code>number</code> | timestamp which can be used if your connector needs to fetch a lot of files and if the stack does not give enough time to your connector to fetch it all. It could happen that the connector is stopped right in the middle of the download of the file and the file will be broken. With the `timeout` option, the `saveFiles` function will check if the timeout has passed right after downloading each file and then will be sure to be stopped cleanly if the timeout is not too long. And since it is really fast to check that a file has already been downloaded, on the next run of the connector, it will be able to download some more files, and so on. If you want the timeout to be in 10s, do `Date.now() + 10*1000`.  You can try it in the previous code. |
@@ -522,6 +525,9 @@ You need the full permission on `io.cozy.files` in your manifest to use this fun
 | options.validateFileContent | <code>boolean</code> \| <code>function</code> | default false. Also check the content of the file to recognize the mime type |
 | options.fileIdAttributes | <code>Array</code> | array of strings : Describes which attributes of files will be taken as primary key for files to check if they already exist, even if they are moved. If not given, the file path will used for deduplication as before. |
 | options.subPath | <code>string</code> | A subpath to save this file, will be created if needed. |
+| [contract] | <code>object</code> | contract object associated to the file |
+| [contract.id] | <code>string</code> | id of the contract |
+| [contract.name] | <code>string</code> | name of the contract |
 | options.fetchFile | <code>function</code> | the connector can give it's own function to fetch the file from the website, which will be run only when necessary (if the corresponding file is missing on the cozy) function returning the stream). This function must return a promise resolved as a stream |
 | options.verboseFilesLog | <code>boolean</code> | the connector will send saveFiles result as a warning |
 

packages/cozy-konnector-libs/src/libs/saveFiles.js

@@ -50,6 +50,9 @@ const FILES_DOCTYPE = 'io.cozy.files'
  * @param {Function} entries.shouldReplaceFile - use this function to state if the current entry should be forced to be redownloaded and replaced. Usefull if we know the file content can change and we always want the last version.
  * @param {object} entries.fileAttributes - ex: `{created_at: new Date()}` sets some additionnal file attributes passed to cozyClient.file.create
  * @param {string} entries.subPath - A subpath to save all files, will be created if needed.
+ * @param {object} entries.contract - contract object associated to the files
+ * @param {string} entries.contract.id - id of the contract
+ * @param {string} entries.contract.name - name of the contract
  * @param {object} fields - is the argument given to the main function of your connector by the BaseKonnector.  It especially contains a `folderPath` which is the string path configured by the user in collect/home
  * @param {object} options - global options
  * @param {number} options.timeout - timestamp which can be used if your connector needs to fetch a lot of files and if the stack does not give enough time to your connector to fetch it all. It could happen that the connector is stopped right in the middle of the download of the file and the file will be broken. With the `timeout` option, the `saveFiles` function will check if the timeout has passed right after downloading each file and then will be sure to be stopped cleanly if the timeout is not too long. And since it is really fast to check that a file has already been downloaded, on the next run of the connector, it will be able to download some more files, and so on. If you want the timeout to be in 10s, do `Date.now() + 10*1000`.  You can try it in the previous code.
@@ -59,6 +62,10 @@ const FILES_DOCTYPE = 'io.cozy.files'
  * @param {boolean|Function} options.validateFileContent - default false. Also check the content of the file to recognize the mime type
  * @param {Array} options.fileIdAttributes - array of strings : Describes which attributes of files will be taken as primary key for files to check if they already exist, even if they are moved. If not given, the file path will used for deduplication as before.
  * @param {string} options.subPath - A subpath to save this file, will be created if needed.
+ * @param {object} [contract] - contract object associated to the file
+ * @param {string} [contract.id] - id of the contract
+ * @param {string} [contract.name] - name of the contract
+
  * @param {Function} options.fetchFile - the connector can give it's own function to fetch the file from the website, which will be run only when necessary (if the corresponding file is missing on the cozy) function returning the stream). This function must return a promise resolved as a stream
  * @param {boolean} options.verboseFilesLog - the connector will send saveFiles result as a warning
  * @example
@@ -102,6 +109,7 @@ const saveFiles = async (entries, fields, options = {}) => {
     shouldReplaceFile: options.shouldReplaceFile,
     validateFile: options.validateFile || defaultValidateFile,
     subPath: options.subPath,
+    contract: options.contract,
     sourceAccountOptions: {
       sourceAccount: options.sourceAccount,
       sourceAccountIdentifier: options.sourceAccountIdentifier
@@ -121,6 +129,29 @@ const saveFiles = async (entries, fields, options = {}) => {
   const canBeSaved = entry =>
     entry.fetchFile || entry.fileurl || entry.requestOptions || entry.filestream
 
+  // get all konnector folders
+  const slug = manifest.data.slug
+  const { included: existingKonnectorFolders } = await client.query(
+    Q('io.cozy.files')
+      .where({})
+      .partialIndex({ type: 'directory', trashed: false })
+      .referencedBy({
+        _type: 'io.cozy.konnectors',
+        _id: `io.cozy.konnectors/${slug}`
+      })
+  )
+  const sourceAccountIdentifier = options.sourceAccountIdentifier
+
+  const existingAccountFolders = existingKonnectorFolders.filter(folder =>
+    Boolean(
+      folder.referenced_by?.find(
+        ref =>
+          ref.type === 'io.cozy.accounts.sourceAccountIdentifier' &&
+          (sourceAccountIdentifier ? ref.id === sourceAccountIdentifier : true)
+      )
+    )
+  )
+
   let filesArray = undefined
   let savedFiles = 0
   const savedEntries = []
@@ -162,19 +193,23 @@ const saveFiles = async (entries, fields, options = {}) => {
 
           delete entry.shouldReplaceName
         }
-
+        let newEntry = { ...entry }
         if (canBeSaved(entry)) {
           const folderPath = await getOrCreateDestinationPath(
             entry,
-            saveOptions
+            saveOptions,
+            existingAccountFolders
           )
-          entry = await saveEntry(entry, { ...saveOptions, folderPath })
+          newEntry = await saveEntry(entry, {
+            ...saveOptions,
+            folderPath
+          })
           if (entry && entry._cozy_file_to_create) {
             savedFiles++
             delete entry._cozy_file_to_create
           }
         }
-        savedEntries.push(entry)
+        savedEntries.push(newEntry)
       },
       { concurrency: saveOptions.concurrency }
     )
@@ -384,10 +419,11 @@ async function getFileFromMetaData(
 async function getFileFromPath(entry, options) {
   try {
     log('debug', `Checking existence of ${getFilePath({ entry, options })}`)
-    const result = await client
-      .collection(FILES_DOCTYPE)
-      .statByPath(getFilePath({ entry, options }))
-    return result.data
+    return (
+      await client
+        .collection(FILES_DOCTYPE)
+        .statByPath(getFilePath({ entry, options }))
+    ).data
   } catch (err) {
     log('debug', err.message)
     return false
@@ -780,12 +816,78 @@ function getAttribute(obj, attribute) {
   return get(obj, `attributes.${attribute}`, get(obj, attribute))
 }
 
-async function getOrCreateDestinationPath(entry, saveOptions) {
-  const subPath = entry.subPath || saveOptions.subPath
-  let finalPath = saveOptions.folderPath
-  if (subPath) {
-    finalPath += '/' + subPath
-    await client.collection(FILES_DOCTYPE).createDirectoryByPath(finalPath)
+async function getOrCreateDestinationPath(
+  entry,
+  saveOptions,
+  existingAccountFolders
+) {
+  try {
+    const subPath =
+      entry.contract?.name ||
+      saveOptions.contract?.name ||
+      entry.subPath ||
+      saveOptions.subPath
+    const contractId = entry.contract?.id || saveOptions.contract?.id
+
+    let finalPath = saveOptions.folderPath
+    if (subPath) {
+      // first try to find dirctory by
+      finalPath += '/' + subPath
+      if (
+        contractId &&
+        existingAccountFolders.find(folder =>
+          hasContractReference(folder, contractId)
+        )
+      ) {
+        return finalPath
+      }
+
+      const sourceAccountIdentifier =
+        saveOptions.sourceAccountOptions?.sourceAccountIdentifier
+
+      if (sourceAccountIdentifier) {
+        const slug = manifest.data.slug
+        const fileCollection = client.collection(FILES_DOCTYPE)
+        const { data: folder } = await fileCollection.createDirectoryByPath(
+          finalPath
+        )
+        await Promise.all([
+          fileCollection.addReferencesTo(
+            {
+              _id: `io.cozy.konnectors/${slug}`,
+              _type: 'io.cozy.konnectors'
+            },
+            [folder]
+          ),
+          fileCollection.addReferencesTo(
+            {
+              _id: sourceAccountIdentifier,
+              _type: 'io.cozy.accounts.sourceAccountIdentifier'
+            },
+            [folder]
+          ),
+          fileCollection.addReferencesTo(
+            {
+              _id: contractId,
+              _type: 'io.cozy.accounts.contracts'
+            },
+            [folder]
+          )
+        ])
+      }
+    }
+    return finalPath
+  } catch (err) {
+    throw new Error(
+      `cozy-konnector-libs::saveFiles Error in getOrCreateDestinationPath. Cannot save files: ${err.message}`
+    )
   }
-  return finalPath
+}
+
+function hasContractReference(folder, contractId) {
+  return Boolean(
+    folder.referenced_by?.find(
+      ref => ref.type === 'io.cozy.accounts.contracts' && ref.id === contractId
+    )
+  )
 }

packages/cozy-konnector-libs/src/libs/saveFiles.spec.js

@@ -1,29 +1,38 @@
 jest.mock('./cozyclient')
 const cozyClient = require('./cozyclient')
+
 const save = jest.fn()
+const query = jest.fn().mockResolvedValue({ included: [], data: null })
 const destroy = jest.fn()
 const queryAll = jest.fn()
 const statByPath = jest.fn()
 const deleteFilePermanently = jest.fn()
 const fetchFileContentById = jest.fn()
-const createDirectoryByPath = jest.fn()
+const createDirectoryByPath = jest
+  .fn()
+  .mockImplementation(path => ({ data: { _id: 'subpathid', path } }))
+const addReferencesTo = jest.fn()
 cozyClient.new = {
   save,
+  query,
   destroy,
   queryAll,
   collection: () => ({
     statByPath,
     deleteFilePermanently,
     fetchFileContentById,
-    createDirectoryByPath
+    createDirectoryByPath,
+    addReferencesTo
   })
 }
 const client = cozyClient.new
 const { models } = require('cozy-client')
 client.models = models
 
 const manifest = require('./manifest')
+
 const logger = require('cozy-logger')
+
 const saveFiles = require('./saveFiles')
 const getFileIfExists = saveFiles.getFileIfExists
 const sanitizeFileName = saveFiles.sanitizeFileName
@@ -134,6 +143,7 @@ describe('saveFiles', function () {
     } = test
     describe(name, () => {
       beforeEach(async () => {
+        query.mockResolvedValue({ included: [] })
         statByPath.mockImplementation(async path => {
           if (path === FOLDER_PATH) {
             return { data: { _id: 'folderId' } }
@@ -189,17 +199,21 @@ describe('saveFiles', function () {
   // Renaming Test, not working due to not sucessfully mock updateAttributesById
   describe('when entry have shouldReplaceName', () => {
     beforeEach(async () => {
-      /* cozyClient.files.statByPath.mockImplementation(() => {
-         return asyncResolve({ _id: 'folderId' })
-       })*/
+      statByPath.mockImplementation(async path => {
+        // Must check if we are stating on the folder or on the file
+        return path === FOLDER_PATH
+          ? { data: { _id: 'folderId' } }
+          : {
+              data: makeFile('existingFileId', {
+                name: 'bill.pdf'
+              })
+            }
+      })
+      query.mockResolvedValue({ included: [] })
       queryAll.mockImplementation(() => {
         // Watch out, not the same format as cozyClient.files
         return [{ name: '201712_freemobile.pdf', _id: 'idToRename' }]
       })
-      /* cozyClient.files.updateAttributesById.mockReset()
-       cozyClient.files.updateAttributesById.mockImplementation(() => {
-         return
-       })*/
     })
     const billWithShouldReplaceName = [
       {
@@ -553,6 +567,13 @@ describe('saveFiles', function () {
 
 describe('subPath handling', () => {
   beforeEach(function () {
+    createDirectoryByPath.mockImplementation(path => ({
+      data: {
+        _id: 'subpathid',
+        path
+      }
+    }))
+    query.mockResolvedValue({ included: [] })
     statByPath.mockImplementation(async path => {
       if (path.includes('randomfileurl.txt')) {
         throw new Error('Anything')
@@ -575,15 +596,21 @@ describe('subPath handling', () => {
     expect(client.collection().createDirectoryByPath.mock.calls.length).toBe(0)
   })
   it('should change the folderPath for entries with subPath', async () => {
-    await saveFiles([{ fileurl: 'randomfileurl.txt', subPath: 'mySubPath' }], {
-      folderPath: 'mainPath'
-    })
+    await saveFiles(
+      [{ fileurl: 'randomfileurl.txt', subPath: 'mySubPath' }],
+      {
+        folderPath: 'mainPath'
+      },
+      {
+        sourceAccountIdentifier: 'accountidentifier'
+      }
+    )
 
     expect(client.collection().createDirectoryByPath).toHaveBeenCalledWith(
       'mainPath/mySubPath'
     )
 
-    expect(client.save).toHaveBeenCalledWith(
+    expect(save).toHaveBeenCalledWith(
       expect.objectContaining({
         name: 'randomfileurl.txt',
         dirId: 'mainPath/mySubPath'
@@ -596,7 +623,7 @@ describe('subPath handling', () => {
       {
         folderPath: 'mainPath'
       },
-      { subPath: 'mySubPath' }
+      { subPath: 'mySubPath', sourceAccountIdentifier: 'accountidentifier' }
     )
 
     expect(client.collection().createDirectoryByPath).toHaveBeenCalledWith(
@@ -612,11 +639,142 @@ describe('subPath handling', () => {
   })
 })
 
+describe('contract handling', () => {
+  beforeEach(function () {
+    createDirectoryByPath.mockImplementation(path => ({
+      data: {
+        _id: 'subpathid',
+        path
+      }
+    }))
+    query.mockResolvedValue({ included: [] })
+    statByPath.mockImplementation(async path => {
+      if (path.includes('randomfileurl.txt')) {
+        throw new Error('Anything')
+      } else {
+        return { data: { _id: path } }
+      }
+    })
+  })
+  it('should not create subPath if no contract specified', async () => {
+    await saveFiles([{ fileurl: 'randomfileurl.txt' }], {
+      folderPath: 'mainPath'
+    })
+
+    expect(client.save).toHaveBeenCalledWith(
+      expect.objectContaining({
+        name: 'randomfileurl.txt',
+        dirId: 'mainPath'
+      })
+    )
+    expect(client.collection().createDirectoryByPath.mock.calls.length).toBe(0)
+    expect(addReferencesTo).not.toHaveBeenCalled()
+  })
+  it('should change the folderPath for entries with contract', async () => {
+    manifest.data.slug = 'testslug'
+    await saveFiles(
+      [
+        {
+          fileurl: 'randomfileurl.txt',
+          contract: { id: 'testContractId', name: 'contractPath' }
+        }
+      ],
+      {
+        folderPath: 'mainPath'
+      },
+      {
+        sourceAccountIdentifier: 'testSourceAccountIdentifier'
+      }
+    )
+
+    expect(client.collection().createDirectoryByPath).toHaveBeenCalledWith(
+      'mainPath/contractPath'
+    )
+
+    expect(save).toHaveBeenCalledWith(
+      expect.objectContaining({
+        name: 'randomfileurl.txt',
+        dirId: 'mainPath/contractPath'
+      })
+    )
+
+    expect(addReferencesTo).toHaveBeenCalledTimes(3)
+    expect(addReferencesTo).toHaveBeenNthCalledWith(
+      1,
+      { _id: 'io.cozy.konnectors/testslug', _type: 'io.cozy.konnectors' },
+      [{ _id: 'subpathid', path: 'mainPath/contractPath' }]
+    )
+    expect(addReferencesTo).toHaveBeenNthCalledWith(
+      2,
+      {
+        _id: 'testSourceAccountIdentifier',
+        _type: 'io.cozy.accounts.sourceAccountIdentifier'
+      },
+      [{ _id: 'subpathid', path: 'mainPath/contractPath' }]
+    )
+    expect(addReferencesTo).toHaveBeenNthCalledWith(
+      3,
+      {
+        _id: 'testContractId',
+        _type: 'io.cozy.accounts.contracts'
+      },
+      [{ _id: 'subpathid', path: 'mainPath/contractPath' }]
+    )
+  })
+  it('should change the folderPath with contract main option', async () => {
+    manifest.data.slug = 'testslug2'
+    await saveFiles(
+      [{ fileurl: 'randomfileurl.txt' }],
+      {
+        folderPath: 'mainPath'
+      },
+      {
+        contract: { id: 'testContractId', name: 'contractPath' },
+        sourceAccountIdentifier: 'testSourceAccountIdentifier'
+      }
+    )
+
+    expect(client.collection().createDirectoryByPath).toHaveBeenCalledWith(
+      'mainPath/contractPath'
+    )
+
+    expect(client.save).toHaveBeenCalledWith(
+      expect.objectContaining({
+        name: 'randomfileurl.txt',
+        dirId: 'mainPath/contractPath'
+      })
+    )
+    expect(addReferencesTo).toHaveBeenCalledTimes(3)
+    expect(addReferencesTo).toHaveBeenNthCalledWith(
+      1,
+      { _id: 'io.cozy.konnectors/testslug2', _type: 'io.cozy.konnectors' },
+      [{ _id: 'subpathid', path: 'mainPath/contractPath' }]
+    )
+    expect(addReferencesTo).toHaveBeenNthCalledWith(
+      2,
+      {
+        _id: 'testSourceAccountIdentifier',
+        _type: 'io.cozy.accounts.sourceAccountIdentifier'
+      },
+      [{ _id: 'subpathid', path: 'mainPath/contractPath' }]
+    )
+    expect(addReferencesTo).toHaveBeenNthCalledWith(
+      3,
+      {
+        _id: 'testContractId',
+        _type: 'io.cozy.accounts.contracts'
+      },
+      [{ _id: 'subpathid', path: 'mainPath/contractPath' }]
+    )
+  })
+})
+
 describe('getFileIfExists', function () {
   jest.resetAllMocks()
   statByPath.mockReset()
   describe('when in filepath mode', () => {
     beforeEach(function () {
+      query.mockResolvedValue({ included: [] })
       manifest.data.slug = false // Without slug, force filepath mode
     })
     it('when the file does not exist, should not return any file', async () => {