@saptools/service-flow 0.1.58 → 0.1.60

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

@@ -10,10 +10,16 @@ import { parseServiceBindings } from './service-binding-parser.js';
 import { parseImportedWrapperCalls } from './imported-wrapper-parser.js';
 import {
   directQueryBuilderStatement,
-  isCapQueryBuilderRootName,
   queryBuilderRoot,
   type DirectQueryBuilderStatement,
 } from './000-direct-query-execution.js';
+import {
+  expressionName,
+  maxAliasDepth,
+  queryEntityFromAst,
+  resolveBinding,
+  variableInitializers,
+} from './001-query-entity-resolution.js';
 import type { RepositorySourceContext } from './ts-project.js';
 import {
   analyzeOperationPath,
@@ -24,47 +30,6 @@ import {
 function lineOf(text: string, idx: number): number {
   return text.slice(0, idx).split('\n').length;
 }
-function entityFromExpression(expr: ts.Expression | undefined): string | undefined {
-  if (!expr) return undefined;
-  if (ts.isIdentifier(expr) || ts.isStringLiteral(expr) || ts.isNoSubstitutionTemplateLiteral(expr)) return expr.text;
-  if (ts.isPropertyAccessExpression(expr) && expr.expression.kind === ts.SyntaxKind.ThisKeyword) return expr.name.text;
-  if (ts.isElementAccessExpression(expr) && expr.argumentExpression && (ts.isStringLiteral(expr.argumentExpression) || ts.isNoSubstitutionTemplateLiteral(expr.argumentExpression))) return expr.argumentExpression.text;
-  return undefined;
-}
-function expressionName(expr: ts.Expression): string {
-  if (ts.isIdentifier(expr)) return expr.text;
-  if (ts.isPropertyAccessExpression(expr)) return `${expressionName(expr.expression)}.${expr.name.text}`;
-  return expr.getText();
-}
-function variableInitializers(source: ts.SourceFile): Map<string, ts.Expression> {
-  const initializers = new Map<string, ts.Expression>();
-  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 unwrapQueryExpression(expr: ts.Expression): ts.Expression {
-  if (ts.isParenthesizedExpression(expr) || ts.isAwaitExpression(expr)
-    || ts.isAsExpression(expr) || ts.isTypeAssertionExpression(expr)
-    || ts.isNonNullExpression(expr) || ts.isSatisfiesExpression(expr))
-    return unwrapQueryExpression(expr.expression);
-  return expr;
-}
-function queryEntityFromAst(expr: ts.Expression, initializers = new Map<string, ts.Expression>()): string | undefined {
-  const unwrapped = unwrapQueryExpression(expr);
-  if (ts.isIdentifier(unwrapped) && initializers.has(unwrapped.text)) return queryEntityFromAst(initializers.get(unwrapped.text) as ts.Expression, initializers);
-  if (ts.isCallExpression(unwrapped)) {
-    const name = expressionName(unwrapped.expression);
-    if (name === 'cds.run') return queryEntityFromAst(unwrapped.arguments[0], initializers);
-    if (isCapQueryBuilderRootName(name)) return entityFromExpression(unwrapped.arguments[0]);
-    const receiver = ts.isPropertyAccessExpression(unwrapped.expression) ? unwrapped.expression.expression : undefined;
-    if (receiver) return queryEntityFromAst(receiver, initializers);
-  }
-  return undefined;
-}
 function queryBuilderEvidence(source: ts.SourceFile, statement: DirectQueryBuilderStatement): Record<string, unknown> {
   return {
     classifier: 'cap_query_builder_direct',
@@ -92,18 +57,6 @@ function queryRunEvidence(
     } : {}),
   };
 }
-function extractQueryEntity(expr: string): string | undefined {
-  const source = ts.createSourceFile('query.ts', `const __query = (${expr});`, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
-  const initializers = variableInitializers(source);
-  let found: string | undefined;
-  const visit = (node: ts.Node): void => {
-    if (found) return;
-    if (ts.isParenthesizedExpression(node)) found = queryEntityFromAst(node.expression, initializers);
-    ts.forEachChild(node, visit);
-  };
-  visit(source);
-  return found;
-}
 function queryWarning(expr: string): string {
   if (/^\s*[`'"]/.test(expr)) return 'raw_sql_or_cql_expression';
   if (/^\s*\w+\s*$/.test(expr)) return 'query_variable_without_static_initializer';
@@ -140,8 +93,6 @@ function nameOfProperty(name: ts.PropertyName): string | 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;
@@ -149,56 +100,6 @@ function safeRaw(expr: ts.Expression): string | 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;
-  if (ts.isCatchClause(node.parent) && node.parent.variableDeclaration === 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) && !isLoopInitializerScope(node, current) && !isFunctionLikeScope(current)) current = current.parent;
-  return current;
-}
-function isLoopInitializerScope(declaration: ts.VariableDeclaration, scope: ts.Node): boolean {
-  const list = declaration.parent;
-  return (ts.isForStatement(scope) && scope.initializer === list) || ((ts.isForInStatement(scope) || ts.isForOfStatement(scope)) && scope.initializer === list);
-}
-function catchBindingScope(declaration: ts.VariableDeclaration | ts.ParameterDeclaration): ts.CatchClause | undefined {
-  if (ts.isParameter(declaration)) return undefined;
-  return ts.isCatchClause(declaration.parent) && declaration.parent.variableDeclaration === declaration ? declaration.parent : undefined;
-}
-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 catchScope = catchBindingScope(declaration);
-  if (catchScope) return nodeContains(catchScope.block, use);
-  const scope = declarationScope(declaration);
-  if (ts.isForStatement(scope) || ts.isForInStatement(scope) || ts.isForOfStatement(scope)) return nodeContains(scope.statement, use);
-  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'] };
@@ -474,7 +375,7 @@ export function classifyOutboundCallsInSource(source: ts.SourceFile, filePath: s
         const objectArg = node.arguments[0];
         if (objectArg && ts.isObjectLiteralExpression(objectArg)) {
           const receiver = receiverName(expr.expression);
-          const query = objectPropertyText(objectArg, 'query');
+          const queryExpression = propertyInitializer(objectArg, 'query');
           const method = stripQuotes(resolveExpression(propertyInitializer(objectArg, 'method'), node, 'literal').value ?? objectPropertyText(objectArg, 'method') ?? 'POST');
           const pathExpr = propertyInitializer(objectArg, 'path') ?? propertyInitializer(objectArg, 'event');
           const pathAnalysis = analyzeOperationPath(pathExpr, node, method);
@@ -485,8 +386,13 @@ export function classifyOutboundCallsInSource(source: ts.SourceFile, filePath: s
           const entityCallTypes: Record<string, OutboundCallFact['callType']> = { entity_mutation: 'remote_entity_mutation', entity_delete: 'remote_entity_delete', entity_media: 'remote_entity_media', entity_candidate: 'remote_entity_candidate' };
           const entityCallType = entityCallTypes[intent.kind];
           const isODataQueryRead = method.toUpperCase() === 'GET' && ['entity_query', 'entity_key_read', 'entity_navigation_query'].includes(intent.kind);
-          const unresolvedReason = !query && pathExpr ? pathUnresolvedReason(pathAnalysis) : undefined;
-          add(node, { callType: query ? 'remote_query' : entityCallType ?? (isODataQueryRead ? 'remote_query' : 'remote_action'), serviceVariableName: receiver, method, operationPathExpr, queryEntity: query ? extractQueryEntity(query) : isODataQueryRead ? intent.entitySegment : undefined, payloadSummary: summarizeExpression(objectArg.getText(source)), confidence: op || query ? 0.8 : 0.4, unresolvedReason }, { receiver, classifier: 'service_client_send_object', operationPathExpression: shorthandPath ? op : undefined, rawPathExpression: pathAnalysis.rawExpression, literalPathSource: literalPathSource(pathAnalysis), odataPathIntent: operationPathExpr ? intent : undefined, pathAnalysis, staticPathCandidates: legacyPathCandidates(pathAnalysis), parserWarning: unresolvedReason });
+          const queryEntity = queryExpression
+            ? queryEntityFromAst(queryExpression, initializers)
+            : isODataQueryRead ? intent.entitySegment : undefined;
+          const unresolvedReason = queryExpression
+            ? queryEntity ? undefined : queryWarning(queryExpression.getText(source))
+            : pathExpr ? pathUnresolvedReason(pathAnalysis) : undefined;
+          add(node, { callType: queryExpression ? 'remote_query' : entityCallType ?? (isODataQueryRead ? 'remote_query' : 'remote_action'), serviceVariableName: receiver, method, operationPathExpr, queryEntity, payloadSummary: summarizeExpression(objectArg.getText(source)), confidence: op || queryExpression ? 0.8 : 0.4, unresolvedReason }, { receiver, classifier: 'service_client_send_object', operationPathExpression: shorthandPath ? op : undefined, rawPathExpression: pathAnalysis.rawExpression, literalPathSource: literalPathSource(pathAnalysis), odataPathIntent: operationPathExpr ? intent : undefined, pathAnalysis, staticPathCandidates: legacyPathCandidates(pathAnalysis), parserWarning: unresolvedReason });
         } else {
           const receiver = receiverName(expr.expression);
           const rootReceiver = rootReceiverName(expr.expression);