@saptools/service-flow 0.1.54 → 0.1.55

package/dist/index.js

@@ -17,7 +17,7 @@ import {
   stripQuotes,
   substituteVariables,
   trace
-} from "./chunk-ERIZHM5C.js";
+} from "./chunk-GXYVIHJ5.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.55",
   "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/outbound-call-parser.ts

@@ -40,19 +40,121 @@ 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 (capQueryBuilderRoots.has(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',
+    queryDispatch: 'direct_query_builder',
+    queryRoot: expressionName(statement.root.expression),
+    queryRootStartOffset: statement.root.getStart(source),
+    queryRootEndOffset: statement.root.getEnd(),
+    queryStatementStartOffset: statement.awaitExpression.getStart(source),
+    queryStatementEndOffset: statement.awaitExpression.getEnd(),
+  };
+}
+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 +200,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 +404,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 +523,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)) {