@sun-asterisk/impact-analyzer 1.0.6 → 1.0.8

package/core/utils/method-call-graph.js

@@ -16,6 +16,9 @@ export class MethodCallGraph {
     this.interfaceToClass = new Map(); // interface name -> concrete class name
     this.commandNameToClass = new Map(); // command name -> command handler class
     this.endpointToCommandNames = new Map(); // endpoint method -> [command names]
+    this.queueNameToProcessor = new Map(); // queue name -> processor class name
+    this.methodToQueueProcessor = new Map(); // method -> queue processor info
+    this.endpointToQueueNames = new Map(); // endpoint method -> [queue names]
   }
 
   /**
@@ -41,6 +44,7 @@ export class MethodCallGraph {
     for (const sourceFile of sourceFiles) {
       this.extractInterfaceMappings(sourceFile);
       this.extractCommandMappings(sourceFile);
+      this.extractQueueProcessorMappings(sourceFile);
     }
 
     for (const sourceFile of sourceFiles) {
@@ -63,6 +67,16 @@ export class MethodCallGraph {
       const className = classDecl.getName();
       if (!className) continue; // Skip anonymous classes
 
+      // Check if this class is a queue processor
+      const classDecorators = classDecl.getDecorators();
+      const processorDecorator = classDecorators.find(d => d.getName() === 'Processor');
+      let processorQueueName = null;
+
+      if (processorDecorator) {
+        const args = processorDecorator.getArguments();
+        processorQueueName = args[0]?.getText().replace(/['"]/g, '');
+      }
+
       // Get all methods in this class
       const methods = classDecl.getMethods();
 
@@ -92,13 +106,32 @@ export class MethodCallGraph {
           });
         }
 
+        // Check if this is a queue processor method (has @Process decorator)
+        const processDecorator = decorators.find(d => d.getName() === 'Process');
+        if (processDecorator && processorQueueName) {
+          const args = processDecorator.getArguments();
+          const jobName = args[0]?.getText().replace(/['"]/g, '') || '';
+
+          this.methodToQueueProcessor.set(fullMethodName, {
+            queueName: processorQueueName,
+            jobName: jobName,
+            processor: className,
+            method: methodName,
+            file: filePath,
+          });
+
+          if (this.verbose) {
+            console.log(`   🔄 Found queue processor: ${processorQueueName}${jobName ? `/${jobName}` : ''} → ${fullMethodName}`);
+          }
+        }
+
         // Find all method calls within this method
         this.analyzeMethodCalls(method, className, fullMethodName);
 
-        // If this is an endpoint, detect command dispatches
-        if (httpDecorator) {
-          this.detectCommandDispatches(method, fullMethodName);
-        }
+        // Detect command dispatches and queue jobs in ALL methods (not just endpoints)
+        // This allows us to track: Controller → Service → Queue → Processor
+        this.detectCommandDispatches(method, fullMethodName);
+        this.detectQueueDispatches(method, fullMethodName);
       }
     }
   }
@@ -735,6 +768,16 @@ export class MethodCallGraph {
         affectedEndpoints.push(cmdEndpoint);
       }
 
+      // NEW: Check if changed method is in a Queue Processor
+      const queueEndpoints = this.findEndpointsByQueue(changedMethod);
+      for (const queueEndpoint of queueEndpoints) {
+        const endpointKey = queueEndpoint.endpointMethod || queueEndpoint.path;
+        if (processedMethods.has(endpointKey)) continue;
+        processedMethods.add(endpointKey);
+
+        affectedEndpoints.push(queueEndpoint);
+      }
+
       // NEW: Check if any CALLER is in a Command handler
       // Flow: ServiceB (changed) → ServiceA → Command.run → find endpoint
       for (const caller of callers) {
@@ -749,6 +792,20 @@ export class MethodCallGraph {
 
           affectedEndpoints.push(cmdEndpoint);
         }
+
+        // NEW: Check if any CALLER is in a Queue Processor
+        const callerQueueEndpoints = this.findEndpointsByQueue(caller);
+        for (const queueEndpoint of callerQueueEndpoints) {
+          const endpointKey = queueEndpoint.endpointMethod || queueEndpoint.path;
+          if (processedMethods.has(endpointKey)) continue;
+          processedMethods.add(endpointKey);
+
+          if (this.verbose) {
+            console.log(`      🔗 Caller '${caller}' is in a queue processor`);
+          }
+
+          affectedEndpoints.push(queueEndpoint);
+        }
       }
     }
 
@@ -804,6 +861,87 @@ export class MethodCallGraph {
     return affectedEndpoints;
   }
 
+  /**
+   * Find endpoints that dispatch queue jobs handled by the changed method
+   * Handles two patterns:
+   * 1. Controller → Queue.add() → Processor (direct)
+   * 2. Controller → Service → Queue.add() → Processor (indirect)
+   */
+  findEndpointsByQueue(changedMethod) {
+    const affectedEndpoints = [];
+
+    // Check if this method is a queue processor method
+    const queueProcessorInfo = this.methodToQueueProcessor.get(changedMethod);
+    
+    if (!queueProcessorInfo) {
+      return affectedEndpoints;
+    }
+
+    const { queueName, jobName } = queueProcessorInfo;
+    const queueLabel = jobName ? `${queueName}/${jobName}` : queueName;
+
+    // Find all methods (endpoints OR services) that dispatch to this queue
+    for (const [methodName, queueNames] of this.endpointToQueueNames) {
+      if (queueNames.includes(queueName)) {
+        const endpoint = this.methodToEndpoint.get(methodName);
+
+        if (endpoint) {
+          // Pattern 1: Direct endpoint → queue
+          if (this.verbose) {
+            console.log(`      ✅ Found endpoint via queue (direct): ${endpoint.method} ${endpoint.path}`);
+            console.log(`         Queue chain: ${changedMethod} ← Queue '${queueLabel}' ← ${methodName}`);
+          }
+
+          affectedEndpoints.push({
+            ...endpoint,
+            affectedBy: changedMethod,
+            callChain: [changedMethod, `Queue: '${queueLabel}'`, methodName],
+            layers: [this.getMethodLayer(changedMethod), 'Queue', this.getMethodLayer(methodName)],
+            viaQueue: queueLabel,
+            endpointMethod: methodName,
+            impactLevel: this.calculateImpactLevel([changedMethod, `Queue: '${queueLabel}'`, methodName]),
+          });
+        } else {
+          // Pattern 2: Service method triggers queue, find controllers that call this service
+          // Flow: Processor ← Queue ← Service ← Controller
+          const serviceCallers = this.findAllCallers(methodName);
+          const endpointCallers = this.filterUpToEndpoints(methodName, serviceCallers);
+
+          if (this.verbose && endpointCallers.length > 0) {
+            console.log(`      🔗 Service method '${methodName}' triggers queue '${queueLabel}'`);
+            console.log(`         Finding controllers that call this service...`);
+          }
+
+          for (const endpointCaller of endpointCallers) {
+            const endpointInfo = this.methodToEndpoint.get(endpointCaller);
+            
+            if (endpointInfo) {
+              const callChain = this.getCallChain(methodName, endpointCaller);
+              const fullChain = [changedMethod, `Queue: '${queueLabel}'`, ...callChain];
+
+              if (this.verbose) {
+                console.log(`      ✅ Found endpoint via queue (indirect): ${endpointInfo.method} ${endpointInfo.path}`);
+                console.log(`         Full chain: ${fullChain.join(' → ')}`);
+              }
+
+              affectedEndpoints.push({
+                ...endpointInfo,
+                affectedBy: changedMethod,
+                callChain: fullChain,
+                layers: [this.getMethodLayer(changedMethod), 'Queue', ...this.getCallChainLayers(callChain)],
+                viaQueue: queueLabel,
+                endpointMethod: endpointCaller,
+                impactLevel: this.calculateImpactLevel(fullChain),
+              });
+            }
+          }
+        }
+      }
+    }
+
+    return affectedEndpoints;
+  }
+
   /**
    * Get the layer/tier of a method based on file path and class name
    */
