@saptools/service-flow 0.1.54 → 0.1.56

package/dist/index.js

@@ -17,7 +17,7 @@ import {
   stripQuotes,
   substituteVariables,
   trace
-} from "./chunk-ERIZHM5C.js";
+} from "./chunk-Y7H7ZU5B.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.54",
+  "version": "0.1.56",
   "description": "Trace SAP CAP service-to-service flows across multi-repository workspaces with runtime-aware graph resolution",
   "type": "module",
   "publishConfig": {

package/src/cli.ts

@@ -30,9 +30,17 @@ import { renderTraceTable } from './output/table-output.js';
 import { renderTraceJson, renderJson } from './output/json-output.js';
 import { renderDoctorDiagnostics } from './output/doctor-output.js';
 import { renderMermaid } from './output/mermaid-output.js';
+import { createStdoutWriter } from './output/000-stdout-policy.js';
 import { VERSION } from './version.js';
 import type { DynamicMode } from './types.js';
 import { cleanWorkspaceState } from './cli/000-clean.js';
+
+const stdout = createStdoutWriter(process.stdout, fail);
+
+function writeStdout(value: string): void {
+  stdout.write(value);
+}
+
 async function init(
   workspace: string,
   options: { db?: string; ignore?: string[] },
@@ -58,7 +66,7 @@ async function init(
     });
   }
   db.close();
-  process.stdout.write(
+  writeStdout(
     `Workspace: ${config.rootPath}\nDatabase: ${config.dbPath}\nRepositories: ${repos.length}\nIgnored: ${config.ignore.join(', ')}\nNext: service-flow index --workspace ${config.rootPath}\n`,
   );
 }
@@ -148,7 +156,7 @@ export function createProgram(): Command {
             repo: opts.repo,
             force: Boolean(opts.force),
           });
-          process.stdout.write(
+          writeStdout(
             `Indexed ${r.indexedCount} repositories, skipped ${r.skippedCount}, ${r.fileCount} files, ${r.diagnosticCount} diagnostics\n`,
           );
         }).catch(fail),
