@sun-asterisk/impact-analyzer 1.0.4 → 1.0.5

package/core/detectors/database-detector.js

@@ -0,0 +1,702 @@
+/**
+ * Database Impact Detector
+ * Detects database changes using layer-aware method tracking
+ *
+ * Spec: .specify/specs/features/database-impact-detection.md
+ * Implements FR-001 to FR-006
+ */
+
+import path from 'path';
+import { createLogger } from '../utils/logger.js';
+
+export class DatabaseDetector {
+  constructor(methodCallGraph, config) {
+    this.methodCallGraph = methodCallGraph;
+    this.config = config;
+    this.logger = createLogger(config.verbose);
+  }
+
+  /**
+   * Detect database impact from changed files using layer-aware tracking
+   * Implements FR-001 to FR-006 from spec
+   */
+  async detect(changedFiles) {
+    const startTime = Date.now();
+    this.logger.info('\n   🔍 Analyzing database impacts...');
+    this.logger.verbose('DatabaseDetector', `Processing ${changedFiles.length} files`);
+
+    const databaseChanges = {
+      tables: new Map(), // tableName -> { entity, file, operations, fields, isEntityFile, hasRelationChange }
+      entityFiles: new Set(),
+    };
+
+    // Extract changed methods
+    const allChangedMethods = [];
+    for (const changedFile of changedFiles) {
+      // FR-001: Detect entity file changes
+      if (this.isEntityFile(changedFile)) {
+        this.logger.verbose('DatabaseDetector', `Analyzing entity: ${path.basename(changedFile.path)}`);
+        this.analyzeEntityChange(changedFile, databaseChanges);
+      }
+
+      const changedMethods = this.methodCallGraph.getChangedMethods(
+        changedFile.diff || '',
+        changedFile.absolutePath
+      );
+      allChangedMethods.push(...changedMethods);
+      
+      // Also analyze changed code directly for database operations
+      this.analyzeChangedCodeForDatabaseOps(changedFile, databaseChanges);
+    }
+
+    this.logger.verbose('DatabaseDetector', `Found ${allChangedMethods.length} changed methods`);
+
+    // FR-003: Find affected repository methods through call graph
+    const affectedRepoMethods = this.findAffectedRepositoryMethods(allChangedMethods);
+
+    this.logger.verbose('DatabaseDetector', `Found ${affectedRepoMethods.length} affected repository methods`);
+
+    // Analyze repository methods for database operations
+    for (const repoMethod of affectedRepoMethods) {
+      const dbOps = this.extractDatabaseOperationsFromCallGraph(repoMethod);
+      
+      for (const op of dbOps) {
+        if (!databaseChanges.tables.has(op.table)) {
+          databaseChanges.tables.set(op.table, {
+            entity: this.tableNameToEntityName(op.table),
+            file: op.file || repoMethod.file,
+            operations: new Set(),
+            fields: new Set(),
+            isEntityFile: false,
+            hasRelationChange: false,
+            changeSource: { path: repoMethod.file }
+          });
+        }
+
+        const tableData = databaseChanges.tables.get(op.table);
+        tableData.operations.add(op.operation);
+
+        if (op.fields && op.fields.length > 0) {
+          op.fields.forEach(field => tableData.fields.add(field));
+        }
+      }
+    }
+
+    const duration = Date.now() - startTime;
+    this.logger.verbose('DatabaseDetector', `Completed in ${duration}ms`);
+
+    // FR-006: Format according to spec output schema
+    return this.formatDatabaseImpact(databaseChanges);
+  }
+
+  /**
+   * FR-001: Check if file is an entity/model file
+   * Detects TypeORM entities and Sequelize models
+   */
+  isEntityFile(file) {
+    const filePath = file.path.toLowerCase();
+    const content = file.content || '';
+
+    // Check file naming conventions
+    if (filePath.includes('.entity.') || filePath.includes('/entities/') ||
+        filePath.includes('.model.') || filePath.includes('/models/')) {
+      return true;
+    }
+
+    // Check for ORM decorators
+    if (content.includes('@Entity(') || content.includes('@Table(')) {
+      return true;
+    }
+
+    // Check for Model extension
+    if (content.includes('extends Model')) {
+      return true;
+    }
+
+    return false;
+  }
+
+  /**
+   * FR-001: Analyze entity file changes
+   * Extracts table name, detects column changes, relation changes
+   */
+  analyzeEntityChange(changedFile, databaseChanges) {
+    const content = changedFile.content || '';
+    const className = this.extractClassName(content);
+
+    if (!className) {
+      this.logger.verbose('DatabaseDetector', `Could not extract class name from ${changedFile.path}`);
+      return;
+    }
+
+    // FR-002: Extract table name
+    const tableName = this.extractTableNameFromEntity(content, className);
+    this.logger.verbose('DatabaseDetector', `Extracted table name: ${tableName}`);
+
+    // Check for relation changes
+    const hasRelationChange = this.detectRelationChange(changedFile.diff || '');
+
+    if (!databaseChanges.tables.has(tableName)) {
+      databaseChanges.tables.set(tableName, {
+        entity: className,
+        file: changedFile.path,
+        operations: new Set(['SELECT', 'INSERT', 'UPDATE']), // Schema changes affect all ops
+        fields: new Set(),
+        isEntityFile: true,
+        hasRelationChange: hasRelationChange,
+        changeSource: { path: changedFile.path, status: changedFile.status }
+      });
+    } else {
+      const tableData = databaseChanges.tables.get(tableName);
+      tableData.isEntityFile = true;
+      tableData.hasRelationChange = hasRelationChange || tableData.hasRelationChange;
+    }
+
+    // Extract changed fields from diff
+    const changedFields = this.extractChangedFields(changedFile.diff || '');
+    if (changedFields.length > 0) {
+      const tableData = databaseChanges.tables.get(tableName);
+      changedFields.forEach(field => tableData.fields.add(field));
+      this.logger.verbose('DatabaseDetector', `Detected changed fields: ${changedFields.join(', ')}`);
+    }
+
+    databaseChanges.entityFiles.add(changedFile.path);
+  }
+
+  /**
+   * Extract class name from entity file content
+   */
+  extractClassName(content) {
+    // Match: class ClassName or export class ClassName
+    const classMatch = content.match(/(?:export\s+)?class\s+(\w+)/);
+    return classMatch ? classMatch[1] : null;
+  }
+
+  /**
+   * FR-002: Extract table name from entity
+   * Priority: 1. @Entity('name') 2. @Entity({ name: 'name' }) 3. className conversion
+   */
+  extractTableNameFromEntity(content, className) {
+    // Check for explicit table name in @Entity decorator
+    const explicitMatch = content.match(/@Entity\s*\(\s*['"](\w+)['"]/);
+    if (explicitMatch) return explicitMatch[1];
+
+    // Check for options object
+    const optionsMatch = content.match(/@Entity\s*\(\s*\{[^}]*name:\s*['"](\w+)['"]/);
+    if (optionsMatch) return optionsMatch[1];
+
+    // Check for Sequelize @Table
+    const tableMatch = content.match(/@Table\s*\(\s*\{[^}]*tableName:\s*['"](\w+)['"]/);
+    if (tableMatch) return tableMatch[1];
+
+    // Convert class name to snake_case
+    return this.entityToTableName(className);
+  }
+
+  /**
+   * Detect if relation decorators changed
+   */
+  detectRelationChange(diff) {
+    const relationDecorators = [
+      '@OneToMany', '@ManyToOne', '@OneToOne', '@ManyToMany',
+      '@HasMany', '@BelongsTo', '@BelongsToMany'
+    ];
+
+    const addedLines = diff.split('\n').filter(line => line.startsWith('+'));
+
+    for (const line of addedLines) {
+      for (const decorator of relationDecorators) {
+        if (line.includes(decorator)) {
+          return true;
+        }
+      }
+    }
+
+    return false;
+  }
+
+  /**
+   * Extract changed field names from diff
+   */
+  extractChangedFields(diff) {
+    const fields = new Set();
+    const lines = diff.split('\n');
+
+    for (const line of lines) {
+      if (!line.startsWith('+') || line.startsWith('+++')) continue;
+
+      const cleanLine = line.substring(1).trim();
+
+      // Match @Column() decorator followed by field name
+      if (cleanLine.includes('@Column') || cleanLine.includes('@PrimaryColumn')) {
+        // Look for field declaration on same or next line
+        const fieldMatch = cleanLine.match(/(@Column[^;]*)\s+(\w+)\s*[;:]/);
+        if (fieldMatch) {
+          fields.add(fieldMatch[2]);
+        }
+      }
+
+      // Match direct field declarations with type annotation
+      const fieldDeclMatch = cleanLine.match(/^\s*(\w+)\s*[?:]?\s*:/);
+      if (fieldDeclMatch && !cleanLine.includes('function') && !cleanLine.includes('constructor')) {
+        const fieldName = fieldDeclMatch[1];
+        if (fieldName !== 'delFlg') {
+          fields.add(fieldName);
+        }
+      }
+    }
+
+    return Array.from(fields);
+  }
+
+  /**
+   * Convert table name back to entity name
+   */
+  tableNameToEntityName(tableName) {
+    // Convert: user_profile → UserProfile
+    return tableName
+      .split('_')
+      .map(part => part.charAt(0).toUpperCase() + part.slice(1))
+      .join('') + 'Entity';
+  }
+
+  findAffectedRepositoryMethods(changedMethods) {
+    const visited = new Set();
+    const repoMethods = [];
+    const queue = [...changedMethods];
+
+    while (queue.length > 0) {
+      const method = queue.shift();
+      
+      if (!method || !method.file) continue;
+      
+      const key = `${method.file}:${method.className}.${method.methodName}`;
+      if (visited.has(key)) continue;
+      visited.add(key);
+
+      const isRepository = method.file.includes('repository') || 
+                          (method.className && method.className.toLowerCase().includes('repository'));
+      
+      if (isRepository) {
+        repoMethods.push(method);
+      }
+
+      const callers = this.methodCallGraph.getCallers(method);
+      queue.push(...callers);
+    }
+
+    return repoMethods;
+  }
+
+  analyzeChangedCodeForDatabaseOps(changedFile, databaseChanges) {
+    const diff = changedFile.diff || '';
+    const lines = diff.split('\n');
+    
+    const typeOrmOps = {
+      'insert': 'INSERT',
+      'save': 'INSERT/UPDATE',
+      'create': 'INSERT',
+      'update': 'UPDATE',
+      'merge': 'UPDATE',
+      'delete': 'DELETE',
+      'remove': 'DELETE',
+      'softDelete': 'SOFT_DELETE',
+      // SELECT operations
+      'find': 'SELECT',
+      'findOne': 'SELECT',
+      'findBy': 'SELECT',
+      'findOneBy': 'SELECT',
+      'findAndCount': 'SELECT',
+      'select': 'SELECT',
+      'query': 'SELECT',
+      'getMany': 'SELECT',
+      'getOne': 'SELECT',
+    };
+    
+    let inDatabaseOperation = false;
+    let currentEntityName = null;
+    let currentOperation = null;
+    let currentTableName = null;
+    
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      const cleanLine = line.startsWith('+') ? line.substring(1).trim() : line.trim();
+      
+      // Detect start of database operations (even in context lines)
+      for (const [opName, opType] of Object.entries(typeOrmOps)) {
+        if (cleanLine.includes(`.${opName}(`)) {
+          inDatabaseOperation = true;
+          currentOperation = opType;
+          
+          // Extract entity name from the operation
+          const entityName = this.extractEntityFromOperation(cleanLine, lines, i);
+          if (entityName) {
+            currentEntityName = entityName;
+            currentTableName = this.entityToTableName(entityName);
+          }
+          
+          // Also check for repository pattern
+          const repoMatch = cleanLine.match(/(\w+Repository)\.(save|update|insert|create|delete|remove)\(/);
+          if (repoMatch && !currentEntityName) {
+            const repoName = repoMatch[1];
+            currentEntityName = repoName.replace(/Repository$/, '') + 'Entity';
+            currentTableName = this.entityToTableName(currentEntityName);
+          }
+          
+          if (currentTableName) {
+            if (!databaseChanges.tables.has(currentTableName)) {
+              databaseChanges.tables.set(currentTableName, {
+                entity: currentEntityName,
+                file: changedFile.path,
+                operations: new Set(),
+                fields: new Set(),
+                isEntityFile: false,
+                hasRelationChange: false,
+                changeSource: { path: changedFile.path }
+              });
+            }
+
+            const tableData = databaseChanges.tables.get(currentTableName);
+            tableData.operations.add(currentOperation);
+          }
+        }
+      }
+      
+      // When in a database operation context, extract fields from added lines
+      if (inDatabaseOperation && line.startsWith('+') && !line.startsWith('+++')) {
+        const addedLine = line.substring(1).trim();
+        
+        // Extract fields from this added line
+        const fields = this.extractFieldsFromLine(addedLine);
+        
+        if (fields.length > 0 && currentTableName) {
+          const tableData = databaseChanges.tables.get(currentTableName);
+          fields.forEach(field => tableData.fields.add(field));
+          
+          this.logger.verbose('DatabaseDetector', `Detected ${currentOperation} on ${currentTableName} with fields: ${fields.join(', ')}`);
+        }
+      }
+      
+      // Reset context when operation ends
+      if (inDatabaseOperation && cleanLine.includes(');')) {
+        inDatabaseOperation = false;
+        currentEntityName = null;
+        currentOperation = null;
+        currentTableName = null;
+      }
+    }
+  }
+  
+  extractFieldsFromLine(line) {
+    const fields = [];
+    
+    // Match field: value patterns
+    const fieldMatches = line.matchAll(/(\w+)\s*:/g);
+    for (const match of fieldMatches) {
+      const field = match[1];
+      if (field && field !== 'delFlg') {
+        fields.push(field);
+      }
+    }
+    
+    // Also check for spread with new fields pattern: { ...obj, newField: value }
+    if (line.includes('...') && line.includes(':')) {
+      const afterSpread = line.split('...').slice(1).join('...');
+      const newFieldMatches = afterSpread.matchAll(/(\w+)\s*:/g);
+      for (const match of newFieldMatches) {
+        const field = match[1];
+        if (field && field !== 'delFlg' && !fields.includes(field)) {
+          fields.push(field);
+        }
+      }
+    }
+    
+    return fields;
+  }
+  
+  extractEntityFromOperation(line, lines, lineIndex) {
+    // Pattern 1: queryRunner.manager.update(UserEntity, ...)
+    const directEntityMatch = line.match(/\.(update|save|insert|create|delete|remove)\s*\(\s*(\w+Entity)/);
+    if (directEntityMatch) {
+      return directEntityMatch[2];
+    }
+    
+    // Pattern 2: Look forward and backward for entity type
+    for (let i = Math.max(0, lineIndex - 5); i < Math.min(lines.length, lineIndex + 5); i++) {
+      const checkLine = lines[i];
+      if (!checkLine) continue;
+      
+      const cleanCheckLine = checkLine.startsWith('+') || checkLine.startsWith('-') ? 
+        checkLine.substring(1) : checkLine;
+      
+      if (cleanCheckLine.includes('Entity')) {
+        const entityMatch = cleanCheckLine.match(/(\w+Entity)/);
+        if (entityMatch) {
+          return entityMatch[1];
+        }
+      }
+    }
+    
+    return null;
+  }
+  
+  extractFieldsFromOperation(line, lines, lineIndex, operation) {
+    const fields = [];
+    
+    // Extract fields from object literal in current line
+    const objectMatch = line.match(/\{\s*([^}]+)\s*\}/);
+    if (objectMatch) {
+      const content = objectMatch[1];
+      const fieldMatches = content.match(/(\w+):/g);
+      if (fieldMatches) {
+        fieldMatches.forEach(match => {
+          const field = match.replace(':', '').trim();
+          if (field && field !== 'delFlg') {
+            fields.push(field);
+          }
+        });
+      }
+      
+      // Also check for spread operator
+      const spreadMatch = content.match(/\.\.\.(\w+)/);
+      if (spreadMatch) {
+        // Try to find the variable definition
+        const varName = spreadMatch[1];
+        const varFields = this.findVariableFields(varName, lines, lineIndex);
+        fields.push(...varFields);
+      }
+    }
+    
+    // Check if operation continues on next lines (multi-line object)
+    if (line.includes('{') && !line.includes('}')) {
+      for (let i = lineIndex + 1; i < Math.min(lines.length, lineIndex + 10); i++) {
+        const nextLine = lines[i];
+        if (!nextLine || !nextLine.startsWith('+')) break;
+        
+        const cleanNext = nextLine.substring(1).trim();
+        if (cleanNext.includes('}')) break;
+        
+        const fieldMatch = cleanNext.match(/(\w+):/);
+        if (fieldMatch) {
+          const field = fieldMatch[1];
+          if (field && field !== 'delFlg') {
+            fields.push(field);
+          }
+        }
+      }
+    }
+    
+    return [...new Set(fields)];
+  }
+  
+  findVariableFields(varName, lines, currentIndex) {
+    const fields = [];
+    
+    for (let i = Math.max(0, currentIndex - 20); i < currentIndex; i++) {
+      const line = lines[i];
+      if (!line || !line.startsWith('+')) continue;
+      
+      const cleanLine = line.substring(1).trim();
+      
+      // Look for variable declaration
+      if (cleanLine.includes(`${varName}`) && cleanLine.includes('=') && cleanLine.includes('{')) {
+        // Start capturing fields
+        for (let j = i; j < Math.min(lines.length, i + 15); j++) {
+          const varLine = lines[j];
+          if (!varLine || !varLine.startsWith('+')) continue;
+          
+          const cleanVarLine = varLine.substring(1).trim();
+          
+          if (cleanVarLine.includes('}')) break;
+          
+          const fieldMatch = cleanVarLine.match(/(\w+):/);
+          if (fieldMatch) {
+            const field = fieldMatch[1];
+            if (field && field !== 'delFlg') {
+              fields.push(field);
+            }
+          }
+        }
+        break;
+      }
+    }
+    
+    return fields;
+  }
+
+  extractDatabaseOperationsFromCallGraph(repoMethod) {
+    const operations = [];
+    
+    const methodKey = `${repoMethod.className}.${repoMethod.methodName}`;
+    const methodCalls = this.methodCallGraph.methodCallsMap?.get(methodKey) || [];
+    
+    if (this.config.verbose) {
+      console.log(`   📞 Analyzing ${methodCalls.length} calls in ${repoMethod.className}.${repoMethod.methodName}`);
+    }
+    
+    for (const call of methodCalls) {
+      const dbOp = this.detectDatabaseOperationFromCall(call);
+
+      if (dbOp) {
+        operations.push({
+          ...dbOp,
+          method: `${repoMethod.className}.${repoMethod.methodName}`,
+          file: repoMethod.file,
+        });
+      }
+    }
+
+    return operations;
+  }
+   
+  detectDatabaseOperationFromCall(call) {
+    const typeOrmOps = {
+      'insert': 'INSERT',
+      'save': 'INSERT/UPDATE',
+      'create': 'INSERT',
+      'update': 'UPDATE',
+      'merge': 'UPDATE',
+      'delete': 'DELETE',
+      'remove': 'DELETE',
+      'softDelete': 'SOFT_DELETE',
+      // SELECT operations
+      'find': 'SELECT',
+      'findOne': 'SELECT',
+      'findBy': 'SELECT',
+      'findOneBy': 'SELECT',
+      'findAndCount': 'SELECT',
+      'select': 'SELECT',
+      'query': 'SELECT',
+      'getMany': 'SELECT',
+      'getOne': 'SELECT',
+    };
+
+    // Handle both string and object format
+    let methodName, target;
+    
+    if (typeof call === 'string') {
+      // Old format: "ClassName.methodName"
+      const parts = call.split('.');
+      if (parts.length >= 2) {
+        target = parts[0];
+        methodName = parts[1];
+      }
+    } else if (typeof call === 'object') {
+      // New format: { target, method, arguments }
+      methodName = call.method;
+      target = call.target;
+    }
+    
+    if (!methodName || !typeOrmOps[methodName]) return null;
+
+    const entityMatch = target?.match(/(\w+Repository)/);
+    
+    if (!entityMatch) return null;
+
+    const entityName = entityMatch[1].replace(/Repository$/, '') + 'Entity';
+    
+    // Extract fields from arguments if available
+    const fields = [];
+    if (call.arguments && Array.isArray(call.arguments)) {
+      for (const arg of call.arguments) {
+        if (arg.type === 'object' && arg.fields) {
+          fields.push(...arg.fields);
+        }
+      }
+    }
+    
+    return {
+      table: this.entityToTableName(entityName),
+      operation: typeOrmOps[methodName],
+      fields: fields.filter(f => f !== '...' && f !== 'delFlg'),
+    };
+  }
+
+  entityToTableName(entityName) {
+    return entityName
+      .replace(/Entity$/, '')
+      .replace(/([A-Z])/g, '_$1')
+      .toLowerCase()
+      .replace(/^_/, '');
+  }
+
+  /**
+   * FR-006: Format database impact according to spec output schema
+   * Output matches: .specify/specs/features/database-impact-detection.md Section 5
+   *
+   * @returns {DatabaseImpact[]} Array of database impacts matching spec schema
+   */
+  formatDatabaseImpact(databaseChanges) {
+    const impacts = [];
+
+    for (const [tableName, tableData] of databaseChanges.tables.entries()) {
+      const impactType = this.classifyImpactType(tableData);
+
+      const impact = {
+        // Spec-required fields
+        tableName: tableName,
+        modelName: tableData.entity,
+        modelPath: tableData.file,
+        impactType: impactType,
+        operations: Array.from(tableData.operations),
+        changeSource: tableData.changeSource,
+        severity: this.calculateSeverity(tableData, impactType),
+      };
+
+      // Optional field - only include if present
+      if (tableData.fields.size > 0) {
+        impact.fields = Array.from(tableData.fields);
+      }
+
+      impacts.push(impact);
+    }
+
+    return impacts;
+  }
+
+  /**
+   * FR-004: Classify impact type
+   * Categories: 'schema' | 'query' | 'relation' | 'migration'
+   */
+  classifyImpactType(tableData) {
+    // Schema: entity file changed
+    if (tableData.isEntityFile) return 'schema';
+
+    // Relation: relation decorators changed
+    if (tableData.hasRelationChange) return 'relation';
+
+    // Migration: migration file changed
+    if (tableData.file && tableData.file.includes('migration')) return 'migration';
+
+    // Query: repository/service changed
+    return 'query';
+  }
+
+  /**
+   * Calculate severity based on spec Section 6
+   * Critical: Schema changes (columns, constraints)
+   * High: Relation changes, DELETE operations
+   * Medium: INSERT, UPDATE operations
+   * Low: SELECT-only query changes
+   */
+  calculateSeverity(tableData, impactType) {
+    // Critical: Schema changes
+    if (impactType === 'schema') {
+      return 'critical';
+    }
+
+    // High: Relation changes or DELETE operations
+    if (impactType === 'relation' || tableData.operations.has('DELETE') || tableData.operations.has('SOFT_DELETE')) {
+      return 'high';
+    }
+
+    // Medium: INSERT or UPDATE operations
+    if (tableData.operations.has('INSERT') || tableData.operations.has('UPDATE') ||
+        tableData.operations.has('INSERT/UPDATE')) {
+      return 'medium';
+    }
+
+    // Low: SELECT-only
+    return 'low';
+  }
+}