@saptools/service-flow 0.1.55 → 0.1.57

package/dist/index.js

@@ -17,7 +17,7 @@ import {
   stripQuotes,
   substituteVariables,
   trace
-} from "./chunk-GXYVIHJ5.js";
+} from "./chunk-DCOFNDKS.js";
 
 // src/parsers/generated-constants-parser.ts
 import fs from "fs/promises";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@saptools/service-flow",
-  "version": "0.1.55",
+  "version": "0.1.57",
   "description": "Trace SAP CAP service-to-service flows across multi-repository workspaces with runtime-aware graph resolution",
   "type": "module",
   "publishConfig": {

package/src/db/repositories.ts

@@ -1,3 +1,4 @@
+import { posix } from 'node:path';
 import type { Db } from './connection.js';
 import { projectBounded } from '../utils/000-bounded-projection.js';
 import type {
@@ -390,34 +391,88 @@ export function insertSymbolCalls(db: Db, repoId: number, rows: SymbolCallFact[]
   for (const r of rows) {
     const caller = callerStmt.get(repoId, r.sourceFile, r.callerQualifiedName) as { id?: number } | undefined;
     const target = resolveSymbolCallTarget(db, repoId, r);
-    insertStmt.run(repoId, caller?.id, target.id, r.calleeExpression, r.importSource, r.sourceFile, r.sourceLine, target.status, 0.8, JSON.stringify({ ...r.evidence, candidateStrategy: target.strategy, candidateCount: target.candidateCount }), target.reason);
+    insertStmt.run(repoId, caller?.id, target.id, r.calleeExpression, r.importSource, r.sourceFile, r.sourceLine, target.status, 0.8, JSON.stringify({ ...r.evidence, candidateStrategy: target.strategy, candidateCount: target.candidateCount, resolvedModulePath: target.resolvedModulePath }), target.reason);
   }
 }
+interface SymbolTargetRow { id: number; kind?: string; sourceFile?: string | null; evidenceJson?: string | null }
+interface SymbolCallResolution { id: number | null; status: 'resolved' | 'ambiguous' | 'unresolved'; reason: string | null; strategy: string; candidateCount: number; resolvedModulePath?: string }
+const stripExt = (value: string): string => value.replace(/\.(ts|tsx|js|jsx|cds)$/, '');
+function symbolTargetRows(rows: Array<Record<string, unknown>>): SymbolTargetRow[] {
+  return rows.flatMap((row) => typeof row.id === 'number' ? [{ id: row.id, kind: typeof row.kind === 'string' ? row.kind : undefined, sourceFile: nullableString(row.sourceFile), evidenceJson: nullableString(row.evidenceJson) }] : []);
+}
+function relativeModuleTargets(callerSourceFile: string, importSource: string): Set<string> {
+  const base = posix.dirname(callerSourceFile);
+  const joined = stripExt(posix.normalize(posix.join(base, importSource)));
+  return new Set([joined, `${joined}/index`]);
+}
+function moduleRows(rows: SymbolTargetRow[], r: SymbolCallFact): SymbolTargetRow[] {
+  if (!r.importSource) return [];
+  const targets = relativeModuleTargets(r.sourceFile, r.importSource);
+  return rows.filter((row) => typeof row.sourceFile === 'string' && targets.has(stripExt(row.sourceFile)));
+}
+function resolvedSymbol(row: SymbolTargetRow, strategy: string, candidateCount: number, moduleScoped = false): SymbolCallResolution {
+  return { id: row.id, status: 'resolved', reason: null, strategy, candidateCount, resolvedModulePath: moduleScoped && row.sourceFile ? stripExt(row.sourceFile) : undefined };
+}
+function exportedSymbolRows(db: Db, repoId: number, r: SymbolCallFact): SymbolTargetRow[] {
+  return symbolTargetRows(db.prepare('SELECT id,kind,source_file sourceFile,evidence_json evidenceJson FROM symbols WHERE repo_id=? AND source_file<>? AND exported=1 AND (exported_name=? OR name=? OR qualified_name=?) ORDER BY id').all(repoId, r.sourceFile, r.calleeLocalName, r.calleeLocalName, r.calleeLocalName));
+}
 function isRelativeImportedSymbolCall(r: SymbolCallFact): boolean {
   return Boolean(r.importSource?.startsWith('.'));
 }
-function resolveSymbolCallTarget(db: Db, repoId: number, r: SymbolCallFact): { id: number | null; status: string; reason: string | null; strategy: string; candidateCount: number } {
-  const evidence = r.evidence as { relation?: unknown };
-  const localRows = db.prepare('SELECT id FROM symbols WHERE repo_id=? AND source_file=? AND (name=? OR qualified_name=?) ORDER BY id').all(repoId, r.sourceFile, r.calleeLocalName, r.calleeLocalName) as Array<{ id: number }>;
-  if (localRows.length === 1) return { id: localRows[0]?.id ?? null, status: 'resolved', reason: null, strategy: 'same_file_exact', candidateCount: 1 };
-  if (localRows.length > 1) return { id: null, status: 'ambiguous', reason: 'Multiple same-file symbol targets matched exactly', strategy: 'same_file_exact', candidateCount: localRows.length };
-  if (evidence.relation === 'class_instance_method' && isRelativeImportedSymbolCall(r)) {
-    const classRows = db.prepare('SELECT id FROM symbols WHERE repo_id=? AND source_file<>? AND qualified_name=? ORDER BY id').all(repoId, r.sourceFile, r.calleeLocalName) as Array<{ id: number }>;
-    if (classRows.length === 1) return { id: classRows[0]?.id ?? null, status: 'resolved', reason: null, strategy: 'relative_import_class_instance_method', candidateCount: 1 };
-    if (classRows.length > 1) return { id: null, status: 'ambiguous', reason: 'Multiple relative class instance method targets matched exactly', strategy: 'relative_import_class_instance_method', candidateCount: classRows.length };
-  }
-  const rows = db.prepare('SELECT id,kind,evidence_json evidenceJson FROM symbols WHERE repo_id=? AND source_file<>? AND exported=1 AND (exported_name=? OR name=? OR qualified_name=?) ORDER BY id').all(repoId, r.sourceFile, r.calleeLocalName, r.calleeLocalName, r.calleeLocalName) as Array<{ id: number; kind?: string; evidenceJson?: string | null }>;
-  if (evidence.relation === 'relative_import_proxy_member' && rows.length > 1) {
-    const objectMapRows = rows.filter((row) => String(row.evidenceJson ?? '').includes('exported_object_shorthand') || String(row.evidenceJson ?? '').includes('exported_object_literal'));
-    if (objectMapRows.length > 0) {
-      const concrete = rows.find((row) => row.kind !== 'object_alias') ?? objectMapRows[0];
-      return { id: concrete?.id ?? null, status: 'resolved', reason: null, strategy: 'proxy_member_exported_object_map', candidateCount: rows.length };
-    }
-    return { id: null, status: 'ambiguous', reason: 'Proxy member target requires explicit factory/module/type evidence; global member name is ambiguous', strategy: 'proxy_member_no_global_name_fallback', candidateCount: rows.length };
+function sameFileResolution(db: Db, repoId: number, r: SymbolCallFact, relation: unknown): SymbolCallResolution | undefined {
+  const bareImport = relation === 'relative_import' && isRelativeImportedSymbolCall(r) && !String(r.calleeLocalName).includes('.');
+  if (bareImport || relation === 'relative_import_namespace_member' || relation === 'package_import') return undefined;
+  const rows = symbolTargetRows(db.prepare('SELECT id FROM symbols WHERE repo_id=? AND source_file=? AND (name=? OR qualified_name=?) ORDER BY id').all(repoId, r.sourceFile, r.calleeLocalName, r.calleeLocalName));
+  if (rows.length === 1 && rows[0]) return resolvedSymbol(rows[0], 'same_file_exact', 1);
+  return rows.length > 1 ? { id: null, status: 'ambiguous', reason: 'Multiple same-file symbol targets matched exactly', strategy: 'same_file_exact', candidateCount: rows.length } : undefined;
+}
+function classInstanceResolution(db: Db, repoId: number, r: SymbolCallFact, relation: unknown): SymbolCallResolution | undefined {
+  if (relation !== 'class_instance_method' || !isRelativeImportedSymbolCall(r)) return undefined;
+  const rows = symbolTargetRows(db.prepare('SELECT id FROM symbols WHERE repo_id=? AND source_file<>? AND qualified_name=? ORDER BY id').all(repoId, r.sourceFile, r.calleeLocalName));
+  if (rows.length === 1 && rows[0]) return resolvedSymbol(rows[0], 'relative_import_class_instance_method', 1);
+  return rows.length > 1 ? { id: null, status: 'ambiguous', reason: 'Multiple relative class instance method targets matched exactly', strategy: 'relative_import_class_instance_method', candidateCount: rows.length } : undefined;
+}
+function namespaceResolution(db: Db, repoId: number, r: SymbolCallFact, relation: unknown): SymbolCallResolution | undefined {
+  if (relation !== 'relative_import_namespace_member' || !isRelativeImportedSymbolCall(r)) return undefined;
+  const rows = moduleRows(exportedSymbolRows(db, repoId, r), r);
+  if (rows.length === 1 && rows[0]) return resolvedSymbol(rows[0], 'relative_import_namespace_member', 1, true);
+  if (rows.length > 1) return { id: null, status: 'ambiguous', reason: 'Multiple namespace member targets matched the imported module', strategy: 'relative_import_namespace_member', candidateCount: rows.length };
+  return { id: null, status: 'unresolved', reason: 'No namespace member target matched the imported module', strategy: 'relative_import_namespace_member', candidateCount: 0 };
+}
+function proxyResolution(rows: SymbolTargetRow[], r: SymbolCallFact, relation: unknown): SymbolCallResolution | undefined {
+  if (relation !== 'relative_import_proxy_member' || rows.length <= 1) return undefined;
+  const mapped = rows.filter((row) => String(row.evidenceJson ?? '').includes('exported_object_shorthand') || String(row.evidenceJson ?? '').includes('exported_object_literal'));
+  if (mapped.length > 0) {
+    const concrete = rows.find((row) => row.kind !== 'object_alias') ?? mapped[0];
+    return { id: concrete?.id ?? null, status: 'resolved', reason: null, strategy: 'proxy_member_exported_object_map', candidateCount: rows.length };
   }
-  if (rows.length === 1) return { id: rows[0]?.id ?? null, status: 'resolved', reason: null, strategy: evidence.relation === 'relative_import_proxy_member' ? 'proxy_member_unique_exported_candidate' : 'relative_import_exported_exact', candidateCount: 1 };
-  if (rows.length > 1) return { id: null, status: 'ambiguous', reason: 'Multiple exported symbol targets matched exactly', strategy: 'exported_exact', candidateCount: rows.length };
-  return { id: null, status: 'unresolved', reason: 'No local symbol target matched exactly', strategy: evidence.relation === 'relative_import_proxy_member' ? 'proxy_member_no_global_name_fallback' : 'exact_symbol_match', candidateCount: 0 };
+  const scoped = moduleRows(rows, r);
+  if (scoped.length === 1 && scoped[0]) return resolvedSymbol(scoped[0], 'relative_import_path_disambiguated', rows.length, true);
+  return { id: null, status: 'ambiguous', reason: 'Proxy member target requires explicit factory/module/type evidence; global member name is ambiguous', strategy: 'proxy_member_no_global_name_fallback', candidateCount: rows.length };
+}
+function exportedResolution(rows: SymbolTargetRow[], r: SymbolCallFact, relation: unknown): SymbolCallResolution | undefined {
+  if (rows.length === 1 && rows[0]) return resolvedSymbol(rows[0], relation === 'relative_import_proxy_member' ? 'proxy_member_unique_exported_candidate' : 'relative_import_exported_exact', 1, moduleRows(rows, r).length === 1);
+  if (rows.length <= 1) return undefined;
+  const scoped = isRelativeImportedSymbolCall(r) ? moduleRows(rows, r) : [];
+  if (scoped.length === 1 && scoped[0]) return resolvedSymbol(scoped[0], 'relative_import_path_disambiguated', rows.length, true);
+  return { id: null, status: 'ambiguous', reason: 'Multiple exported symbol targets matched exactly', strategy: 'exported_exact', candidateCount: rows.length };
+}
+function accessorResolution(db: Db, repoId: number, r: SymbolCallFact, relation: unknown): SymbolCallResolution | undefined {
+  if (relation !== 'relative_import' || !isRelativeImportedSymbolCall(r) || !/^[^.]+\.[^.]+$/.test(String(r.calleeLocalName))) return undefined;
+  const methodRows = symbolTargetRows(db.prepare("SELECT id,kind,source_file sourceFile FROM symbols WHERE repo_id=? AND source_file<>? AND kind='method' AND qualified_name=? ORDER BY id").all(repoId, r.sourceFile, r.calleeLocalName));
+  const scoped = moduleRows(methodRows, r);
+  if (scoped.length === 1 && scoped[0]) return resolvedSymbol(scoped[0], 'relative_import_static_accessor_instance_method', 1, true);
+  return scoped.length > 1 ? { id: null, status: 'ambiguous', reason: 'Multiple static-accessor instance method targets matched the imported module', strategy: 'relative_import_static_accessor_instance_method', candidateCount: scoped.length } : undefined;
+}
+function resolveSymbolCallTarget(db: Db, repoId: number, r: SymbolCallFact): SymbolCallResolution {
+  const relation = r.evidence.relation;
+  const early = sameFileResolution(db, repoId, r, relation) ?? classInstanceResolution(db, repoId, r, relation) ?? namespaceResolution(db, repoId, r, relation);
+  if (early) return early;
+  const rows = relation === 'package_import' ? [] : exportedSymbolRows(db, repoId, r);
+  const matched = proxyResolution(rows, r, relation) ?? exportedResolution(rows, r, relation) ?? accessorResolution(db, repoId, r, relation);
+  if (matched) return matched;
+  if (relation === 'package_import') return { id: null, status: 'unresolved', reason: 'Package import target resolution requires a post-publication workspace pass', strategy: 'package_import_unresolved', candidateCount: 0 };
+  return { id: null, status: 'unresolved', reason: 'No local symbol target matched exactly', strategy: relation === 'relative_import_proxy_member' ? 'proxy_member_no_global_name_fallback' : 'exact_symbol_match', candidateCount: 0 };
 }
 export function insertCalls(
   db: Db,

package/src/parsers/000-direct-query-execution.ts

@@ -0,0 +1,287 @@
+import ts from 'typescript';
+
+const capQueryBuilderRoots = new Set([
+  'SELECT.from',
+  'SELECT.one.from',
+  'SELECT.one',
+  'INSERT.into',
+  'UPSERT.into',
+  'UPDATE.entity',
+  'UPDATE',
+  'DELETE.from',
+]);
+const promiseValueShadowCache = new WeakMap<ts.SourceFile, boolean>();
+
+export type DirectQueryExecutionContext =
+  | 'await'
+  | 'async_return'
+  | 'promise_return'
+  | 'promise_aggregate';
+
+export interface DirectQueryBuilderStatement {
+  root: ts.CallExpression;
+  logicalCall: ts.CallExpression;
+  statement: ts.Expression;
+  executionContext: DirectQueryExecutionContext;
+}
+
+export function isCapQueryBuilderRootName(name: string): boolean {
+  return capQueryBuilderRoots.has(name);
+}
+
+export function queryBuilderRoot(
+  expression: ts.Expression,
+): ts.CallExpression | undefined {
+  const unwrapped = unwrapQueryExpression(expression);
+  if (!ts.isCallExpression(unwrapped)) return undefined;
+  if (isCapQueryBuilderRootName(expressionName(unwrapped.expression)))
+    return unwrapped;
+  return ts.isPropertyAccessExpression(unwrapped.expression)
+    ? queryBuilderRoot(unwrapped.expression.expression)
+    : undefined;
+}
+
+export function directQueryBuilderStatement(
+  node: ts.CallExpression,
+): DirectQueryBuilderStatement | undefined {
+  const root = queryBuilderRoot(node);
+  if (!root) return undefined;
+  const logicalCall = outerFluentQueryCall(root);
+  if (logicalCall !== node) return undefined;
+  const expression = outerTransparentExpression(logicalCall);
+  const awaitExpression = directAwaitExpression(expression);
+  if (awaitExpression)
+    return { root, logicalCall, statement: awaitExpression, executionContext: 'await' };
+  const returnContext = returnExecutionContext(expression);
+  if (returnContext)
+    return { root, logicalCall, statement: expression, executionContext: returnContext };
+  if (isAwaitedPromiseAllElement(expression))
+    return { root, logicalCall, statement: expression, executionContext: 'promise_aggregate' };
+  return undefined;
+}
+
+function expressionName(expression: ts.Expression): string {
+  if (ts.isIdentifier(expression)) return expression.text;
+  if (ts.isPropertyAccessExpression(expression))
+    return `${expressionName(expression.expression)}.${expression.name.text}`;
+  return expression.getText();
+}
+
+function unwrapQueryExpression(expression: ts.Expression): ts.Expression {
+  if (ts.isParenthesizedExpression(expression) || ts.isAwaitExpression(expression)
+    || ts.isAsExpression(expression) || ts.isTypeAssertionExpression(expression)
+    || ts.isNonNullExpression(expression) || ts.isSatisfiesExpression(expression))
+    return unwrapQueryExpression(expression.expression);
+  return expression;
+}
+
+function wrapperParent(node: ts.Expression): ts.Expression | undefined {
+  const parent = node.parent;
+  if ((ts.isParenthesizedExpression(parent) || ts.isAsExpression(parent)
+    || ts.isTypeAssertionExpression(parent) || ts.isNonNullExpression(parent)
+    || ts.isSatisfiesExpression(parent)) && parent.expression === node)
+    return parent;
+  return undefined;
+}
+
+function fluentCallParent(node: ts.Expression): ts.CallExpression | undefined {
+  const property = node.parent;
+  if (!ts.isPropertyAccessExpression(property) || property.expression !== node)
+    return undefined;
+  const call = property.parent;
+  return ts.isCallExpression(call) && call.expression === property ? call : undefined;
+}
+
+function outerFluentQueryCall(root: ts.CallExpression): ts.CallExpression {
+  let current: ts.Expression = root;
+  let outer = root;
+  while (true) {
+    const wrapper = wrapperParent(current);
+    if (wrapper) {
+      current = wrapper;
+      continue;
+    }
+    const next = fluentCallParent(current);
+    if (!next) return outer;
+    outer = next;
+    current = next;
+  }
+}
+
+function outerTransparentExpression(expression: ts.Expression): ts.Expression {
+  let current = expression;
+  while (true) {
+    const wrapper = wrapperParent(current);
+    if (!wrapper) return current;
+    current = wrapper;
+  }
+}
+
+function directAwaitExpression(
+  expression: ts.Expression,
+): ts.AwaitExpression | undefined {
+  const parent = expression.parent;
+  return ts.isAwaitExpression(parent) && parent.expression === expression
+    ? parent
+    : undefined;
+}
+
+function returnExecutionContext(
+  expression: ts.Expression,
+): DirectQueryExecutionContext | undefined {
+  const callable = returnedExpressionCallable(expression);
+  if (!callable) return undefined;
+  if (hasAsyncModifier(callable)) return 'async_return';
+  return hasGuaranteedPromiseReturn(callable) ? 'promise_return' : undefined;
+}
+
+function returnedExpressionCallable(
+  expression: ts.Expression,
+): ts.FunctionLikeDeclaration | undefined {
+  const parent = expression.parent;
+  if (ts.isArrowFunction(parent) && parent.body === expression) return parent;
+  if (!ts.isReturnStatement(parent) || parent.expression !== expression)
+    return undefined;
+  return nearestCallable(parent);
+}
+
+function nearestCallable(node: ts.Node): ts.FunctionLikeDeclaration | undefined {
+  let current = node.parent;
+  while (current) {
+    if (isRuntimeCallable(current)) return current;
+    current = current.parent;
+  }
+  return undefined;
+}
+
+function isRuntimeCallable(node: ts.Node): node is ts.FunctionLikeDeclaration {
+  return ts.isFunctionDeclaration(node) || ts.isFunctionExpression(node)
+    || ts.isArrowFunction(node) || ts.isMethodDeclaration(node)
+    || ts.isConstructorDeclaration(node) || ts.isGetAccessorDeclaration(node)
+    || ts.isSetAccessorDeclaration(node);
+}
+
+function hasAsyncModifier(node: ts.Node): boolean {
+  return !isGeneratorCallable(node) && ts.canHaveModifiers(node) && (ts.getModifiers(node)?.some(
+    (modifier) => modifier.kind === ts.SyntaxKind.AsyncKeyword,
+  ) ?? false);
+}
+
+function isGeneratorCallable(node: ts.Node): boolean {
+  return (ts.isFunctionDeclaration(node) || ts.isFunctionExpression(node)
+    || ts.isMethodDeclaration(node)) && Boolean(node.asteriskToken);
+}
+
+function hasGuaranteedPromiseReturn(
+  callable: ts.FunctionLikeDeclaration,
+): boolean {
+  const returnType = declaredReturnType(callable);
+  return Boolean(returnType && isGuaranteedPromiseType(returnType));
+}
+
+function declaredReturnType(
+  callable: ts.FunctionLikeDeclaration,
+): ts.TypeNode | undefined {
+  if (ts.isFunctionDeclaration(callable) || ts.isFunctionExpression(callable)
+    || ts.isArrowFunction(callable) || ts.isMethodDeclaration(callable))
+    return callable.type;
+  return undefined;
+}
+
+function isGuaranteedPromiseType(type: ts.TypeNode): boolean {
+  if (ts.isParenthesizedTypeNode(type))
+    return isGuaranteedPromiseType(type.type);
+  if (ts.isTypeReferenceNode(type))
+    return isStandardPromiseTypeName(type.typeName);
+  if (ts.isUnionTypeNode(type))
+    return type.types.length > 0 && type.types.every(isGuaranteedPromiseType);
+  if (ts.isIntersectionTypeNode(type))
+    return type.types.some(isGuaranteedPromiseType);
+  return false;
+}
+
+function isStandardPromiseTypeName(name: ts.EntityName): boolean {
+  if (ts.isIdentifier(name))
+    return name.text === 'Promise' || name.text === 'PromiseLike';
+  return ts.isIdentifier(name.left)
+    && (name.left.text === 'globalThis' || name.left.text === 'global')
+    && (name.right.text === 'Promise' || name.right.text === 'PromiseLike');
+}
+
+function isAwaitedPromiseAllElement(expression: ts.Expression): boolean {
+  const array = directArrayParent(expression);
+  if (!array) return false;
+  const aggregate = aggregateCallForArray(array);
+  return Boolean(aggregate && isBuiltInPromiseAll(aggregate)
+    && directAwaitExpression(outerTransparentExpression(aggregate)));
+}
+
+function directArrayParent(
+  expression: ts.Expression,
+): ts.ArrayLiteralExpression | undefined {
+  const parent = expression.parent;
+  return ts.isArrayLiteralExpression(parent) && parent.elements.some(
+    (element) => element === expression,
+  ) ? parent : undefined;
+}
+
+function aggregateCallForArray(
+  array: ts.ArrayLiteralExpression,
+): ts.CallExpression | undefined {
+  const argument = outerTransparentExpression(array);
+  const parent = argument.parent;
+  return ts.isCallExpression(parent) && parent.arguments.length === 1
+    && parent.arguments[0] === argument ? parent : undefined;
+}
+
+function isBuiltInPromiseAll(call: ts.CallExpression): boolean {
+  return ts.isPropertyAccessExpression(call.expression)
+    && ts.isIdentifier(call.expression.expression)
+    && call.expression.expression.text === 'Promise'
+    && call.expression.name.text === 'all'
+    && !hasPromiseValueShadow(call.getSourceFile());
+}
+
+function hasPromiseValueShadow(source: ts.SourceFile): boolean {
+  const cached = promiseValueShadowCache.get(source);
+  if (cached !== undefined) return cached;
+  let shadowed = false;
+  const visit = (node: ts.Node): void => {
+    if (shadowed) return;
+    if (declaresPromiseValue(node)) {
+      shadowed = true;
+      return;
+    }
+    ts.forEachChild(node, visit);
+  };
+  visit(source);
+  promiseValueShadowCache.set(source, shadowed);
+  return shadowed;
+}
+
+function declaresPromiseValue(node: ts.Node): boolean {
+  if (ts.isVariableDeclaration(node) || ts.isParameter(node))
+    return bindingNameIsPromise(node.name);
+  if (ts.isImportClause(node))
+    return !node.isTypeOnly && nodeIsPromise(node.name);
+  if (ts.isImportSpecifier(node))
+    return !node.isTypeOnly && nodeIsPromise(node.name);
+  if (ts.isNamespaceImport(node) || ts.isImportEqualsDeclaration(node))
+    return nodeIsPromise(node.name);
+  if (ts.isFunctionDeclaration(node) || ts.isClassDeclaration(node)
+    || ts.isEnumDeclaration(node) || ts.isModuleDeclaration(node))
+    return nodeIsPromise(node.name);
+  return false;
+}
+
+function bindingNameIsPromise(name: ts.BindingName): boolean {
+  if (ts.isIdentifier(name)) return name.text === 'Promise';
+  if (ts.isObjectBindingPattern(name))
+    return name.elements.some((element) => bindingNameIsPromise(element.name));
+  return name.elements.some((element) => ts.isBindingElement(element)
+    && bindingNameIsPromise(element.name));
+}
+
+function nodeIsPromise(name: ts.Node | undefined): boolean {
+  return Boolean(name && ts.isIdentifier(name) && name.text === 'Promise');
+}

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

@@ -8,6 +8,12 @@ import { summarizeExpression } from '../utils/redaction.js';
 import { classifyODataPathIntent } from '../linker/odata-path-normalizer.js';
 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 type { RepositorySourceContext } from './ts-project.js';
 import {
   analyzeOperationPath,
@@ -53,82 +59,12 @@ function queryEntityFromAst(expr: ts.Expression, initializers = new Map<string,
   if (ts.isCallExpression(unwrapped)) {
     const name = expressionName(unwrapped.expression);
     if (name === 'cds.run') return queryEntityFromAst(unwrapped.arguments[0], initializers);
-    if (capQueryBuilderRoots.has(name)) return entityFromExpression(unwrapped.arguments[0]);
+    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;
 }
-const capQueryBuilderRoots = new Set([
-  'SELECT.from',
-  'SELECT.one.from',
-  'SELECT.one',
-  'INSERT.into',
-  'UPSERT.into',
-  'UPDATE.entity',
-  'UPDATE',
-  'DELETE.from',
-]);
-interface DirectQueryBuilderStatement {
-  root: ts.CallExpression;
-  logicalCall: ts.CallExpression;
-  awaitExpression: ts.AwaitExpression;
-}
-function wrapperParent(node: ts.Expression): ts.Expression | undefined {
-  const parent = node.parent;
-  if ((ts.isParenthesizedExpression(parent) || ts.isAsExpression(parent)
-    || ts.isTypeAssertionExpression(parent) || ts.isNonNullExpression(parent)
-    || ts.isSatisfiesExpression(parent)) && parent.expression === node)
-    return parent;
-  return undefined;
-}
-function fluentCallParent(node: ts.Expression): ts.CallExpression | undefined {
-  const property = node.parent;
-  if (!ts.isPropertyAccessExpression(property) || property.expression !== node) return undefined;
-  const call = property.parent;
-  return ts.isCallExpression(call) && call.expression === property ? call : undefined;
-}
-function queryBuilderRoot(expr: ts.Expression): ts.CallExpression | undefined {
-  const unwrapped = unwrapQueryExpression(expr);
-  if (!ts.isCallExpression(unwrapped)) return undefined;
-  if (capQueryBuilderRoots.has(expressionName(unwrapped.expression))) return unwrapped;
-  return ts.isPropertyAccessExpression(unwrapped.expression)
-    ? queryBuilderRoot(unwrapped.expression.expression)
-    : undefined;
-}
-function outerFluentQueryCall(root: ts.CallExpression): ts.CallExpression {
-  let current: ts.Expression = root;
-  let outer = root;
-  while (true) {
-    const wrapper = wrapperParent(current);
-    if (wrapper) {
-      current = wrapper;
-      continue;
-    }
-    const next = fluentCallParent(current);
-    if (!next) return outer;
-    outer = next;
-    current = next;
-  }
-}
-function directQueryBuilderStatement(node: ts.CallExpression): DirectQueryBuilderStatement | undefined {
-  const root = queryBuilderRoot(node);
-  if (!root) return undefined;
-  const logicalCall = outerFluentQueryCall(root);
-  if (logicalCall !== node) return undefined;
-  let current: ts.Expression = logicalCall;
-  while (true) {
-    const wrapper = wrapperParent(current);
-    if (wrapper) {
-      current = wrapper;
-      continue;
-    }
-    const parent = current.parent;
-    return ts.isAwaitExpression(parent) && parent.expression === current
-      ? { root, logicalCall, awaitExpression: parent }
-      : undefined;
-  }
-}
 function queryBuilderEvidence(source: ts.SourceFile, statement: DirectQueryBuilderStatement): Record<string, unknown> {
   return {
     classifier: 'cap_query_builder_direct',
@@ -136,8 +72,9 @@ function queryBuilderEvidence(source: ts.SourceFile, statement: DirectQueryBuild
     queryRoot: expressionName(statement.root.expression),
     queryRootStartOffset: statement.root.getStart(source),
     queryRootEndOffset: statement.root.getEnd(),
-    queryStatementStartOffset: statement.awaitExpression.getStart(source),
-    queryStatementEndOffset: statement.awaitExpression.getEnd(),
+    queryStatementStartOffset: statement.statement.getStart(source),
+    queryStatementEndOffset: statement.statement.getEnd(),
+    queryExecutionContext: statement.executionContext,
   };
 }
 function queryRunEvidence(

package/src/parsers/symbol-parser.ts

@@ -184,6 +184,7 @@ export async function parseExecutableSymbols(
   const symbols: ExecutableSymbolFact[] = [];
   const calls: SymbolCallFact[] = [];
   const imports = new Map<string, string>();
+  const namespaceImports = new Set<string>();
   const exportNames = exportDeclarations(source);
   const objectExports = new Set<string>();
   const exportedClasses = new Set<string>();
@@ -214,7 +215,10 @@ export async function parseExecutableSymbols(
       if (clause?.name) imports.set(clause.name.text, sourceText);
       const named = clause?.namedBindings;
       if (named && ts.isNamedImports(named)) for (const el of named.elements) imports.set(el.name.text, sourceText);
-      if (named && ts.isNamespaceImport(named)) imports.set(named.name.text, sourceText);
+      if (named && ts.isNamespaceImport(named)) {
+        imports.set(named.name.text, sourceText);
+        namespaceImports.add(named.name.text);
+      }
     }
     if (ts.isVariableStatement(node)) {
       for (const declaration of node.declarationList.declarations) {
@@ -330,7 +334,9 @@ export async function parseExecutableSymbols(
         const instance = (callee.local ? classInstances.get(callee.local) : undefined) ?? (callee.receiver ? classInstances.get(callee.receiver) : undefined);
         const importSource = instance?.importSource ?? proxy?.importSource ?? (callee.local ? imports.get(callee.local) : undefined) ?? (callee.member && callee.local ? imports.get(callee.local) : undefined);
         const directThisMethod = callee.receiver === 'this';
-        const targetName = instance && callee.member ? `${instance.className}.${callee.member}` : proxy && callee.member ? callee.member : directThisMethod ? callee.member : callee.member && callee.local ? `${callee.local}.${callee.member}` : callee.local;
+        const namespaceMember = Boolean(callee.member && callee.local && namespaceImports.has(callee.local));
+        const packageImport = Boolean(importSource && !isRelativeImport(importSource));
+        const targetName = instance && callee.member ? `${instance.className}.${callee.member}` : proxy && callee.member ? callee.member : directThisMethod ? callee.member : namespaceMember ? callee.member : packageImport ? (callee.member ?? callee.local) : callee.member && callee.local ? `${callee.local}.${callee.member}` : callee.local;
         const className = caller.qualifiedName.includes('.') ? caller.qualifiedName.split('.')[0] : undefined;
         const thisTarget = directThisMethod && className && callee.member ? `${className}.${callee.member}` : undefined;
         const loggerLike = callee.receiver?.endsWith('.logger') || callee.local === 'logger' || (callee.expression.startsWith('this.logger.') && callee.member ? loggerMembers.has(callee.member) : false);
@@ -339,11 +345,11 @@ export async function parseExecutableSymbols(
         const provenThisMethod = Boolean(thisTarget && localCallables.has(thisTarget));
         const provenRelativeImport = Boolean(isRelativeImport(importSource) && targetName);
         const provenClassInstance = Boolean(instance && callee.member && targetName);
-        const importedFromPackage = Boolean(importSource && !isRelativeImport(importSource));
-        const ignored = loggerLike || terminalMember || importedFromPackage || ignoredFrameworkCall(callee);
+        const provenPackageImport = Boolean(packageImport && targetName);
+        const ignored = loggerLike || terminalMember || ignoredFrameworkCall(callee);
         const resolvedTarget = provenThisMethod ? thisTarget : targetName;
-        const keep = Boolean(resolvedTarget) && !ignored && (provenLocal || provenThisMethod || provenRelativeImport || provenClassInstance);
-        if (keep) calls.push({ callerQualifiedName: caller.qualifiedName, calleeExpression: callee.expression, calleeLocalName: resolvedTarget, receiverLocalName: callee.member ? (callee.local ?? callee.receiver) : undefined, importSource, sourceFile, sourceLine: line, evidence: { relation: instance ? 'class_instance_method' : proxy ? 'relative_import_proxy_member' : importSource ? 'relative_import' : provenThisMethod ? 'indexed_this_method' : 'indexed_local_symbol', caller: caller.qualifiedName, targetName: resolvedTarget, instanceVariable: instance ? (instance.propertyName ?? callee.local) : undefined, className: instance?.className, methodName: instance ? callee.member : undefined, classImportSource: instance?.importSource, callArguments: argumentEvidence(node.arguments, source), proxyVariableName: proxy?.variableName, factory: proxy?.factory, factoryExpression: proxy?.factory, factoryImportSource: proxy?.importSource, candidateStrategy: instance ? (instance.importSource ? 'relative_import_class_instance_method' : 'same_file_class_instance_method') : proxy ? 'proxy_member_exact_export_or_unique_member' : undefined } });
+        const keep = Boolean(resolvedTarget) && !ignored && (provenLocal || provenThisMethod || provenRelativeImport || provenClassInstance || provenPackageImport);
+        if (keep) calls.push({ callerQualifiedName: caller.qualifiedName, calleeExpression: callee.expression, calleeLocalName: resolvedTarget, receiverLocalName: callee.member ? (callee.local ?? callee.receiver) : undefined, importSource, sourceFile, sourceLine: line, evidence: { relation: instance ? 'class_instance_method' : proxy ? 'relative_import_proxy_member' : packageImport ? 'package_import' : namespaceMember ? 'relative_import_namespace_member' : importSource ? 'relative_import' : provenThisMethod ? 'indexed_this_method' : 'indexed_local_symbol', caller: caller.qualifiedName, targetName: resolvedTarget, instanceVariable: instance ? (instance.propertyName ?? callee.local) : undefined, className: instance?.className, methodName: instance ? callee.member : undefined, classImportSource: instance?.importSource, callArguments: argumentEvidence(node.arguments, source), proxyVariableName: proxy?.variableName, factory: proxy?.factory, factoryExpression: proxy?.factory, factoryImportSource: proxy?.importSource, candidateStrategy: instance ? (instance.importSource ? 'relative_import_class_instance_method' : 'same_file_class_instance_method') : proxy ? 'proxy_member_exact_export_or_unique_member' : undefined } });
       }
     }
     ts.forEachChild(node, visitCalls);