chore: activer ESLint sur le backend

Installe eslint, ajoute le script lint, modernise le parser
(retrait de babel-eslint obsolète) et applique l'autofix
(points-virgules manquants sur l'ensemble du code, conformément
à la règle "semi" déjà présente dans .eslintrc mais jamais
appliquée faute d'ESLint installé et d'un script pour l'exécuter).

src/api/parole/controllers/__tests__/parole.test.js

@@ -1,20 +1,20 @@
-import {describe, it, expect, vi} from 'vitest'
+import {describe, it, expect, vi} from 'vitest';
 
-const {default: createController} = await import('../parole.js')
+const {default: createController} = await import('../parole.js');
 
 function buildStrapi({dbUser, artiste}) {
   const paroleDocuments = {
     findMany: vi.fn(async () => []),
     create: vi.fn(async ({data}) => ({id: 42, ...data})),
     update: vi.fn(async ({data}) => ({id: 42, ...data}))
-  }
+  };
   const userDocuments = {
     findOne: vi.fn(async () => dbUser),
     update: vi.fn(async () => {})
-  }
+  };
   const artisteDocuments = {
     findOne: vi.fn(async () => artiste)
-  }
+  };
 
   const strapi = {
     contentType: vi.fn(() => ({uid: 'api::parole.parole', kind: 'collectionType'})),
@@ -23,14 +23,14 @@ function buildStrapi({dbUser, artiste}) {
       translateLyrics: vi.fn()
     })),
     documents: vi.fn(uid => {
-      if (uid === 'plugin::users-permissions.user') return userDocuments
-      if (uid === 'api::artiste.artiste') return artisteDocuments
-      if (uid === 'api::parole.parole') return paroleDocuments
-      throw new Error(`unexpected uid: ${uid}`)
+      if (uid === 'plugin::users-permissions.user') return userDocuments;
+      if (uid === 'api::artiste.artiste') return artisteDocuments;
+      if (uid === 'api::parole.parole') return paroleDocuments;
+      throw new Error(`unexpected uid: ${uid}`);
     })
-  }
+  };
 
-  return {strapi, paroleDocuments, userDocuments, artisteDocuments}
+  return {strapi, paroleDocuments, userDocuments, artisteDocuments};
 }
 
 function buildCtx(data) {
@@ -41,11 +41,11 @@ function buildCtx(data) {
     },
     badRequest: vi.fn(),
     notFound: vi.fn()
-  }
+  };
 }
 
-const dbUser = {id: 1, documentId: 'user-doc-1', username: 'foo', email: 'foo@bar.com'}
-const artiste = {id: 9, documentId: 'artiste-doc-1'}
+const dbUser = {id: 1, documentId: 'user-doc-1', username: 'foo', email: 'foo@bar.com'};
+const artiste = {id: 9, documentId: 'artiste-doc-1'};
 
 function buildData(overrides = {}) {
   return {
@@ -54,77 +54,77 @@ function buildData(overrides = {}) {
     user: {...dbUser},
     artistes: [{documentId: 'artiste-doc-1'}],
     ...overrides
-  }
+  };
 }
 
 describe('parole.findOne', () => {
   it('interroge avec le documentId venant de ctx.params.id, pas avec ctx lui-même', async () => {
     const paroleDocuments = {
       findOne: vi.fn(async ({documentId}) => ({id: 1, documentId, titre: 'Test'}))
-    }
+    };
     const strapi = {
       contentType: vi.fn(() => ({uid: 'api::parole.parole', kind: 'collectionType'})),
       documents: vi.fn(uid => {
-        if (uid === 'api::parole.parole') return paroleDocuments
-        throw new Error(`unexpected uid: ${uid}`)
+        if (uid === 'api::parole.parole') return paroleDocuments;
+        throw new Error(`unexpected uid: ${uid}`);
       })
-    }
-    const controller = createController({strapi})
-    const ctx = {params: {id: 'doc-123'}}
+    };
+    const controller = createController({strapi});
+    const ctx = {params: {id: 'doc-123'}};
 
-    const result = await controller.findOne(ctx)
+    const result = await controller.findOne(ctx);
 
     expect(paroleDocuments.findOne).toHaveBeenCalledWith({
       documentId: 'doc-123',
       populate: ['artistes']
-    })
-    expect(result).toEqual({id: 1, documentId: 'doc-123', titre: 'Test'})
-  })
-})
+    });
+    expect(result).toEqual({id: 1, documentId: 'doc-123', titre: 'Test'});
+  });
+});
 
 describe('parole.create', () => {
   it('crée la parole quand le user et l\'artiste existent', async () => {
-    const {strapi, paroleDocuments} = buildStrapi({dbUser, artiste})
-    const controller = createController({strapi})
-    const ctx = buildCtx(buildData())
+    const {strapi, paroleDocuments} = buildStrapi({dbUser, artiste});
+    const controller = createController({strapi});
+    const ctx = buildCtx(buildData());
 
-    await controller.create(ctx)
+    await controller.create(ctx);
 
-    expect(paroleDocuments.create).toHaveBeenCalled()
-  })
+    expect(paroleDocuments.create).toHaveBeenCalled();
+  });
 
   it('refuse sans planter quand data.user est absent', async () => {
-    const {strapi, userDocuments} = buildStrapi({dbUser, artiste})
-    const controller = createController({strapi})
-    const ctx = buildCtx(buildData({user: undefined}))
+    const {strapi, userDocuments} = buildStrapi({dbUser, artiste});
+    const controller = createController({strapi});
+    const ctx = buildCtx(buildData({user: undefined}));
 
-    await controller.create(ctx)
+    await controller.create(ctx);
 
-    expect(ctx.badRequest).toHaveBeenCalled()
-    expect(userDocuments.findOne).not.toHaveBeenCalled()
-  })
+    expect(ctx.badRequest).toHaveBeenCalled();
+    expect(userDocuments.findOne).not.toHaveBeenCalled();
+  });
 
   it('refuse sans planter quand data.artistes est vide', async () => {
-    const {strapi, artisteDocuments} = buildStrapi({dbUser, artiste})
-    const controller = createController({strapi})
-    const ctx = buildCtx(buildData({artistes: []}))
+    const {strapi, artisteDocuments} = buildStrapi({dbUser, artiste});
+    const controller = createController({strapi});
+    const ctx = buildCtx(buildData({artistes: []}));
 
-    await controller.create(ctx)
+    await controller.create(ctx);
 
-    expect(ctx.badRequest).toHaveBeenCalled()
-    expect(artisteDocuments.findOne).not.toHaveBeenCalled()
-  })
+    expect(ctx.badRequest).toHaveBeenCalled();
+    expect(artisteDocuments.findOne).not.toHaveBeenCalled();
+  });
 
   it('ignore les champs non autorisés du payload (mass assignment)', async () => {
-    const {strapi, paroleDocuments} = buildStrapi({dbUser, artiste})
-    const controller = createController({strapi})
+    const {strapi, paroleDocuments} = buildStrapi({dbUser, artiste});
+    const controller = createController({strapi});
     const ctx = buildCtx(buildData({
       userAdmin: {id: 999},
       isNewRelease: true,
       difference: [{fake: true}]
-    }))
+    }));
 