@@ -816,6 +954,7 @@ export class MethodCallGraph {
     
     // Check file path for layer indicators (order matters - most specific first)
     if (lowerPath.includes('/controllers/') || fileName.includes('.controller.')) return 'Controller';
+    if (lowerPath.includes('/processors/') || fileName.includes('.processor.')) return 'QueueProcessor';
     if (lowerPath.includes('/services/') || fileName.includes('.service.')) return 'Service';
     if (lowerPath.includes('/repositories/') || fileName.includes('.repository.')) return 'Repository';
     if (lowerPath.includes('/providers/') || fileName.includes('.provider.')) return 'Provider';
@@ -944,4 +1083,110 @@ export class MethodCallGraph {
     // Longer chain
     return 'low';
   }
+
+  /**
+   * Extract queue name -> processor class mappings from @Processor decorators
+   */
+  extractQueueProcessorMappings(sourceFile) {
+    const classes = sourceFile.getClasses();
+
+    for (const classDecl of classes) {
+      const className = classDecl.getName();
+      if (!className) continue;
+
+      const decorators = classDecl.getDecorators();
+      const processorDecorator = decorators.find(d => d.getName() === 'Processor');
+
+      if (processorDecorator) {
+        const args = processorDecorator.getArguments();
+        if (args.length > 0) {
+          const queueName = args[0].getText().replace(/['"]/g, '');
+          this.queueNameToProcessor.set(queueName, className);
+
+          if (this.verbose) {
+            console.log(`   🔄 Mapped queue processor: '${queueName}' → ${className}`);
+          }
+        }
+      }
+    }
+  }
+
+  /**
+   * Detect queue job dispatches in endpoint methods
+   * Handles patterns like:
+   * - await this.queueName.add('job-name', data)
+   * - await queue.add(data)
+   */
+  detectQueueDispatches(method, fullMethodName) {
+    const callExpressions = method.getDescendantsOfKind(SyntaxKind.CallExpression);
+    const queueNames = [];
+
+    for (const call of callExpressions) {
+      const expression = call.getExpression();
+
+      // Look for .add() method calls
+      if (expression.getKind() === SyntaxKind.PropertyAccessExpression) {
+        const methodName = expression.getName();
+
+        if (methodName === 'add') {
+          // Get the object being called (e.g., 'this.queueName' or 'queue')
+          const objectExpr = expression.getExpression();
+          
+          // Check if it's a property access like 'this.queueName'
+          if (objectExpr.getKind() === SyntaxKind.PropertyAccessExpression) {
+            const queuePropertyName = objectExpr.getName();
+            
+            // Try to find @InjectQueue decorator in constructor
+            const classDecl = method.getParent();
+            if (classDecl && classDecl.getKind() === SyntaxKind.ClassDeclaration) {
+              const constructor = classDecl.getConstructors()[0];
+              if (constructor) {
+                const queueName = this.findQueueNameFromConstructor(constructor, queuePropertyName);
+                if (queueName && !queueNames.includes(queueName)) {
+                  queueNames.push(queueName);
+
+                  if (this.verbose) {
+                    console.log(`   📤 Found queue dispatch: ${fullMethodName} → queue '${queueName}'`);
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+
+    if (queueNames.length > 0) {
+      this.endpointToQueueNames.set(fullMethodName, queueNames);
+    }
+  }
+
+  /**
+   * Find queue name from @InjectQueue decorator in constructor
+   */
+  findQueueNameFromConstructor(constructor, propertyName) {
+    const parameters = constructor.getParameters();
+
+    for (const param of parameters) {
+      // Check if parameter name matches (e.g., 'queueName' parameter)
+      const paramName = param.getName();
+      
+      // Match patterns like:
+      // - private readonly queueName: Queue
+      // - private queueName: Queue
+      if (paramName === propertyName || paramName.includes(propertyName)) {
+        const decorators = param.getDecorators();
+        const injectQueueDecorator = decorators.find(d => d.getName() === 'InjectQueue');
+
+        if (injectQueueDecorator) {
+          const args = injectQueueDecorator.getArguments();
+          if (args.length > 0) {
+            return args[0].getText().replace(/['"]/g, '');
+          }
+        }
+      }
+    }
+
+    return null;
+  }
 }

package/index.js

@@ -17,6 +17,12 @@ import path from 'path';
 async function main() {
   const cli = new CLI(process.argv);
 
+  // Show help if requested
+  if (cli.hasArg('help') || cli.hasArg('h')) {
+    cli.showHelp();
+    process.exit(0);
+  }
+
   // Load configuration
   const config = loadConfig(cli);
   const absoluteSourceDir = path.resolve(config.sourceDir);
@@ -110,7 +116,7 @@ async function main() {
     // Exit with code based on severity
     if (impact.severity === 'critical' && ! cli.hasArg('no-fail')) {
       console.log('⚠️  Critical impact detected - exiting with error code');
-      process.exit(1);
+      process.exit(0);
     }
 
     console.log('✨ Analysis completed successfully!\n');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sun-asterisk/impact-analyzer",
-  "version": "1.0.6",
+  "version": "1.0.8",
   "description": "Automated impact analysis for TypeScript/JavaScript projects",
   "main": "index.js",
   "type": "module",
@@ -9,7 +9,10 @@
   },
   "scripts": {
     "analyze": "node index.js",
-    "analyze:local": "node index.js --input=src --base=origin/main --head=HEAD",
+    "analyze:last": "node index.js --base=HEAD~1",
+    "analyze:main": "node index.js --base=origin/main",
+    "analyze:verbose": "node index.js --verbose",
+    "help": "node index.js --help",
     "test": "node --test"
   },
   "keywords": [