@saptools/service-flow 0.1.39 → 0.1.41

package/src/parsers/outbound-call-parser.ts

@@ -23,11 +23,12 @@ function expressionName(expr: ts.Expression): string {
 }
 function variableInitializers(source: ts.SourceFile): Map<string, ts.Expression> {
   const initializers = new Map<string, ts.Expression>();
-  const visit = (node: ts.Node): void => {
-    if (ts.isVariableDeclaration(node) && ts.isIdentifier(node.name) && node.initializer && (node.parent.flags & ts.NodeFlags.Const) !== 0) initializers.set(node.name.text, node.initializer);
-    ts.forEachChild(node, visit);
-  };
-  visit(source);
+  for (const statement of source.statements) {
+    if (!ts.isVariableStatement(statement) || (statement.declarationList.flags & ts.NodeFlags.Const) === 0) continue;
+    for (const declaration of statement.declarationList.declarations) {
+      if (ts.isIdentifier(declaration.name) && declaration.initializer) initializers.set(declaration.name.text, declaration.initializer);
+    }
+  }
   return initializers;
 }
 function queryEntityFromAst(expr: ts.Expression, initializers = new Map<string, ts.Expression>()): string | undefined {
@@ -89,50 +90,119 @@ function nameOfProperty(name: ts.PropertyName): string | undefined {
   return undefined;
 }
 
+type ExpressionStatus = 'static' | 'dynamic' | 'ambiguous' | 'unknown';
+type ExpressionSourceKind = 'string_literal' | 'no_substitution_template' | 'template_with_substitutions' | 'const_alias' | 'conditional_candidates' | 'dynamic_expression';
+interface ExpressionResolution { status: ExpressionStatus; sourceKind: ExpressionSourceKind; value?: string; rawExpression?: string; placeholderKeys: string[]; evidence: string[]; constName?: string }
+interface BindingResolution { declaration?: ts.VariableDeclaration | ts.ParameterDeclaration; initializer?: ts.Expression; immutable: boolean; evidence: string[] }
+const maxAliasDepth = 5;
+function safeRaw(expr: ts.Expression): string | undefined {
+  if (ts.isStringLiteral(expr) || ts.isNoSubstitutionTemplateLiteral(expr) || ts.isIdentifier(expr) || ts.isTemplateExpression(expr)) return expr.getText(expr.getSourceFile());
+  return undefined;
+}
+function placeholders(expr: ts.TemplateExpression): string[] {
+  return expr.templateSpans.map((span) => span.expression.getText(expr.getSourceFile()));
+}
+function isFunctionLikeScope(node: ts.Node): boolean {
+  return ts.isFunctionLike(node) || ts.isSourceFile(node);
+}
+function nodeContains(parent: ts.Node, child: ts.Node): boolean {
+  const source = child.getSourceFile();
+  return child.getStart(source) >= parent.getStart(source) && child.getEnd() <= parent.getEnd();
+}
+function declarationScope(node: ts.VariableDeclaration | ts.ParameterDeclaration): ts.Node {
+  if (ts.isParameter(node)) return node.parent;
+  const list = node.parent;
+  const blockScoped = (list.flags & (ts.NodeFlags.Const | ts.NodeFlags.Let)) !== 0;
+  let current: ts.Node = list.parent;
+  if (!blockScoped) {
+    while (current.parent && !isFunctionLikeScope(current)) current = current.parent;
+    return current;
+  }
+  while (current.parent && !ts.isBlock(current) && !ts.isSourceFile(current) && !ts.isModuleBlock(current) && !ts.isCaseBlock(current) && !isFunctionLikeScope(current)) current = current.parent;
+  return current;
+}
+function isAccessibleDeclaration(declaration: ts.VariableDeclaration | ts.ParameterDeclaration, use: ts.Node): boolean {
+  const source = use.getSourceFile();
+  if (declaration.name.getStart(source) >= use.getStart(source)) return false;
+  const scope = declarationScope(declaration);
+  return ts.isSourceFile(scope) || nodeContains(scope, use);
+}
+function resolveBinding(identifier: ts.Identifier, use: ts.Node): BindingResolution {
+  const source = use.getSourceFile();
+  let best: ts.VariableDeclaration | ts.ParameterDeclaration | undefined;
+  const visit = (node: ts.Node): void => {
+    if (ts.isVariableDeclaration(node) && ts.isIdentifier(node.name) && node.name.text === identifier.text && isAccessibleDeclaration(node, use)) best = node;
+    if (ts.isParameter(node) && ts.isIdentifier(node.name) && node.name.text === identifier.text && isAccessibleDeclaration(node, use)) best = node;
+    ts.forEachChild(node, visit);
+  };
+  visit(source);
+  if (!best) return { immutable: false, evidence: ['binding_not_found'] };
+  const immutable = ts.isVariableDeclaration(best) && (best.parent.flags & ts.NodeFlags.Const) !== 0;
+  return { declaration: best, initializer: ts.isVariableDeclaration(best) ? best.initializer : undefined, immutable, evidence: [immutable ? 'lexical_const_binding_before_use' : 'lexical_mutable_or_parameter_binding'] };
+}
+function resolveExpression(expr: ts.Expression | undefined, use: ts.Node, policy: 'operation_path' | 'external' | 'literal', depth = 0, seen = new Set<ts.Node>()): ExpressionResolution {
+  if (!expr) return { status: 'unknown', sourceKind: 'dynamic_expression', placeholderKeys: [], evidence: ['expression_missing'] };
+  if (ts.isStringLiteral(expr)) return { status: 'static', sourceKind: 'string_literal', value: expr.text, rawExpression: safeRaw(expr), placeholderKeys: [], evidence: ['string_literal'] };
+  if (ts.isNoSubstitutionTemplateLiteral(expr)) return { status: 'static', sourceKind: 'no_substitution_template', value: expr.text, rawExpression: safeRaw(expr), placeholderKeys: [], evidence: ['no_substitution_template'] };
+  if (ts.isTemplateExpression(expr)) {
+    const keys = placeholders(expr);
+    if (policy === 'operation_path') return { status: 'dynamic', sourceKind: 'template_with_substitutions', value: stripQuotes(expr.getText(expr.getSourceFile())), rawExpression: safeRaw(expr), placeholderKeys: keys, evidence: ['operation_path_template_placeholders_retained'] };
+    return { status: 'dynamic', sourceKind: 'template_with_substitutions', placeholderKeys: keys, evidence: ['template_substitutions_not_static_external_target'] };
+  }
+  if (ts.isIdentifier(expr)) {
+    if (depth >= maxAliasDepth) return { status: 'unknown', sourceKind: 'const_alias', rawExpression: safeRaw(expr), placeholderKeys: [], evidence: ['alias_depth_exceeded'], constName: expr.text };
+    const binding = resolveBinding(expr, use);
+    if (!binding.declaration || !binding.initializer || !binding.immutable) return { status: 'dynamic', sourceKind: 'dynamic_expression', rawExpression: safeRaw(expr), placeholderKeys: [], evidence: binding.evidence, constName: expr.text };
+    if (seen.has(binding.declaration)) return { status: 'unknown', sourceKind: 'const_alias', rawExpression: safeRaw(expr), placeholderKeys: [], evidence: ['alias_cycle_detected'], constName: expr.text };
+    seen.add(binding.declaration);
+    const resolved = resolveExpression(binding.initializer, binding.declaration, policy, depth + 1, seen);
+    return { ...resolved, sourceKind: 'const_alias', rawExpression: safeRaw(expr), constName: expr.text, evidence: [...binding.evidence, ...resolved.evidence] };
+  }
+  return { status: 'dynamic', sourceKind: 'dynamic_expression', rawExpression: safeRaw(expr), placeholderKeys: [], evidence: [`unsupported_${ts.SyntaxKind[expr.kind] ?? 'expression'}`] };
+}
 function staticExpressionText(expr: ts.Expression | undefined, initializers: Map<string, ts.Expression>): string | undefined {
   if (!expr) return undefined;
   if (isStringLike(expr)) return expr.text;
-  if (ts.isTemplateExpression(expr)) return stripQuotes(expr.getText(expr.getSourceFile()));
   if (ts.isIdentifier(expr) && initializers.has(expr.text)) return staticExpressionText(initializers.get(expr.text), initializers);
   return undefined;
 }
-interface StaticPathResolution { text?: string; sourceKind: 'literal' | 'template' | 'const' | 'dynamic'; rawExpression?: string; constName?: string }
-function staticPathExpression(expr: ts.Expression | undefined, initializers: Map<string, ts.Expression>): StaticPathResolution {
-  if (!expr) return { sourceKind: 'dynamic' };
-  const rawExpression = expr.getText(expr.getSourceFile());
-  if (isStringLike(expr)) return { text: expr.text, sourceKind: 'literal', rawExpression };
-  if (ts.isTemplateExpression(expr)) return { text: stripQuotes(rawExpression), sourceKind: 'template', rawExpression };
-  if (ts.isIdentifier(expr) && initializers.has(expr.text)) {
-    const resolved = staticPathExpression(initializers.get(expr.text), initializers);
-    return resolved.text ? { ...resolved, sourceKind: 'const', rawExpression, constName: expr.text } : { sourceKind: 'dynamic', rawExpression };
-  }
-  return { sourceKind: 'dynamic', rawExpression };
+interface StaticPathResolution { text?: string; sourceKind: 'literal' | 'template' | 'const' | 'dynamic'; rawExpression?: string; constName?: string; resolution: ExpressionResolution }
+function staticPathExpression(expr: ts.Expression | undefined, use: ts.Node): StaticPathResolution {
+  const resolution = resolveExpression(expr, use, 'operation_path');
+  const sourceKind = resolution.sourceKind === 'const_alias' ? 'const' : resolution.sourceKind === 'template_with_substitutions' || resolution.sourceKind === 'no_substitution_template' ? 'template' : resolution.status === 'static' ? 'literal' : 'dynamic';
+  return { text: resolution.value, sourceKind, rawExpression: resolution.rawExpression, constName: resolution.constName, resolution };
 }
 function operationPathFromStatic(text: string | undefined): string | undefined {
   return text ? `/${stripQuotes(text).replace(/^\//, '')}` : undefined;
 }
-interface PathCandidateEvidence { candidatePaths: string[]; normalizedCandidateOperations: string[]; candidateSourceKind: string; candidateIdentifier: string; hasDynamicAssignments: boolean }
-function staticPathCandidates(source: ts.SourceFile, identifier: string, initializers: Map<string, ts.Expression>): PathCandidateEvidence | undefined {
+interface PathCandidateEvidence { candidatePaths: string[]; normalizedCandidateOperations: string[]; candidateSourceKind: string; candidateIdentifier: string; hasDynamicAssignments: boolean; conservativeReason?: string }
+function staticPathCandidates(identifier: ts.Identifier, call: ts.Node, method: string): PathCandidateEvidence | undefined {
+  const binding = resolveBinding(identifier, call);
+  const declaration = binding.declaration;
+  if (!declaration) return undefined;
+  const source = call.getSourceFile();
   const paths: string[] = [];
   let hasDynamicAssignments = false;
+  const addExpr = (expr: ts.Expression | undefined, origin: ts.Node): void => {
+    const resolved = staticPathExpression(expr, origin);
+    if (resolved.text) paths.push(operationPathFromStatic(resolved.text) ?? resolved.text);
+    else hasDynamicAssignments = true;
+  };
+  if (ts.isVariableDeclaration(declaration)) addExpr(declaration.initializer, declaration);
   const visit = (node: ts.Node): void => {
-    if (ts.isVariableDeclaration(node) && ts.isIdentifier(node.name) && node.name.text === identifier && node.initializer) {
-      const resolved = staticPathExpression(node.initializer, initializers);
-      if (resolved.text) paths.push(operationPathFromStatic(resolved.text) ?? resolved.text);
-      else hasDynamicAssignments = true;
-    }
-    if (ts.isBinaryExpression(node) && node.operatorToken.kind === ts.SyntaxKind.EqualsToken && ts.isIdentifier(node.left) && node.left.text === identifier) {
-      const resolved = staticPathExpression(node.right, initializers);
-      if (resolved.text) paths.push(operationPathFromStatic(resolved.text) ?? resolved.text);
-      else hasDynamicAssignments = true;
+    if (node !== source && isFunctionLikeScope(node) && !nodeContains(node, call)) return;
+    if (node.getStart(source) >= call.getStart(source)) return;
+    if (ts.isBinaryExpression(node) && node.operatorToken.kind === ts.SyntaxKind.EqualsToken && ts.isIdentifier(node.left)) {
+      const target = resolveBinding(node.left, node);
+      if (target.declaration === declaration) addExpr(node.right, node);
     }
     ts.forEachChild(node, visit);
   };
   visit(source);
   const candidatePaths = [...new Set(paths)];
   if (candidatePaths.length === 0) return undefined;
-  const normalizedCandidateOperations = [...new Set(candidatePaths.map((candidate) => classifyODataPathIntent(candidate, 'POST').topLevelOperationName).filter((value): value is string => Boolean(value)))];
-  return { candidatePaths, normalizedCandidateOperations, candidateSourceKind: 'static candidates observed', candidateIdentifier: identifier, hasDynamicAssignments };
+  const normalizedCandidateOperations = [...new Set(candidatePaths.map((candidate) => classifyODataPathIntent(candidate, method).topLevelOperationName).filter((value): value is string => Boolean(value)))];
+  return { candidatePaths, normalizedCandidateOperations, candidateSourceKind: 'static candidates observed before call in lexical scope', candidateIdentifier: identifier.text, hasDynamicAssignments, conservativeReason: hasDynamicAssignments ? 'dynamic_assignment_observed' : normalizedCandidateOperations.length > 1 ? 'candidate_tie' : undefined };
 }
 function destinationExpressionShape(expr: ts.Expression | undefined): string | undefined {
   if (!expr) return undefined;
@@ -159,57 +229,59 @@ function propertyInitializer(object: ts.ObjectLiteralExpression, key: string): t
   }
   return undefined;
 }
-function httpMethodFromObject(object: ts.ObjectLiteralExpression, initializers: Map<string, ts.Expression>): string | undefined {
-  const text = staticExpressionText(propertyInitializer(object, 'method'), initializers);
+function httpMethodFromObject(object: ts.ObjectLiteralExpression, use: ts.Node): string | undefined {
+  const text = resolveExpression(propertyInitializer(object, 'method'), use, 'literal').value;
   return text ? stripQuotes(text).toUpperCase() : undefined;
 }
-function urlTargetFromExpression(expr: ts.Expression | undefined, initializers: Map<string, ts.Expression>): Record<string, unknown> {
-  const text = staticExpressionText(expr, initializers);
-  if (text) return { kind: 'static_url', expression: text, dynamic: false };
-  if (expr && (ts.isTemplateExpression(expr) || ts.isIdentifier(expr) || ts.isPropertyAccessExpression(expr) || ts.isCallExpression(expr))) return { kind: 'url_expression', expression: expr.getText(expr.getSourceFile()), dynamic: true };
+function hasTemplatePlaceholder(value: string): boolean { return /\$\{|%7B|%7D/i.test(value); }
+function urlTargetFromExpression(expr: ts.Expression | undefined, use: ts.Node): Record<string, unknown> {
+  const resolved = resolveExpression(expr, use, 'external');
+  if (resolved.status === 'static' && resolved.value && !hasTemplatePlaceholder(resolved.value)) return { kind: 'static_url', expression: resolved.value, dynamic: false, sourceKind: resolved.sourceKind };
+  if (expr) return { kind: 'url_expression', dynamic: true, expression: `${resolved.sourceKind}:${resolved.placeholderKeys.join('|')}`, expressionShape: resolved.sourceKind, placeholderKeys: resolved.placeholderKeys };
   return { kind: 'unknown', dynamic: false };
 }
-function destinationTargetFromExpression(expr: ts.Expression | undefined, initializers: Map<string, ts.Expression>): Record<string, unknown> | undefined {
-  const text = staticExpressionText(expr, initializers);
-  if (text) return { kind: 'destination', expression: text, dynamic: false };
-  const candidates = staticConditionalCandidates(expr, initializers);
+function destinationTargetFromExpression(expr: ts.Expression | undefined, use: ts.Node): Record<string, unknown> | undefined {
+  const resolved = resolveExpression(expr, use, 'external');
+  const text = resolved.value;
+  if (resolved.status === 'static' && text && !hasTemplatePlaceholder(text)) return { kind: 'destination', expression: text, dynamic: false, sourceKind: resolved.sourceKind };
+  const candidates = staticConditionalCandidates(expr, new Map<string, ts.Expression>());
   if (candidates) return { kind: 'destination', dynamic: true, expressionShape: 'conditional', candidateLiterals: candidates };
   const shape = destinationExpressionShape(expr);
   if (shape) return { kind: 'destination', dynamic: true, expressionShape: shape };
   return undefined;
 }
-function externalHttpEvidence(node: ts.CallExpression, source: ts.SourceFile, initializers: Map<string, ts.Expression>): { method?: string; externalTarget: Record<string, unknown>; classifier: string; sourceCallShape: string } | undefined {
+function externalHttpEvidence(node: ts.CallExpression, source: ts.SourceFile): { method?: string; externalTarget: Record<string, unknown>; classifier: string; sourceCallShape: string } | undefined {
   const expr = node.expression;
   const exprText = expr.getText(source);
   if (exprText === 'useOrFetchDestination') {
     const objectArg = node.arguments[0];
     if (objectArg && ts.isObjectLiteralExpression(objectArg)) {
-      const destination = destinationTargetFromExpression(propertyInitializer(objectArg, 'destinationName'), initializers);
+      const destination = destinationTargetFromExpression(propertyInitializer(objectArg, 'destinationName'), node);
       return { externalTarget: destination ?? { kind: 'unknown', dynamic: false }, classifier: 'sap_destination_lookup', sourceCallShape: 'useOrFetchDestination' };
     }
   }
   if (exprText === 'executeHttpRequest') {
-    const destination = destinationTargetFromExpression(node.arguments[0], initializers);
+    const destination = destinationTargetFromExpression(node.arguments[0], node);
     const config = node.arguments[1];
-    const method = config && ts.isObjectLiteralExpression(config) ? httpMethodFromObject(config, initializers) : undefined;
-    const url = config && ts.isObjectLiteralExpression(config) ? urlTargetFromExpression(propertyInitializer(config, 'url'), initializers) : { kind: 'unknown', dynamic: false };
+    const method = config && ts.isObjectLiteralExpression(config) ? httpMethodFromObject(config, node) : undefined;
+    const url = config && ts.isObjectLiteralExpression(config) ? urlTargetFromExpression(propertyInitializer(config, 'url'), node) : { kind: 'unknown', dynamic: false };
     return { method, externalTarget: destination ? { ...url, destination } : url, classifier: 'sap_execute_http_request', sourceCallShape: 'executeHttpRequest' };
   }
   if (exprText === 'axios') {
     const config = node.arguments[0];
     if (config && ts.isObjectLiteralExpression(config)) {
-      const method = httpMethodFromObject(config, initializers);
-      return { method, externalTarget: urlTargetFromExpression(propertyInitializer(config, 'url'), initializers), classifier: 'axios_config_call', sourceCallShape: 'axios(config)' };
+      const method = httpMethodFromObject(config, node);
+      return { method, externalTarget: urlTargetFromExpression(propertyInitializer(config, 'url'), node), classifier: 'axios_config_call', sourceCallShape: 'axios(config)' };
     }
     return { externalTarget: { kind: 'unknown', dynamic: false }, classifier: 'axios_unknown_call', sourceCallShape: 'axios(...)' };
   }
   if (exprText === 'fetch') {
     const init = node.arguments[1];
-    const method = init && ts.isObjectLiteralExpression(init) ? httpMethodFromObject(init, initializers) : undefined;
-    return { method, externalTarget: urlTargetFromExpression(node.arguments[0], initializers), classifier: 'fetch_call', sourceCallShape: 'fetch' };
+    const method = init && ts.isObjectLiteralExpression(init) ? httpMethodFromObject(init, node) : undefined;
+    return { method, externalTarget: urlTargetFromExpression(node.arguments[0], node), classifier: 'fetch_call', sourceCallShape: 'fetch' };
   }
   if (ts.isPropertyAccessExpression(expr) && ['get','post','put','patch','delete','head'].includes(expr.name.text) && expr.expression.getText(source) === 'axios') {
-    return { method: expr.name.text.toUpperCase(), externalTarget: urlTargetFromExpression(node.arguments[0], initializers), classifier: 'axios_member_call', sourceCallShape: `axios.${expr.name.text}` };
+    return { method: expr.name.text.toUpperCase(), externalTarget: urlTargetFromExpression(node.arguments[0], node), classifier: 'axios_member_call', sourceCallShape: `axios.${expr.name.text}` };
   }
   return undefined;
 }
@@ -274,7 +346,7 @@ function collectWrapperSpecs(source: ts.SourceFile): Map<string, WrapperSpec> {
           const methodProp = propertyInitializer(objectArg, 'method');
           const pathName = pathProp && ts.isIdentifier(pathProp) ? pathProp.text : undefined;
           const methodName = methodProp && ts.isIdentifier(methodProp) ? methodProp.text : undefined;
-          const methodLiteral = staticExpressionText(methodProp, variableInitializers(source));
+          const methodLiteral = resolveExpression(methodProp, node, 'literal').value;
           if (pathName) sends.push({ client: node.expression.expression.text, path: pathName, method: methodName, methodLiteral, start: node.getStart(source), end: node.getEnd() });
         }
       }
@@ -324,12 +396,12 @@ export function classifyOutboundCallsInSource(source: ts.SourceFile, filePath: s
         if (objectArg && ts.isObjectLiteralExpression(objectArg)) {
           const receiver = receiverName(expr.expression);
           const query = objectPropertyText(objectArg, 'query');
-          const method = stripQuotes(objectPropertyText(objectArg, 'method') ?? 'POST');
+          const method = stripQuotes(resolveExpression(propertyInitializer(objectArg, 'method'), node, 'literal').value ?? objectPropertyText(objectArg, 'method') ?? 'POST');
           const pathExpr = propertyInitializer(objectArg, 'path') ?? propertyInitializer(objectArg, 'event');
-          const resolvedPath = staticPathExpression(pathExpr, initializers);
+          const resolvedPath = staticPathExpression(pathExpr, node);
           const op = pathExpr ? resolvedPath.text ?? pathExpr.getText(source) : undefined;
           const shorthandPath = objectPropertyIsShorthand(objectArg, 'path');
-          const candidateEvidence = pathExpr && ts.isIdentifier(pathExpr) && !resolvedPath.text ? staticPathCandidates(source, pathExpr.text, initializers) : undefined;
+          const candidateEvidence = pathExpr && ts.isIdentifier(pathExpr) && !resolvedPath.text ? staticPathCandidates(pathExpr, node, method) : undefined;
           const candidateOperationPath = candidateEvidence && !candidateEvidence.hasDynamicAssignments && candidateEvidence.normalizedCandidateOperations.length === 1 && candidateEvidence.candidatePaths.length > 0 ? candidateEvidence.candidatePaths[0] : undefined;
           const operationPathExpr = operationPathFromStatic(resolvedPath.text) ?? candidateOperationPath;
           const intent = classifyODataPathIntent(operationPathExpr, method);
@@ -346,8 +418,8 @@ export function classifyOutboundCallsInSource(source: ts.SourceFile, filePath: s
         const pathArg = spec ? wrapperArgs[spec.pathIndex] : undefined;
         const methodArg = spec?.methodIndex === undefined ? undefined : wrapperArgs[spec.methodIndex];
         const receiver = clientArg && ts.isIdentifier(clientArg) ? clientArg.text : spec?.clientName;
-        const method = stripQuotes(staticExpressionText(methodArg, initializers) ?? spec?.methodLiteral ?? 'POST');
-        const resolvedPath = staticPathExpression(pathArg, initializers);
+        const method = stripQuotes(resolveExpression(methodArg, node, 'literal').value ?? spec?.methodLiteral ?? 'POST');
+        const resolvedPath = staticPathExpression(pathArg, node);
         const operationPathExpr = operationPathFromStatic(resolvedPath.text);
         const normalizedOperationPath = operationPathExpr ? classifyODataPathIntent(operationPathExpr, method).topLevelOperationName : undefined;
         if (spec && receiver && operationPathExpr) {
@@ -363,7 +435,7 @@ export function classifyOutboundCallsInSource(source: ts.SourceFile, filePath: s
           if (eventName) add(node, { callType: expr.name.text === 'on' ? 'async_subscribe' : 'async_emit', serviceVariableName: rootReceiver ?? receiver, eventNameExpr: eventName }, { receiver, rootReceiver, classifier: expr.name.text === 'on' ? 'cap_service_event_subscription' : 'cap_service_event_emit', receiverClassification: 'cap_evidence' });
         }
       } else {
-        const external = externalHttpEvidence(node, source, initializers);
+        const external = externalHttpEvidence(node, source);
         if (external) {
           const evidenceTarget = { ...external.externalTarget, method: external.method, parserClassifier: external.classifier, sourceCallShape: external.sourceCallShape };
           const safeTarget = externalHttpTarget({ method: external.method, evidence_json: JSON.stringify({ externalTarget: evidenceTarget }) });
@@ -400,7 +472,7 @@ function parseLocalServiceCalls(text: string, filePath: string): OutboundCallFac
       if (origin) aliases.set(node.name.text, { ...origin, chain: [...origin.chain, node.name.text] });
     }
     if (ts.isCallExpression(node)) {
-      const parsed = serviceOperationCall(node.expression, aliases);
+      const parsed = serviceOperationCall(node, aliases);
       if (parsed && parsed.operation !== 'entities') calls.push({
         callType: 'local_service_call',
         operationPathExpr: `/${parsed.operation}`,
@@ -413,7 +485,8 @@ function parseLocalServiceCalls(text: string, filePath: string): OutboundCallFac
         confidence: 0.9,
         unresolvedReason: ['send', 'emit', 'publish', 'on'].includes(parsed.operation) ? 'transport_client_method' : undefined,
         evidence: parserEvidence(source, node, {
-          classifier: 'local_cap_service_call',
+          classifier: parsed.classifier,
+          parserCallType: parsed.operation === 'send' ? 'transport_client_method' : parsed.classifier,
           localServiceLookup: parsed.lookup,
           localServiceName: parsed.service,
           operation: parsed.operation,
@@ -432,10 +505,17 @@ function serviceLookup(expr: ts.Expression, aliases: Map<string, { service: stri
   if (ts.isElementAccessExpression(expr) && expr.expression.getText() === 'cds.services' && ts.isStringLiteral(expr.argumentExpression)) return { service: expr.argumentExpression.text, lookup: expr.getText(), chain: [expr.getText()] };
   return undefined;
 }
-function serviceOperationCall(expr: ts.Expression, aliases: Map<string, { service: string; lookup: string; chain: string[] }>): { service: string; lookup: string; chain: string[]; operation: string } | undefined {
+function serviceOperationCall(node: ts.CallExpression, aliases: Map<string, { service: string; lookup: string; chain: string[] }>): { service: string; lookup: string; chain: string[]; operation: string; classifier: string } | undefined {
+  const expr = node.expression;
   if (!ts.isPropertyAccessExpression(expr)) return undefined;
-  const operation = expr.name.text;
   const origin = serviceLookup(expr.expression, aliases);
   if (!origin) return undefined;
-  return { ...origin, operation };
+  if (expr.name.text === 'send') {
+    const first = literalText(node.arguments[0]);
+    const second = literalText(node.arguments[1]);
+    const method = first?.toUpperCase();
+    if (method && ['GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'HEAD'].includes(method) && second) return { ...origin, operation: second.replace(/^\//, ''), classifier: 'cap_service_send_method_path' };
+    if (first) return { ...origin, operation: first.replace(/^\//, ''), classifier: 'cap_service_send_local_dispatch' };
+  }
+  return { ...origin, operation: expr.name.text, classifier: 'local_cap_service_call' };
 }

package/src/types.ts

@@ -70,6 +70,14 @@ export interface CdsServiceFact {
   sourceFile: string;
   sourceLine: number;
   operations: CdsOperationFact[];
+  extension?: CdsExtensionFact;
+}
+export interface CdsExtensionFact {
+  localReference: string;
+  importedSymbol?: string;
+  localAlias?: string;
+  moduleSpecifier?: string;
+  importKind?: 'relative' | 'package' | 'none';
 }
 export interface CdsOperationFact {
   operationType: 'action' | 'function' | 'event';
@@ -79,6 +87,8 @@ export interface CdsOperationFact {
   returnType?: string;
   sourceFile: string;
   sourceLine: number;
+  provenance?: 'direct' | 'inherited';
+  baseOperationId?: number;
 }
 export interface HandlerClassFact {
   className: string;