-    await controller.create(ctx)
+    await controller.create(ctx);
 
     expect(paroleDocuments.create).toHaveBeenCalledWith({
       data: {
@@ -135,14 +135,14 @@ describe('parole.create', () => {
         artistes: [artiste.id],
         user: dbUser.id
       }
-    })
-  })
-})
+    });
+  });
+});
 
 describe('parole.update', () => {
   it('ignore les champs non autorisés du payload (mass assignment)', async () => {
-    const {strapi, paroleDocuments} = buildStrapi({dbUser, artiste})
-    const controller = createController({strapi})
+    const {strapi, paroleDocuments} = buildStrapi({dbUser, artiste});
+    const controller = createController({strapi});
     const ctx = buildCtx({
       documentId: 'doc-1',
       titre: 'Nouveau titre',
@@ -152,9 +152,9 @@ describe('parole.update', () => {
       artistes: [9],
       userAdmin: {id: 999},
       user: {id: 999}
-    })
+    });
 
-    await controller.update(ctx)
+    await controller.update(ctx);
 
     expect(paroleDocuments.update).toHaveBeenCalledWith({
       documentId: 'doc-1',
@@ -165,6 +165,6 @@ describe('parole.update', () => {
         traductionAuto: true,
         artistes: [9]
       }
-    })
-  })
-})
+    });
+  });
+});

src/api/parole/controllers/parole.js

@@ -2,29 +2,29 @@
 
 const { createCoreController } = require('@strapi/strapi').factories;
 
