@saptools/service-flow 0.1.63 → 0.1.65

package/dist/cli.js

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
 import {
   classifyODataPathIntent,
+  classifyOutboundCallsInSource,
   clearRepoFacts,
   containsSupportedOutboundCall,
   discoverRepositories,
@@ -35,7 +36,7 @@ import {
   trace,
   upsertRepository,
   upsertWorkspace
-} from "./chunk-EGBTHN7J.js";
+} from "./chunk-OONNRIDL.js";
 
 // src/cli.ts
 import { Command } from "commander";
@@ -237,7 +238,7 @@ function migrate(db) {
 // package.json
 var package_default = {
   name: "@saptools/service-flow",
-  version: "0.1.63",
+  version: "0.1.65",
   description: "Trace SAP CAP service-to-service flows across multi-repository workspaces with runtime-aware graph resolution",
   type: "module",
   publishConfig: {
@@ -490,6 +491,52 @@ function exportDeclarations(source) {
 function isRelativeImport(value) {
   return Boolean(value?.startsWith("."));
 }
+function directHandlerReferenceTarget(expression, source, imports, namespaceImports) {
+  if (ts.isIdentifier(expression)) {
+    const importSource2 = imports.get(expression.text);
+    return {
+      calleeExpression: expression.text,
+      calleeLocalName: expression.text,
+      importSource: importSource2,
+      relation: importSource2 ? isRelativeImport(importSource2) ? "relative_import" : "package_import" : "indexed_local_symbol"
+    };
+  }
+  if (!ts.isPropertyAccessExpression(expression) || expression.questionDotToken || !ts.isIdentifier(expression.expression) || !ts.isIdentifier(expression.name))
+    return void 0;
+  const objectName = expression.expression.text;
+  const memberName = expression.name.text;
+  const importSource = imports.get(objectName);
+  if (namespaceImports.has(objectName)) return {
+    calleeExpression: expression.getText(source),
+    calleeLocalName: memberName,
+    importSource,
+    relation: "relative_import_namespace_member"
+  };
+  const qualifiedName = `${objectName}.${memberName}`;
+  return {
+    calleeExpression: qualifiedName,
+    calleeLocalName: qualifiedName,
+    importSource,
+    relation: importSource ? isRelativeImport(importSource) ? "relative_import" : "package_import" : "indexed_local_symbol"
+  };
+}
+function handlerReferenceTarget(expression, source, imports, namespaceImports) {
+  const direct = directHandlerReferenceTarget(
+    expression,
+    source,
+    imports,
+    namespaceImports
+  );
+  if (direct) return direct;
+  if (!ts.isCallExpression(expression) || expression.questionDotToken || expression.arguments.length !== 1) return void 0;
+  const inner = directHandlerReferenceTarget(
+    expression.arguments[0],
+    source,
+    imports,
+    namespaceImports
+  );
+  return inner ? { ...inner, wrapperFunction: expression.expression.getText(source) } : void 0;
+}
 function isObjectFunction(node) {
   return ts.isFunctionExpression(node) || ts.isArrowFunction(node) || ts.isMethodDeclaration(node);
 }
@@ -655,6 +702,9 @@ async function parseExecutableSymbols(repoPath, filePath, context) {
   const calls = [];
   const imports = /* @__PURE__ */ new Map();
   const namespaceImports = /* @__PURE__ */ new Set();
+  const eventSubscriptionOffsets = new Set(
+    classifyOutboundCallsInSource(source, sourceFile).filter((call) => call.fact.callType === "async_subscribe").map((call) => call.node.getStart(source))
+  );
   const exportNames = exportDeclarations(source);
   const objectExports = /* @__PURE__ */ new Set();
   const exportedClasses = /* @__PURE__ */ new Set();
@@ -771,6 +821,32 @@ async function parseExecutableSymbols(repoPath, filePath, context) {
         const name = `event:${eventName}:${startLine}`;
         symbols.push({ kind: "event_registration", localName: name, qualifiedName: `module:${sourceFile}#${name}`, sourceFile, startLine, endLine: lineOf(source, node.getEnd()), startOffset: node.getStart(source), endOffset: node.getEnd(), exported: false, importExportEvidence: { source: "synthetic_event_registration", eventName: eventArg.text, registrationLine: startLine, receiver } });
       }
+      if (eventSubscriptionOffsets.has(node.getStart(source))) {
+        const startLine = lineOf(source, node.getStart(source));
+        const handlerArgument = node.arguments[1];
+        const target = handlerArgument ? handlerReferenceTarget(
+          handlerArgument,
+          source,
+          imports,
+          namespaceImports
+        ) : void 0;
+        const anchor = nearest(symbols, startLine);
+        if (target && anchor) calls.push({
+          callerQualifiedName: anchor.qualifiedName,
+          calleeExpression: target.calleeExpression,
+          calleeLocalName: target.calleeLocalName,
+          importSource: target.importSource,
+          sourceFile,
+          sourceLine: startLine,
+          evidence: {
+            relation: target.relation,
+            caller: anchor.qualifiedName,
+            targetName: target.calleeLocalName,
+            ...target.wrapperFunction ? { wrapperFunction: target.wrapperFunction } : {},
+            candidateStrategy: "event_subscribe_handler_reference"
+          }
+        });
+      }
     }
     ts.forEachChild(node, visitEventRegistrationSymbols);
   };