@@ -162,7 +170,7 @@ export function createProgram(): Command {
         void withWorkspace(opts.workspace, (db, workspaceId) => {
           const r = linkWorkspace(db, workspaceId);
           const upgradeWarnings = linkUpgradeWarnings(db);
-          process.stdout.write(
+          writeStdout(
             `${upgradeWarnings.length ? `Warnings: ${upgradeWarnings.map((item) => String(item.code)).join(', ')}. Run service-flow doctor --strict for remediation.\n` : ''}Linked ${r.edgeCount} edges: ${r.remoteResolvedCount} remote operation calls resolved, ${r.localResolvedCount} local operation calls resolved, ${r.unresolvedCount} unresolved operation calls, ${r.ambiguousCount} ambiguous operation calls, ${r.dynamicCount} dynamic operation calls, ${r.terminalCount} terminal call edges, ${r.dependencyResolvedCount} dependency resolved, ${r.dependencyAmbiguousCount} dependency ambiguous, ${r.implementationResolvedCount} implementation resolved, ${r.implementationAmbiguousCount} implementation ambiguous, ${r.implementationUnresolvedCount} implementation unresolved\n`,
           );
         }).catch(fail),
@@ -227,7 +235,7 @@ export function createProgram(): Command {
               maxDynamicCandidates: parsePositiveInteger(opts.maxDynamicCandidates, 5),
             },
           );
-          process.stdout.write(
+          writeStdout(
             opts.format === 'json'
               ? renderTraceJson(result)
               : opts.format === 'mermaid'
@@ -243,7 +251,7 @@ export function createProgram(): Command {
     .action(
       (opts: { workspace?: string }) =>
         void withReadOnlyWorkspace(opts.workspace, (db, workspaceId) =>
-          process.stdout.write(
+          writeStdout(
             renderJson(
               listRepositories(db, workspaceId).map((r) => ({
                 name: r.name,
@@ -265,7 +273,7 @@ export function createProgram(): Command {
             ? selectRepository(db, opts.repo, workspaceId)
             : {};
           if (selection.diagnostic) {
-            process.stdout.write(renderJson([selection.diagnostic]));
+            writeStdout(renderJson([selection.diagnostic]));
             return;
           }
           const repo = selection.repo;
@@ -274,7 +282,7 @@ export function createProgram(): Command {
               'SELECT r.name repo,s.service_path servicePath,s.qualified_name qualifiedName FROM cds_services s JOIN repositories r ON r.id=s.repo_id WHERE r.workspace_id=? AND (? IS NULL OR s.repo_id=?) ORDER BY r.name,s.service_path',
             )
             .all(workspaceId, repo?.id, repo?.id);
-          process.stdout.write(renderJson(rows));
+          writeStdout(renderJson(rows));
         }).catch(fail),
     );
   list
@@ -289,7 +297,7 @@ export function createProgram(): Command {
             ? selectRepository(db, opts.repo, workspaceId)
             : {};
           if (selection.diagnostic) {
-            process.stdout.write(renderJson([selection.diagnostic]));
+            writeStdout(renderJson([selection.diagnostic]));
             return;
           }
           const repo = selection.repo;
@@ -298,7 +306,7 @@ export function createProgram(): Command {
               'SELECT r.name repo,s.service_path servicePath,o.operation_name operation,o.operation_path path FROM cds_operations o JOIN cds_services s ON s.id=o.service_id JOIN repositories r ON r.id=s.repo_id WHERE r.workspace_id=? AND (? IS NULL OR s.repo_id=?) AND (? IS NULL OR s.service_path=?)',
             )
             .all(workspaceId, repo?.id, repo?.id, opts.service, opts.service);
-          process.stdout.write(renderJson(rows));
+          writeStdout(renderJson(rows));
         }).catch(fail),
     );
   list
@@ -313,7 +321,7 @@ export function createProgram(): Command {
             ? selectRepository(db, opts.repo, workspaceId)
             : {};
           if (selection.diagnostic) {
-            process.stdout.write(renderJson([selection.diagnostic]));
+            writeStdout(renderJson([selection.diagnostic]));
             return;
           }
           const repo = selection.repo;
@@ -330,7 +338,7 @@ export function createProgram(): Command {
               opts.operation ? `/${opts.operation}` : undefined,
               opts.operation ? `%${opts.operation}%` : undefined,
             );
-          process.stdout.write(renderJson(rows));
+          writeStdout(renderJson(rows));
         }).catch(fail),
     );
   program
@@ -382,7 +390,7 @@ export function createProgram(): Command {
               maxDynamicCandidates: parsePositiveInteger(opts.maxDynamicCandidates, 5),
             },
           );
-          process.stdout.write(
+          writeStdout(
             opts.format === 'json'
               ? renderTraceJson(result)
               : renderMermaid(result),
@@ -398,7 +406,7 @@ export function createProgram(): Command {
       (name: string, opts: { workspace?: string }) =>
         void withReadOnlyWorkspace(opts.workspace, (db, workspaceId) => {
           const selection = selectRepository(db, name, workspaceId);
-          process.stdout.write(renderJson(
+          writeStdout(renderJson(
             selection.repo ?? selection.diagnostic ?? { error: 'repo not found' },
           ));
         }).catch(fail),
@@ -415,7 +423,7 @@ export function createProgram(): Command {
               'SELECT o.* FROM cds_operations o JOIN cds_services s ON s.id=o.service_id JOIN repositories r ON r.id=s.repo_id WHERE r.workspace_id=? AND (o.operation_name=? OR o.operation_path=?)',
             )
             .all(workspaceId, selector, selector);
-          process.stdout.write(renderJson(rows));
+          writeStdout(renderJson(rows));
         }).catch(fail),
     );
   program
@@ -428,7 +436,7 @@ export function createProgram(): Command {
       (opts: { workspace?: string; strict?: boolean; detail?: boolean; format?: string }) =>
         void withReadOnlyWorkspace(opts.workspace, (db) => {
           const allDiagnostics = doctorDiagnostics(db, Boolean(opts.strict), { detail: Boolean(opts.detail) });
-          process.stdout.write(renderDoctorDiagnostics(allDiagnostics, opts.format));
+          writeStdout(renderDoctorDiagnostics(allDiagnostics, opts.format));
         }).catch(fail),
     );
   program
@@ -440,7 +448,7 @@ export function createProgram(): Command {
         void (async () => {
           const config = await loadWorkspaceConfig(opts.workspace);
           await cleanWorkspaceState(config, Boolean(opts.dbOnly));
-          process.stdout.write('Cleaned service-flow state\n');
+          writeStdout('Cleaned service-flow state\n');
         })().catch(fail),
     );
   return program;

package/src/output/000-stdout-policy.ts

@@ -0,0 +1,65 @@
+import type { Writable } from 'node:stream';
+
+export interface StdoutWriter {
+  write(value: string): boolean;
+}
+
+interface OutputState {
+  blocked: boolean;
+  unexpectedReported: boolean;
+}
+
+interface WriterEntry {
+  state: OutputState;
+  writer: StdoutWriter;
+}
+
+const writers = new WeakMap<Writable, WriterEntry>();
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return Boolean(value && typeof value === 'object' && !Array.isArray(value));
+}
+
+function isBrokenPipe(error: Error): boolean {
+  return isRecord(error) && error.code === 'EPIPE';
+}
+
+function asError(value: unknown): Error {
+  return value instanceof Error ? value : new Error(String(value));
+}
+
+function handleStreamError(
+  state: OutputState,
+  error: Error,
+  onUnexpectedError: (error: Error) => void,
+): void {
+  state.blocked = true;
+  if (isBrokenPipe(error) || state.unexpectedReported) return;
+  state.unexpectedReported = true;
+  onUnexpectedError(error);
+}
+
+export function createStdoutWriter(
+  stream: Writable,
+  onUnexpectedError: (error: Error) => void,
+): StdoutWriter {
+  const existing = writers.get(stream);
+  if (existing) return existing.writer;
+  const state: OutputState = { blocked: false, unexpectedReported: false };
+  const writer: StdoutWriter = {
+    write(value: string): boolean {
+      if (state.blocked) return false;
+      try {
+        stream.write(value);
+        return true;
+      } catch (error) {
+        handleStreamError(state, asError(error), onUnexpectedError);
+        return false;
+      }
+    },
+  };
+  stream.on('error', (error: Error) =>
+    handleStreamError(state, error, onUnexpectedError));
+  writers.set(stream, { state, writer });
+  return writer;
+}

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,
@@ -40,19 +46,52 @@ function variableInitializers(source: ts.SourceFile): Map<string, ts.Expression>
   }
   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 {
-  if (ts.isParenthesizedExpression(expr) || ts.isAwaitExpression(expr)) return queryEntityFromAst(expr.expression, initializers);
-  if (ts.isIdentifier(expr) && initializers.has(expr.text)) return queryEntityFromAst(initializers.get(expr.text) as ts.Expression, initializers);
-  if (ts.isCallExpression(expr)) {
-    const name = expressionName(expr.expression);
-    if (name === 'cds.run') return queryEntityFromAst(expr.arguments[0], initializers);
-    if (['SELECT.one.from', 'SELECT.from', 'SELECT.one', 'INSERT.into', 'UPSERT.into', 'DELETE.from', 'UPDATE.entity'].includes(name)) return entityFromExpression(expr.arguments[0]);
-    if (name === 'UPDATE') return entityFromExpression(expr.arguments[0]);
-    const receiver = ts.isPropertyAccessExpression(expr.expression) ? expr.expression.expression : 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',
+    queryDispatch: 'direct_query_builder',
+    queryRoot: expressionName(statement.root.expression),
+    queryRootStartOffset: statement.root.getStart(source),
+    queryRootEndOffset: statement.root.getEnd(),
+    queryStatementStartOffset: statement.statement.getStart(source),
+    queryStatementEndOffset: statement.statement.getEnd(),
+    queryExecutionContext: statement.executionContext,
+  };
+}
+function queryRunEvidence(
+  source: ts.SourceFile,
+  argument: ts.Expression | undefined,
+): Record<string, unknown> {
+  const root = argument ? queryBuilderRoot(argument) : undefined;
+  return {
+    classifier: 'cap_query_run_wrapper',
+    queryDispatch: 'cds_run_wrapper',
+    ...(root ? {
+      queryRoot: expressionName(root.expression),
+      queryRootStartOffset: root.getStart(source),
+      queryRootEndOffset: root.getEnd(),
+    } : {}),
+  };
+}
 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);
@@ -98,7 +137,6 @@ function nameOfProperty(name: ts.PropertyName): string | undefined {
   if (ts.isIdentifier(name) || ts.isStringLiteral(name) || ts.isNumericLiteral(name)) return name.text;
   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 }
@@ -303,7 +341,6 @@ function externalHttpEvidence(node: ts.CallExpression, source: ts.SourceFile): {
   }
   return undefined;
 }
-
 function collectServiceVariables(source: ts.SourceFile): Set<string> {
   const vars = new Set<string>(['cds', 'messaging', 'messageClient', 'eventClient']);
   const visit = (node: ts.Node): void => {
@@ -423,11 +460,16 @@ export function classifyOutboundCallsInSource(source: ts.SourceFile, filePath: s
       }
       const expr = node.expression;
       const exprText = expr.getText(source);
+      const directQuery = directQueryBuilderStatement(node);
       if (exprText === 'cds.run') {
         const arg = node.arguments[0];
         const entity = arg ? queryEntityFromAst(arg, initializers) : undefined;
         const payload = arg?.getText(source) ?? '';
-        add(node, { callType: 'local_db_query', queryEntity: entity, payloadSummary: summarizeExpression(payload), confidence: entity ? 0.9 : 0.55, unresolvedReason: entity ? undefined : queryWarning(payload) });
+        add(node, { callType: 'local_db_query', queryEntity: entity, payloadSummary: summarizeExpression(payload), confidence: entity ? 0.9 : 0.55, unresolvedReason: entity ? undefined : queryWarning(payload) }, queryRunEvidence(source, arg));
+      } else if (directQuery) {
+        const entity = queryEntityFromAst(directQuery.logicalCall, initializers);
+        const payload = directQuery.logicalCall.getText(source);
+        add(directQuery.logicalCall, { callType: 'local_db_query', queryEntity: entity, payloadSummary: summarizeExpression(payload), confidence: entity ? 0.9 : 0.55, unresolvedReason: entity ? undefined : queryWarning(payload) }, queryBuilderEvidence(source, directQuery));
       } else if (ts.isPropertyAccessExpression(expr) && expr.name.text === 'send' && (ts.isIdentifier(expr.expression) || ts.isPropertyAccessExpression(expr.expression))) {
         const objectArg = node.arguments[0];
         if (objectArg && ts.isObjectLiteralExpression(objectArg)) {