-const VALID_LANGS = new Set(['fr', 'en', 'es', 'de', 'it'])
+const VALID_LANGS = new Set(['fr', 'en', 'es', 'de', 'it']);
 
 module.exports = createCoreController('api::parole.parole', ({strapi}) => ({
   async export(ctx) {
-    const { type = 'pairs', lang, format = 'jsonl' } = ctx.query
+    const { type = 'pairs', lang, format = 'jsonl' } = ctx.query;
 
     const langs = lang
       ? lang.split(',').map(l => l.trim()).filter(l => VALID_LANGS.has(l))
-      : null
+      : null;
 
     if (lang && (!langs || langs.length === 0)) {
-      return ctx.badRequest('Langue(s) invalide(s). Valeurs acceptées : fr, en, es, de, it.')
+      return ctx.badRequest('Langue(s) invalide(s). Valeurs acceptées : fr, en, es, de, it.');
     }
 
     if (!['pairs', 'instruct'].includes(type)) {
-      return ctx.badRequest('type invalide. Valeurs acceptées : pairs, instruct.')
+      return ctx.badRequest('type invalide. Valeurs acceptées : pairs, instruct.');
     }
 
-    const paroles = await strapi.service('api::parole.parole').fetchAllParoles()
-    const { metadata, pairs } = strapi.service('api::parole.parole').buildExport(paroles, type, langs)
+    const paroles = await strapi.service('api::parole.parole').fetchAllParoles();
+    const { metadata, pairs } = strapi.service('api::parole.parole').buildExport(paroles, type, langs);
 
     if (format === 'json') {
-      return ctx.send({ metadata, data: pairs })
+      return ctx.send({ metadata, data: pairs });
     }
 
     // JSONL : première ligne = métadonnées, suivies des exemples d'entraînement.
@@ -32,30 +32,30 @@ module.exports = createCoreController('api::parole.parole', ({strapi}) => ({
     const lines = [
       JSON.stringify({ _metadata: true, ...metadata }),
       ...pairs.map(p => JSON.stringify(p)),
-    ]
+    ];
 
-    ctx.set('Content-Type', 'application/x-ndjson')
-    ctx.set('Content-Disposition', `attachment; filename="pawol-nu-export-${Date.now()}.jsonl"`)
-    ctx.body = lines.join('\n')
+    ctx.set('Content-Type', 'application/x-ndjson');
+    ctx.set('Content-Disposition', `attachment; filename="pawol-nu-export-${Date.now()}.jsonl"`);
+    ctx.body = lines.join('\n');
   },
 
   async bulkTranslate(ctx) {
-    const result = await strapi.service('api::parole.parole').bulkTranslateMissing()
-    return ctx.send(result)
+    const result = await strapi.service('api::parole.parole').bulkTranslateMissing();
+    return ctx.send(result);
   },
 
   async findOne(ctx) {
-    const {id: documentId} = ctx.params
+    const {id: documentId} = ctx.params;
     const parole = await strapi.documents('api::parole.parole').findOne({
       documentId,
       populate: ['artistes']
-    })
+    });
 
-    return parole
+    return parole;
   },
   async update(ctx) {
-    const {body} = ctx.request
-    const {data} = body
+    const {body} = ctx.request;
+    const {data} = body;
 
     const updatedParole = await strapi.documents('api::parole.parole').update({
       documentId: data.documentId,
@@ -67,38 +67,38 @@ module.exports = createCoreController('api::parole.parole', ({strapi}) => ({
         traductionAuto: data.traductionAuto,
         artistes: data.artistes
       }
-    })
+    });
 
-    return updatedParole
+    return updatedParole;
   },
   async create(ctx) {
-    const {body} = ctx.request
-    const {data} = body
+    const {body} = ctx.request;
+    const {data} = body;
 
     if (!data?.user?.documentId || !data?.artistes?.[0]?.documentId) {
-      return ctx.badRequest('Informations manquantes.')
+      return ctx.badRequest('Informations manquantes.');
     }
 
-    strapi.service('api::parole.parole').validateParoles(data.titre, data.transcription)
+    strapi.service('api::parole.parole').validateParoles(data.titre, data.transcription);
 
     const user = await strapi.documents('plugin::users-permissions.user').findOne({
       documentId: body.data.user.documentId
-    })
+    });
 
     if (!user) {
-      return ctx.notFound('Utilisateur introuvable.')
+      return ctx.notFound('Utilisateur introuvable.');
     }
 
     if (user.id !== data.user.id || user.username !== data.user.username || user.email !== data.user.email) {
-      return ctx.badRequest('Informations non valides.')
+      return ctx.badRequest('Informations non valides.');
     }
 
     const artiste = await strapi.documents('api::artiste.artiste').findOne({
       documentId: data.artistes[0].documentId
-    })
+    });
 
     if (!artiste) {
-      return ctx.notFound('Artiste introuvable.')
+      return ctx.notFound('Artiste introuvable.');
     }
 
     const currentUserParole = await strapi.documents('api::parole.parole').findMany({
@@ -113,12 +113,12 @@ module.exports = createCoreController('api::parole.parole', ({strapi}) => ({
           $eq: null
         }
       }
-    })
+    });
 
 
     if (user && user.canAutoTranslate && data.traductionAuto && data.traductions.francais && (!data.traductions.anglais || !data.traductions.espagnol || !data.traductions.allemand || !data.traductions.italien)) {
-      const translated = await strapi.service('api::parole.parole').translateLyrics(data.traductions.francais)
-      data.traductions = translated
+      const translated = await strapi.service('api::parole.parole').translateLyrics(data.traductions.francais);
+      data.traductions = translated;
     }
 
     const newParole = await strapi.documents('api::parole.parole').create({
@@ -130,10 +130,10 @@ module.exports = createCoreController('api::parole.parole', ({strapi}) => ({
         artistes: [artiste.id],
         user: user.id
       }
-    })
+    });
 
-    const parolesIds = currentUserParole.map(({id}) => id)
-    parolesIds.push(newParole.id)
+    const parolesIds = currentUserParole.map(({id}) => id);
+    parolesIds.push(newParole.id);
 
     await strapi.documents('plugin::users-permissions.user').update({
       documentId: user.documentId,
@@ -141,8 +141,8 @@ module.exports = createCoreController('api::parole.parole', ({strapi}) => ({
       data: {
         paroles: parolesIds
       }
-    })
+    });
 
-    return newParole
+    return newParole;
   }
-}))
+}));