Export Web/SCORM : corrige la résolution des champs "relation" hors ligne

Bug signalé : une Donnée liée/un filtre référençant un champ "relation"
affichait "{{champ}}" tel quel une fois exporté, alors qu'il fonctionnait
en ligne. Deux causes cumulées :

- full_game_payload.py lisait la colonne SQL "<champ>" au lieu de
  "<champ>_id" (seule vraie colonne d'un champ relation, voir
  _field_column dans filter_repeater_rows.py) en construisant
  gameData.data — une valeur toujours None. Invisible en ligne (les
  filtres y requêtent la base fraîche, jamais cette snapshot), mais
  fatal hors ligne (aucune base à requêter).
- Une fois ce None corrigé, le port JS (forgeFieldColumn) relisait
  cette même valeur sous une clé slugifiée+suffixée ("boss_id") alors
  que gameData.data est déjà indexé par le nom D'AFFICHAGE du champ
  ("boss") — mismatch qui ne se voyait que sur un champ relation (le
  seul cas où slugify(nom)+suffixe diverge du nom original). Supprime
  ce port erroné, lit directement row[fieldName] partout.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

static/js/play/offline/__tests__/filter-repeater-rows.test.js

@@ -5,8 +5,8 @@ const test = require('node:test');
 const assert = require('node:assert/strict');
 
 const {
-  forgeDecodeClauses, forgeResolveVariablePath, forgeFieldColumn, forgeSlugifyFieldName,
-  forgeResolveFilterValue, forgeFilterRowsByClauses, forgeFilterRepeaterRows,
+  forgeDecodeClauses, forgeResolveVariablePath,
+  forgeResolveFilterValue, forgeClauseMatches, forgeFilterRowsByClauses, forgeFilterRepeaterRows,
 } = require('../filter-repeater-rows.js');
 
 function baseGameData() {
@@ -17,11 +17,15 @@ function baseGameData() {
     },
     definition_names: { '1': 'Progression', '2': 'Ennemis' },
     fields_meta: {
+      // "boss" (relation) : gameData.data (voir full_game_payload.py) est
+      // déjà indexé par le nom D'AFFICHAGE du champ ("boss"), JAMAIS par sa
+      // colonne SQL réelle ("boss_id") — contrairement à côté serveur
+      // (filter_repeater_rows.py::_field_column), qui lit la base fraîche.
       '1': [{ name: 'niveau_actuel', type: 'nombre_entier' }, { name: 'boss', type: 'relation' }],
       '2': [{ name: 'nom', type: 'texte' }, { name: 'pv', type: 'nombre_entier' }],
     },
     data: {
-      '1': [{ id: 1, niveau_actuel: 4, boss_id: 7 }],
+      '1': [{ id: 1, niveau_actuel: 4, boss: 7 }],
       '2': [
         { id: 1, nom: 'Slime', pv: 10 },
         { id: 2, nom: 'Dragon', pv: 100 },
@@ -30,15 +34,21 @@ function baseGameData() {
   };
 }
 
-test('forgeSlugifyFieldName correspond à db.slugify(...).replace("-","_")', () => {
-  assert.equal(forgeSlugifyFieldName('Nom Complet'), 'nom_complet');
-  assert.equal(forgeSlugifyFieldName('Âge (ans)'), 'ge_ans');
+// Régression signalée par un utilisateur : un filtre/une Donnée liée sur
+// un champ "relation" ne matchait jamais rien une fois exporté (le port
+// hors ligne lisait à tort row[nom_slugifié + "_id"], une clé qui n'existe
+// pas dans gameData.data), laissant "{{champ}}" affiché tel quel au lieu
+// de la valeur résolue.
+test('forgeClauseMatches — un champ "relation" se lit directement par son nom (pas de colonne SQL à reconstruire)', () => {
+  const gd = baseGameData();
+  const row = gd.data['1'][0];
+  const clause = { champ: 'boss', operateur: 'egal', valeur: '7' };
+  assert.equal(forgeClauseMatches(gd, '1', row, clause), true);
 });
 
-test('forgeFieldColumn ajoute _id pour un champ relation', () => {
-  const fields = [{ name: 'boss', type: 'relation' }, { name: 'nom', type: 'texte' }];
-  assert.equal(forgeFieldColumn(fields, 'boss'), 'boss_id');
-  assert.equal(forgeFieldColumn(fields, 'nom'), 'nom');
+test('forgeResolveFilterValue — {{Objet.champ}} sur un champ "relation"', () => {
+  const gd = baseGameData();
+  assert.equal(forgeResolveFilterValue(gd, '{{Progression.boss}}'), 7);
 });
 
 test('forgeResolveVariablePath — chemin objet/tableau, chemin vide, JSON invalide', () => {

static/js/play/offline/filter-repeater-rows.js

@@ -65,22 +65,19 @@ function forgeResolveVariablePath(rawValue, path) {
   return current;
 }
 
-// Port de _field_column — un champ "relation" vit dans une colonne
-// "<champ>_id" (voir screens/data_actions/apply_data_action.py) ; le
-// payload hors ligne (gameData.fields_meta) indexe déjà les lignes par le
-// nom SLUGIFIÉ du champ (voir full_game_payload.py), jamais par son nom
-// affiché — slugifyLike() reproduit db.slugify()+replace("-","_").
-function forgeSlugifyFieldName(name) {
-  return String(name).trim().toLowerCase()
-    .replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").replace(/-/g, "_") || "jeu";
-}
-
-function forgeFieldColumn(fieldsMetaForDef, fieldName) {
-  var col = forgeSlugifyFieldName(fieldName);
-  var field = (fieldsMetaForDef || []).find(function (f) { return f.name === fieldName; });
-  if (field && field.type === "relation") col += "_id";
-  return col;
-}
+// PAS d'équivalent JS de _field_column (screens/rendering/
+// filter_repeater_rows.py) : côté serveur, cette fonction traduit un nom
+// de champ vers la VRAIE colonne SQL ("<champ>_id" pour une relation),
+// nécessaire puisque _resolve_filter_value/_clause_matches lisent la base
+// FRAÎCHE à chaque appel (SELECT * -> colonnes réelles). Hors ligne, il
+// n'y a AUCUNE base à requêter : gameData.data (voir full_game_payload.py,
+// `{fname: r.get(col) ...}`) est déjà ré-indexé par le nom D'AFFICHAGE du
+// champ, PAS par sa colonne SQL — donc `row[fieldName]` suffit partout ici
+// (une ancienne version de ce fichier appelait à tort une slugification
+// ici, un bug jamais visible en ligne mais qui rendait tout champ
+// "relation" illisible une fois exporté : le filtre/la Donnée liée
+// correspondants ne matchaient jamais rien, laissant "{{champ}}" affiché
+// tel quel — bug signalé par un utilisateur).
 
 // Port de _resolve_filter_value — {{Objet.champ}} (ligne la plus récente
 // d'un AUTRE objet, convention "1 objet = 1 ligne = état de partie") ou
@@ -106,8 +103,7 @@ function forgeResolveFilterValue(gameData, rawValue) {
     if (names[defId] === objectName) {
       var rows = gameData.data && gameData.data[defId];
       if (rows && rows.length) {
-        var col = forgeFieldColumn(gameData.fields_meta && gameData.fields_meta[defId], fieldName);
-        return rows[0][col];
+        return rows[0][fieldName];
       }
       return null;
     }
@@ -124,8 +120,7 @@ function forgeClauseMatches(gameData, definitionId, row, clause) {
   var fieldsMetaForDef = gameData.fields_meta && gameData.fields_meta[definitionId];
   var field = (fieldsMetaForDef || []).find(function (f) { return f.name === fieldName; });
   var fieldType = field ? field.type : "texte";
-  var col = forgeFieldColumn(fieldsMetaForDef, fieldName);
-  return compareValues(row[col], operator, expected, fieldType);
+  return compareValues(row[fieldName], operator, expected, fieldType);
 }
 
 // Port de filter_rows_by_clauses.
@@ -151,7 +146,7 @@ function forgeFilterRepeaterRows(gameData, definitionId, rows, attrs) {
 
 if (typeof module !== 'undefined' && module.exports) {
   module.exports = {
-    forgeDecodeClauses, forgeResolveVariablePath, forgeFieldColumn, forgeSlugifyFieldName,
+    forgeDecodeClauses, forgeResolveVariablePath,
     forgeResolveFilterValue, forgeClauseMatches, forgeFilterRowsByClauses, forgeFilterRepeaterRows,
   };
   global.compareValues = global.compareValues || require('../conditions.js').compareValues;

static/js/play/offline/render-element.js

@@ -173,7 +173,10 @@ function forgeResolveBoundRowCtx(gameData, attrs) {
   var row = rows[0];
   var ctx = {};
   fieldsMetaForDef.forEach(function (f) {
-    var v = row[forgeFieldColumn(fieldsMetaForDef, f.name)];
+    // row[f.name] : gameData.data est déjà indexé par le nom D'AFFICHAGE
+    // du champ (voir full_game_payload.py), jamais par sa colonne SQL —
+    // voir filter-repeater-rows.js pour le détail de ce piège.
+    var v = row[f.name];
     ctx[f.name] = (v === null || v === undefined || v === "") ? "" : String(v);
   });
   return ctx;
@@ -319,7 +322,6 @@ if (typeof module !== 'undefined' && module.exports) {
   var filterMod = require('./filter-repeater-rows.js');
   global.forgeResolveFilterValue = global.forgeResolveFilterValue || filterMod.forgeResolveFilterValue;
   global.forgeResolveVariablePath = global.forgeResolveVariablePath || filterMod.forgeResolveVariablePath;
-  global.forgeFieldColumn = global.forgeFieldColumn || filterMod.forgeFieldColumn;
   global.forgeDecodeClauses = global.forgeDecodeClauses || filterMod.forgeDecodeClauses;
   global.forgeFilterRowsByClauses = global.forgeFilterRowsByClauses || filterMod.forgeFilterRowsByClauses;
   global.compareValues = global.compareValues || require('../conditions.js').compareValues;

static/js/play/offline/render-repeater.js

@@ -25,8 +25,6 @@ function forgeRenderRepeater(el, meta, gameData, childrenMap, ctx, parentFlexDir
 
   var rows = gameData.data[definitionId] || [];
   rows = forgeFilterRepeaterRows(gameData, definitionId, rows, attrsRaw);
-  var fieldCols = {};
-  fieldsMetaForDef.forEach(function (f) { fieldCols[f.name] = forgeFieldColumn(fieldsMetaForDef, f.name); });
 
   var templateTree = null;
   if (templateTypeId) {
@@ -35,9 +33,13 @@ function forgeRenderRepeater(el, meta, gameData, childrenMap, ctx, parentFlexDir
 
   var items = rows.map(function (row) {
     var rowCtx = Object.assign({}, ctx || {});
-    Object.keys(fieldCols).forEach(function (fname) {
-      var v = row[fieldCols[fname]];
-      rowCtx[fname] = v === null || v === undefined ? "" : String(v);
+    // gameData.data est déjà indexé par le nom D'AFFICHAGE du champ (voir
+    // full_game_payload.py), jamais par sa colonne SQL — row[f.name] lit
+    // donc directement la bonne valeur, y compris pour un champ "relation"
+    // (voir filter-repeater-rows.js pour le détail de ce piège).
+    fieldsMetaForDef.forEach(function (f) {
+      var v = row[f.name];
+      rowCtx[f.name] = v === null || v === undefined ? "" : String(v);
     });
     var inner;
     if (templateTree) {
@@ -73,5 +75,4 @@ if (typeof module !== 'undefined' && module.exports) {
   });
   var filterMod = require('./filter-repeater-rows.js');
   global.forgeFilterRepeaterRows = global.forgeFilterRepeaterRows || filterMod.forgeFilterRepeaterRows;
-  global.forgeFieldColumn = global.forgeFieldColumn || filterMod.forgeFieldColumn;
 }

static/js/play/offline/visibility-condition.js

@@ -1,8 +1,8 @@
 // Export Web/SCORM (voir le plan "port complet du runtime jouable côté
 // navigateur") — port de screens/rendering/visibility_condition.py
 // (is_element_visible). Réutilise forgeResolveFilterValue/
-// forgeResolveVariablePath/forgeFieldColumn (filter-repeater-rows.js) et
-// compareValues (conditions.js), chargés avant ce fichier.
+// forgeResolveVariablePath (filter-repeater-rows.js) et compareValues
+// (conditions.js), chargés avant ce fichier.
 //
 // `ctx` : les {{champ}} de la ligne en cours quand cet élément est
 // descendant d'un Répéteur (voir render-element.js) — en mode "objet", si
@@ -43,7 +43,9 @@ function forgeIsElementVisibleOffline(gameData, attrs, ctx) {
   var rows = gameData.data && gameData.data[definitionId];
   if (!rows || !rows.length) return true; // objet sans donnée pour l'instant : ne bloque pas
   var row = rows[0]; // convention "état de partie" : une seule ligne
-  return compareValues(row[forgeFieldColumn(fieldsMetaForDef, fieldName)], operator, expected, fieldType);
+  // row[fieldName] : gameData.data est déjà indexé par le nom D'AFFICHAGE
+  // du champ (voir full_game_payload.py), jamais par sa colonne SQL.
+  return compareValues(row[fieldName], operator, expected, fieldType);
 }
 
 if (typeof module !== 'undefined' && module.exports) {
@@ -51,6 +53,5 @@ if (typeof module !== 'undefined' && module.exports) {
   var filterMod = require('./filter-repeater-rows.js');
   global.forgeResolveFilterValue = global.forgeResolveFilterValue || filterMod.forgeResolveFilterValue;
   global.forgeResolveVariablePath = global.forgeResolveVariablePath || filterMod.forgeResolveVariablePath;
-  global.forgeFieldColumn = global.forgeFieldColumn || filterMod.forgeFieldColumn;
   global.compareValues = global.compareValues || require('../conditions.js').compareValues;
 }