@silvestv/migration-planificator 3.0.0 → 4.1.0

package/dist/src/core/ast/matchers/html/html-pipe-variable-matcher.js

@@ -0,0 +1,250 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.matchesHtmlPipeVariable = matchesHtmlPipeVariable;
+const ts_morph_1 = require("ts-morph");
+const html_parser_1 = require("./html-parser");
+const html_variable_resolver_1 = require("./html-variable-resolver");
+const rxjs_matcher_1 = require("../ts/rxjs-matcher");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+/**
+ * Extrait le contenu du template d'un @Component (inline ou externe)
+ * Supporte les fichiers in-memory (ts-morph) et les fichiers réels (fs)
+ */
+function getTemplateContent(componentNode) {
+    if (!ts_morph_1.Node.isDecorator(componentNode)) {
+        return null;
+    }
+    const expression = componentNode.getExpression();
+    if (!ts_morph_1.Node.isCallExpression(expression)) {
+        return null;
+    }
+    const args = expression.getArguments();
+    if (args.length === 0) {
+        return null;
+    }
+    const configObject = args[0];
+    if (!ts_morph_1.Node.isObjectLiteralExpression(configObject)) {
+        return null;
+    }
+    // Cas 1: Template inline
+    const templateProperty = configObject.getProperty('template');
+    if (templateProperty && ts_morph_1.Node.isPropertyAssignment(templateProperty)) {
+        const templateValue = templateProperty.getInitializer();
+        if (templateValue) {
+            return templateValue.getText().replace(/[`'"]/g, '');
+        }
+    }
+    // Cas 2: Template externe (templateUrl)
+    const templateUrlProperty = configObject.getProperty('templateUrl');
+    if (templateUrlProperty && ts_morph_1.Node.isPropertyAssignment(templateUrlProperty)) {
+        const templateUrlValue = templateUrlProperty.getInitializer();
+        if (!templateUrlValue) {
+            return null;
+        }
+        const templateUrl = templateUrlValue.getText().replace(/[`'"]/g, '');
+        const sourceFile = componentNode.getSourceFile();
+        const project = sourceFile.getProject();
+        const fileSystem = project.getFileSystem();
+        const tsFilePath = sourceFile.getFilePath();
+        const tsDir = path.dirname(tsFilePath);
+        // APPROCHE 1: Essayer de lire depuis le file system de ts-morph (in-memory ou réel)
+        try {
+            // Essayer plusieurs variantes du chemin
+            // IMPORTANT: Pour in-memory file system, les chemins doivent correspondre exactement
+            const resolvedPath = path.resolve(tsDir, templateUrl);
+            const joinedPath = path.join(tsDir, templateUrl);
+            // Normaliser les chemins pour Windows (utiliser /)
+            const pathsToTry = [
+                templateUrl.replace(/^\.\//, '/'), // './test.html' → '/test.html'
+                resolvedPath,
+                resolvedPath.replace(/\\/g, '/'),
+                joinedPath,
+                joinedPath.replace(/\\/g, '/'),
+                templateUrl,
+            ];
+            for (const tryPath of pathsToTry) {
+                if (fileSystem.fileExistsSync(tryPath)) {
+                    return fileSystem.readFileSync(tryPath, 'utf-8');
+                }
+            }
+        }
+        catch (error) {
+            // Continue vers approche 2
+        }
+        // APPROCHE 2: Essayer de récupérer comme SourceFile (pour templates TypeScript)
+        const htmlFilePath = path.resolve(tsDir, templateUrl);
+        let htmlSourceFile = project.getSourceFile(htmlFilePath);
+        if (!htmlSourceFile) {
+            htmlSourceFile = project.getSourceFile(htmlFilePath.replace(/\\/g, '/'));
+        }
+        if (htmlSourceFile) {
+            return htmlSourceFile.getFullText();
+        }
+        // APPROCHE 3: Fallback sur fs réel (si pas in-memory)
+        try {
+            if (fs.existsSync(htmlFilePath)) {
+                return fs.readFileSync(htmlFilePath, 'utf-8');
+            }
+        }
+        catch (error) {
+            return null;
+        }
+    }
+    return null;
+}
+/**
+ * Trouve toutes les expressions de pipes dans un template HTML
+ * @param htmlContent Contenu du template
+ * @param pipeName Nom de la pipe à rechercher (ex: "async")
+ * @returns Liste des expressions de pipe trouvées
+ */
+function findPipeExpressions(htmlContent, pipeName) {
+    const pipeExpressions = [];
+    // Parser le template HTML
+    const ast = (0, html_parser_1.parseHtmlTemplate)(htmlContent);
+    // Pattern factice pour utiliser traversePipeExpression
+    const pattern = { nodeType: 'PipeExpression', pipeName };
+    // Parcourir l'AST pour trouver les pipes
+    function traverse(nodes) {
+        for (const node of nodes) {
+            // Vérifier les expressions liées (BoundText, BoundAttribute, etc.)
+            if ('value' in node && node.value) {
+                const value = node.value;
+                const astNode = value.ast || value;
+                // Parcourir l'expression pour trouver les BindingPipe
+                traverseForBindingPipe(astNode);
+            }
+            // Vérifier les templates (structural directives: *ngFor, *ngIf, etc.)
+            // Les bindings sont dans node.templateAttrs (ex: ngForOf pour *ngFor)
+            if ('templateAttrs' in node && Array.isArray(node.templateAttrs)) {
+                for (const attr of node.templateAttrs) {
+                    if (attr.value) {
+                        const astNode = attr.value.ast || attr.value;
+                        traverseForBindingPipe(astNode);
+                    }
+                }
+            }
+            // Parcourir les enfants
+            if ('children' in node && Array.isArray(node.children)) {
+                traverse(node.children);
+            }
+            // Parcourir les branches (@if, @else)
+            if ('branches' in node && Array.isArray(node.branches)) {
+                for (const branch of node.branches) {
+                    if (branch.children)
+                        traverse(branch.children);
+                }
+            }
+            // Parcourir les cases (@switch, @case)
+            if ('cases' in node && Array.isArray(node.cases)) {
+                for (const caseNode of node.cases) {
+                    if (caseNode.children)
+                        traverse(caseNode.children);
+                }
+            }
+            // Parcourir @defer blocks
+            const deferBlocks = ['mainBlock', 'placeholder', 'loading', 'error', 'empty'];
+            for (const blockName of deferBlocks) {
+                if (blockName in node && node[blockName]?.children) {
+                    traverse(node[blockName].children);
+                }
+            }
+        }
+    }
+    function traverseForBindingPipe(expr) {
+        if (!expr)
+            return;
+        // Si c'est un BindingPipe avec le bon nom, l'ajouter
+        if (expr.constructor?.name === 'BindingPipe' && expr.name === pipeName) {
+            pipeExpressions.push(expr);
+        }
+        // Parcourir récursivement
+        if (expr.exp)
+            traverseForBindingPipe(expr.exp);
+        if (expr.expressions && Array.isArray(expr.expressions)) {
+            expr.expressions.forEach(traverseForBindingPipe);
+        }
+        if (expr.args && Array.isArray(expr.args)) {
+            expr.args.forEach(traverseForBindingPipe);
+        }
+    }
+    traverse(ast);
+    return pipeExpressions;
+}
+/**
+ * Vérifie si un @Component contient des pipes HTML dont les variables TS
+ * n'ont PAS de gestion d'erreur RxJS
+ *
+ * @param componentNode Nœud Decorator @Component
+ * @param pattern Pattern de vérification
+ * @returns true si au moins une variable sans gestion d'erreur est trouvée
+ */
+function matchesHtmlPipeVariable(componentNode, pattern) {
+    // Vérifier que c'est bien un @Component
+    if (!ts_morph_1.Node.isDecorator(componentNode)) {
+        return false;
+    }
+    // Extraire le template
+    const templateContent = getTemplateContent(componentNode);
+    if (!templateContent) {
+        return false;
+    }
+    // Trouver toutes les expressions avec la pipe spécifiée
+    const pipeExpressions = findPipeExpressions(templateContent, pattern.pipeName);
+    if (pipeExpressions.length === 0) {
+        return false;
+    }
+    // Pour chaque pipe expression, vérifier la gestion d'erreur
+    const operators = pattern.resolvedProperty.missingRxjsOperators || [];
+    for (const pipeExpr of pipeExpressions) {
+        // Résoudre la variable HTML vers la PropertyDeclaration TS
+        const propertyDeclaration = (0, html_variable_resolver_1.resolveVariableFromHtmlPipe)(componentNode, pipeExpr);
+        // Si on ne peut pas résoudre la variable, on ne peut pas vérifier
+        // (skip ce cas, car il peut s'agir d'une variable locale, etc.)
+        if (!propertyDeclaration) {
+            continue;
+        }
+        // Vérifier si la propriété a une gestion d'erreur
+        const hasError = (0, rxjs_matcher_1.hasErrorHandling)(propertyDeclaration, operators);
+        // Si AUCUNE gestion d'erreur trouvée, c'est un match !
+        if (!hasError) {
+            return true;
+        }
+    }
+    // Toutes les variables ont une gestion d'erreur, pas de match
+    return false;
+}

package/dist/src/core/ast/matchers/html/html-variable-resolver.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractVariableNameFromPipe = extractVariableNameFromPipe;
+exports.resolveVariableFromComponent = resolveVariableFromComponent;
+exports.resolveVariableFromHtmlPipe = resolveVariableFromHtmlPipe;
+const ts_morph_1 = require("ts-morph");
+/**
+ * Extrait le nom de variable depuis une expression de pipe HTML
+ * Exemples:
+ *   "data$ | async" → "data$"
+ *   "users | filter: 'active' | async" → "users"
+ *   "product?.name | uppercase" → "product"
+ */
+function extractVariableNameFromPipe(pipeExpression) {
+    if (!pipeExpression || !pipeExpression.exp) {
+        return null;
+    }
+    // Naviguer vers l'expression de base (avant le premier pipe)
+    let baseExpr = pipeExpression.exp;
+    // Si c'est une chaîne de pipes, remonter jusqu'à l'expression originale
+    while (baseExpr && baseExpr.exp && baseExpr.constructor?.name === 'BindingPipe') {
+        baseExpr = baseExpr.exp;
+    }
+    // Cas 1: PropertyRead (ex: data$, users)
+    if (baseExpr.constructor?.name === 'PropertyRead') {
+        return baseExpr.name || null;
+    }
+    // Cas 2: SafePropertyRead (ex: product?.name)
+    if (baseExpr.constructor?.name === 'SafePropertyRead') {
+        // On veut uniquement la première propriété (product, pas product.name)
+        if (baseExpr.receiver && baseExpr.receiver.name) {
+            return baseExpr.receiver.name;
+        }
+        return baseExpr.name || null;
+    }
+    // Cas 3: ImplicitReceiver (ex: dans *ngIf="data$ | async as data")
+    if (baseExpr.constructor?.name === 'ImplicitReceiver') {
+        return null;
+    }
+    // Cas 4: Autres types d'expressions (LiteralPrimitive, etc.)
+    // Pas de variable à résoudre
+    return null;
+}
+/**
+ * Trouve la ClassDeclaration d'un nœud @Component
+ * @param componentDecorator Nœud Decorator avec name="Component"
+ * @returns ClassDeclaration ou undefined
+ */
+function findComponentClass(componentDecorator) {
+    if (!ts_morph_1.Node.isDecorator(componentDecorator)) {
+        return undefined;
+    }
+    const parent = componentDecorator.getParent();
+    if (!parent) {
+        return undefined;
+    }
+    // Le parent du Decorator est typiquement la ClassDeclaration
+    if (ts_morph_1.Node.isClassDeclaration(parent)) {
+        return parent;
+    }
+    // Sinon, chercher dans les siblings ou parents proches
+    let current = parent;
+    while (current && !ts_morph_1.Node.isClassDeclaration(current)) {
+        current = current.getParent();
+    }
+    return current;
+}
+/**
+ * Résout un nom de variable HTML vers sa PropertyDeclaration TypeScript
+ * @param componentNode Nœud @Component (Decorator)
+ * @param variableName Nom de la variable extraite du HTML (ex: "data$")
+ * @returns PropertyDeclaration ou undefined
+ */
+function resolveVariableFromComponent(componentNode, variableName) {
+    if (!variableName) {
+        return undefined;
+    }
+    // Trouver la classe du composant
+    const componentClass = findComponentClass(componentNode);
+    if (!componentClass) {
+        return undefined;
+    }
+    // Chercher la propriété avec ce nom
+    const properties = componentClass.getProperties();
+    const matchingProperty = properties.find(prop => {
+        const propName = prop.getName();
+        return propName === variableName;
+    });
+    return matchingProperty;
+}
+/**
+ * Vérifie si une variable HTML utilisée avec une pipe est résolue vers une PropertyDeclaration TS
+ * @param componentNode Nœud @Component
+ * @param pipeExpression Expression de pipe depuis l'AST HTML (@angular/compiler)
+ * @returns PropertyDeclaration ou undefined
+ */
+function resolveVariableFromHtmlPipe(componentNode, pipeExpression) {
+    // Étape 1: Extraire le nom de variable depuis l'expression de pipe
+    const variableName = extractVariableNameFromPipe(pipeExpression);
+    if (!variableName) {
+        return undefined;
+    }
+    // Étape 2: Résoudre vers la PropertyDeclaration
+    return resolveVariableFromComponent(componentNode, variableName);
+}

package/dist/src/core/ast/matchers/index.js

@@ -60,6 +60,7 @@ exports.SymbolMatcher = SymbolMatcher;
 // Import matchers HTML (depuis html/)
 const HtmlMatcher = __importStar(require("./html"));
 exports.HtmlMatcher = HtmlMatcher;
+const html_pipe_variable_matcher_1 = require("./html/html-pipe-variable-matcher");
 /**
  * Fonction principale : vérifie si un nœud correspond à un pattern AST
  * OPTIMISÉ : excludeContext en premier (88% des règles l'utilisent)
@@ -370,6 +371,12 @@ function matchesAstPattern(node, pattern) {
             return false;
         }
     }
+    // Vérifier htmlPipeVariable (résolution HTML pipe → TS variable → RxJS error handling)
+    if (pattern.htmlPipeVariable !== undefined) {
+        if (!(0, html_pipe_variable_matcher_1.matchesHtmlPipeVariable)(node, pattern.htmlPipeVariable)) {
+            return false;
+        }
+    }
     return true;
 }
 // Export des fonctions utilitaires de cache

package/dist/src/core/ast/matchers/ts/hierarchy-matcher.js

@@ -25,7 +25,8 @@ function matchesParent(node, parentPattern, matchesAstPatternFn) {
                 // Vérifier notFunctionName si spécifié
                 if (parentPattern.notFunctionName && ts_morph_1.Node.isCallExpression(current)) {
                     const funcName = current.getExpression().getText().split('.').pop() || '';
-                    if (funcName === parentPattern.notFunctionName) {
+                    const notFunctionNames = (0, matcher_helpers_1.ensureArray)(parentPattern.notFunctionName);
+                    if (notFunctionNames.includes(funcName)) {
                         return false; // Trouvé le pattern à exclure
                     }
                 }

package/dist/src/core/ast/matchers/ts/rxjs-matcher.js

@@ -0,0 +1,128 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasRxjsErrorHandling = hasRxjsErrorHandling;
+exports.hasSubscribeErrorCallback = hasSubscribeErrorCallback;
+exports.hasErrorHandling = hasErrorHandling;
+const ts_morph_1 = require("ts-morph");
+/**
+ * Liste des opérateurs RxJS de gestion d'erreur
+ */
+const RXJS_ERROR_OPERATORS = [
+    'catchError',
+    'retry',
+    'retryWhen',
+    'onErrorResumeNext'
+];
+/**
+ * Cherche les assignations à une propriété dans le constructeur ou autres méthodes
+ * @param propertyNode PropertyDeclaration
+ * @returns Nœuds d'assignation trouvés
+ */
+function findPropertyAssignments(propertyNode) {
+    const propertyName = propertyNode.getName();
+    const classDecl = propertyNode.getParent();
+    if (!ts_morph_1.Node.isClassDeclaration(classDecl)) {
+        return [];
+    }
+    const assignments = [];
+    // Chercher dans le constructeur
+    const constructor = classDecl.getConstructors()[0];
+    if (constructor) {
+        const body = constructor.getBody();
+        if (body) {
+            // Chercher les this.propertyName = ...
+            body.forEachDescendant((node) => {
+                if (ts_morph_1.Node.isBinaryExpression(node)) {
+                    const left = node.getLeft();
+                    // Vérifier si c'est this.propertyName
+                    if (ts_morph_1.Node.isPropertyAccessExpression(left)) {
+                        const expr = left.getExpression();
+                        if (ts_morph_1.Node.isThisExpression(expr) && left.getName() === propertyName) {
+                            assignments.push(node.getRight());
+                        }
+                    }
+                }
+            });
+        }
+    }
+    return assignments;
+}
+/**
+ * Vérifie si une PropertyDeclaration utilise .pipe() avec des opérateurs de gestion d'erreur
+ * @param propertyNode PropertyDeclaration à analyser
+ * @param operators Liste des opérateurs RxJS à rechercher (par défaut: catchError, retry, etc.)
+ * @returns true si au moins un opérateur de gestion d'erreur est trouvé
+ */
+function hasRxjsErrorHandling(propertyNode, operators = RXJS_ERROR_OPERATORS) {
+    // Cas 1: Propriété avec initializer direct (data$ = this.http.get(...).pipe(...))
+    const initializer = propertyNode.getInitializer();
+    const nodesToCheck = initializer ? [initializer] : [];
+    // Cas 2: Propriété assignée dans le constructeur (this.data$ = ...)
+    const assignments = findPropertyAssignments(propertyNode);
+    nodesToCheck.push(...assignments);
+    // Pas d'initializer ni d'assignation trouvée
+    if (nodesToCheck.length === 0) {
+        return false;
+    }
+    // APPROCHE SIMPLE : Vérifier le texte brut pour les opérateurs
+    for (const nodeToCheck of nodesToCheck) {
+        const codeText = nodeToCheck.getText();
+        // Vérifier si le code contient `.pipe(` et un opérateur de gestion d'erreur
+        if (codeText.includes('.pipe(')) {
+            for (const operator of operators) {
+                // Chercher "operator(" dans le code
+                const regex = new RegExp(`\\b${operator}\\s*\\(`);
+                if (regex.test(codeText)) {
+                    return true;
+                }
+            }
+        }
+    }
+    return false;
+}
+/**
+ * Vérifie si une PropertyDeclaration utilise .subscribe() avec un callback d'erreur
+ * @param propertyNode PropertyDeclaration à analyser
+ * @returns true si .subscribe() a un deuxième argument (error callback)
+ */
+function hasSubscribeErrorCallback(propertyNode) {
+    const initializer = propertyNode.getInitializer();
+    if (!initializer) {
+        return false;
+    }
+    // Chercher tous les .subscribe()
+    const callExpressions = initializer.getDescendantsOfKind(ts_morph_1.SyntaxKind.CallExpression);
+    for (const callExpr of callExpressions) {
+        if (!ts_morph_1.Node.isCallExpression(callExpr)) {
+            continue;
+        }
+        const expression = callExpr.getExpression();
+        // Vérifier si c'est .subscribe()
+        if (ts_morph_1.Node.isPropertyAccessExpression(expression) && expression.getName() === 'subscribe') {
+            const args = callExpr.getArguments();
+            // .subscribe(next, error, complete) - au moins 2 arguments
+            if (args.length >= 2) {
+                return true;
+            }
+            // .subscribe({ next, error, complete })
+            if (args.length === 1 && ts_morph_1.Node.isObjectLiteralExpression(args[0])) {
+                const obj = args[0];
+                const errorProp = obj.getProperty('error');
+                if (errorProp) {
+                    return true;
+                }
+            }
+        }
+    }
+    return false;
+}
+/**
+ * Vérifie si une PropertyDeclaration a une gestion d'erreur (RxJS ou subscribe)
+ * @param propertyNode PropertyDeclaration à analyser
+ * @param operators Liste des opérateurs RxJS à rechercher
+ * @returns true si au moins une gestion d'erreur est trouvée
+ */
+function hasErrorHandling(propertyNode, operators = RXJS_ERROR_OPERATORS) {
+    return hasRxjsErrorHandling(propertyNode, operators) ||
+        hasSubscribeErrorCallback(propertyNode);
+}

package/dist/src/core/workload/hierarchy-calculator.js

@@ -104,10 +104,10 @@ function calculateRuleWorkload(rule, matches, targetName, projectInfo) {
         baseOccurrences = occurrences;
         type = occurrences > 0 ? 'combined' : 'special';
         if (fileCount > 0) {
-            const specialMinutes = fileCount * rule.special_workload.bb_time_by_occurrence;
-            logger_1.logger.debug(`   📦 Special workload [${rule.key}]: ${fileCount} fichiers × ${rule.special_workload.bb_time_by_occurrence}min = ${specialMinutes}min`);
+            const specialMinutes = fileCount * rule.special_workload.timePerOccurrence;
+            logger_1.logger.debug(`   📦 Special workload [${rule.key}]: ${fileCount} fichiers × ${rule.special_workload.timePerOccurrence}min = ${specialMinutes}min`);
             totalMinutes += specialMinutes;
-            rule.special_workload.occurrences_found = fileCount;
+            rule.special_workload.occurrencesFound = fileCount;
         }
     }
     const ruleWorkload = {
@@ -121,7 +121,7 @@ function calculateRuleWorkload(rule, matches, targetName, projectInfo) {
     if (specialWorkloadFiles !== undefined) {
         ruleWorkload.specialWorkloadFiles = specialWorkloadFiles;
         ruleWorkload.baseOccurrences = baseOccurrences;
-        ruleWorkload.specialTimePerFile = rule.special_workload?.bb_time_by_occurrence;
+        ruleWorkload.specialTimePerFile = rule.special_workload?.timePerOccurrence;
     }
     return ruleWorkload;
 }

package/dist/src/core/workload/special-workload.js

@@ -60,10 +60,10 @@ function isRootFilePattern(pattern) {
  * FALLBACK : Scanne récursivement les patterns avec wildcard dans targetPath
  */
 function countSpecialWorkloadFiles(targetPath, rule, projectRoot) {
-    if (!rule.special_workload || !rule.special_workload.bb_fileTypes) {
+    if (!rule.special_workload || !rule.special_workload.fileTypes) {
         return 0;
     }
-    const patterns = rule.special_workload.bb_fileTypes;
+    const patterns = rule.special_workload.fileTypes;
     const cacheKey = `${targetPath}::${projectRoot}::${patterns.join(',')}`;
     // Vérifier le cache
     if (specialWorkloadCache.has(cacheKey)) {