@saptools/service-flow 0.1.54 → 0.1.55

package/CHANGELOG.md

@@ -1,5 +1,10 @@
 # Changelog
 
+## 0.1.55
+
+- Indexed directly awaited CAP query-builder statements as local database calls, preserving exact builder-root evidence, fluent statement offsets, dynamic-entity warnings, method ownership, and the existing single `cds.run(...)` fact.
+- Made normal CLI stdout pipeline-safe: an early downstream pipe close stops further output without an unhandled `EPIPE` stack trace, while unrelated stream failures remain non-zero diagnostics.
+
 ## 0.1.54
 
 - Made contextual dynamic trace diagnostics runtime-current after `--var` substitution while retaining labelled pre-substitution binding state and distinct structural blockers.

package/README.md

@@ -156,6 +156,10 @@ service-flow link --workspace /path/to/workspace --force
 | `--workspace <path>` | Workspace to link |
 | `--force` | Accepted for workflow symmetry; linking always rebuilds graph edges |
 
+### Pipeline-safe output
+
+Normal command output is safe to pipe to a Unix consumer that intentionally stops reading early. A closed stdout pipe stops further output without an unhandled `EPIPE` stack trace; unrelated stdout failures still use the normal stderr diagnostic and non-zero exit outcome. Complete JSON, table, and Mermaid output bytes are unchanged.
+
 ### 🧵 `service-flow trace`
 
 Trace one starting point and render table, JSON, or Mermaid output. Trace now
@@ -170,7 +174,7 @@ Local CAP calls through `cds.services.<Service>.<operation>()`, bracket service
 
 Conservative local symbol traversal intentionally excludes decorators, built-ins such as `JSON.parse`, collection methods, third-party APIs, and arbitrary property chains unless the callee can plausibly resolve to an indexed local symbol. Named export lists such as `export { loadTemplate as publicLoadTemplate }` are indexed with the public exported name so relative imports can resolve. One-level object-literal helpers are indexed as symbols named like `cacheHelper.getConfiguration`; nested object literals are not yet expanded beyond the first helper level. `parseGeneratedConstants` remains a public low-level parser export for callers that need it, but generated constants are not persisted as graph facts in this patch; linking uses the deterministic decorator normalizer described above.
 JSON output includes typed nodes for calls, operations, database entities,
-external destinations, and unresolved/dynamic candidates when edges exist. Chained CAP DB queries inside `cds.run(...)` are parsed with TypeScript AST evidence for `SELECT`, `INSERT`, `UPDATE`, and `DELETE` forms. When the query target is genuinely dynamic, graph status remains terminal and JSON retains `parserWarning` evidence, while table and Mermaid render the target as `Entity: unknown` rather than a numeric call id.
+external destinations, and unresolved/dynamic candidates when edges exist. Chained CAP DB queries inside `cds.run(...)` and directly awaited supported builders are parsed with TypeScript AST evidence for `SELECT`, `INSERT`, `UPSERT`, `UPDATE`, and `DELETE` forms. Direct builders must have a recognized CAP root; unrelated methods named `from`, `where`, or `set` are not promoted to database facts. When the query target is genuinely dynamic, graph status remains terminal and JSON retains `parserWarning` evidence, while table and Mermaid render the target as `Entity: unknown` rather than a numeric call id.
 
 ```bash
 service-flow trace --workspace /path/to/workspace --repo facade-service --operation doWork
@@ -270,9 +274,10 @@ External HTTP facts use semantic terminal nodes instead of outbound-call row ids
   a concrete client. Trace evidence includes the caller variable, returned
   property, imported helper, source file, exported symbol, placeholders, and
   transaction alias steps.
-- `SELECT.one.from(Entity)`, `SELECT.from(Entity)`, `INSERT.into(Entity)`,
-  `UPDATE(Entity)`, and `DELETE.from(Entity)` are indexed as local database
-  query entities when statically knowable.
+- Direct awaited `SELECT.one.from(Entity)`, `SELECT.from(Entity)`,
+  `INSERT.into(Entity)`, `UPSERT.into(Entity)`, `UPDATE(Entity)`, and
+  `DELETE.from(Entity)` statements, plus equivalent `cds.run(...)` queries,
+  are indexed as local database query entities when statically knowable.
 - `doctor` reports silent quality problems such as services without operations,
   handler repositories without CDS service facts, and an empty search index.
 
@@ -336,7 +341,7 @@ service-flow clean --workspace /path/to/workspace
 | Handler facts | `cds-routing-handlers` decorators, handler classes/methods, server registrations |
 | Service bindings | `cds.connect.to("alias")`, aliases from `package.json#cds.requires`, destination/service path expressions |
 | Outbound calls | `remote.send({ method, path })`, `remote.send({ query })`, `cds.services.Service.operation()`, service wrapper calls |
-| Local data access | `cds.run(SELECT...)` and local entity query evidence |
+| Local data access | direct awaited CAP query builders, `cds.run(SELECT...)`, and local entity query evidence |
 | Async channels | Event Mesh-style `emit`, `publish`, and `on` facts |
 | External calls | Cloud SDK-style HTTP/destination calls and external edge evidence |
 | Generated constants | low-level `parseGeneratedConstants` parser output for integrations; not persisted as first-class graph facts in this patch |

package/TECHNICAL-NOTE.md

@@ -1,5 +1,11 @@
 # Service Flow Resolution Notes
 
+## 0.1.55 direct query-builder and stdout notes
+
+- Direct, awaited CAP builders now create one `local_db_query` fact when their AST root is a supported `SELECT`, `INSERT`, `UPSERT`, `UPDATE`, or `DELETE` form. The parser follows fluent continuations and transparent TypeScript wrappers, records the direct dispatch marker plus root and statement offsets, and keeps ordinary member-name lookalikes out of database facts. A builder nested in `cds.run(...)` remains one wrapper-dispatched fact.
+- Static entities retain high confidence. Dynamic entity expressions retain the existing terminal unknown-entity behavior and parser warning; neither form evaluates application expressions. Fact insertion continues to use the logical statement location, so the narrowest executable symbol owns lifecycle and operation-method queries independently.
+- CLI command output uses one shared stdout policy. `EPIPE` from an early-closing Unix consumer marks output complete and suppresses later writes. Other stdout errors are reported through the existing failure path, so valid full JSON, table, and Mermaid bytes are unchanged and genuine failures still exit non-zero.
+
 ## 0.1.54 runtime-current diagnostics and selected handler notes
 
 - Contextual service-binding resolution now emits typed local trace state instead of passing a message string as control flow. `dynamic_missing`, `ambiguous_binding`, `ambiguous_operation`, `no_matching_operation`, and other conservative blockers remain distinguishable; `contextualPreSubstitutionState` preserves the historical attempt without changing a persisted graph row.

package/dist/{chunk-ERIZHM5C.js → chunk-GXYVIHJ5.js}

@@ -3045,19 +3045,105 @@ function variableInitializers(source) {
   }
   return initializers;
 }
+function unwrapQueryExpression(expr) {
+  if (ts8.isParenthesizedExpression(expr) || ts8.isAwaitExpression(expr) || ts8.isAsExpression(expr) || ts8.isTypeAssertionExpression(expr) || ts8.isNonNullExpression(expr) || ts8.isSatisfiesExpression(expr))
+    return unwrapQueryExpression(expr.expression);
+  return expr;
+}
 function queryEntityFromAst(expr, initializers = /* @__PURE__ */ new Map()) {
-  if (ts8.isParenthesizedExpression(expr) || ts8.isAwaitExpression(expr)) return queryEntityFromAst(expr.expression, initializers);
-  if (ts8.isIdentifier(expr) && initializers.has(expr.text)) return queryEntityFromAst(initializers.get(expr.text), initializers);
-  if (ts8.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 = ts8.isPropertyAccessExpression(expr.expression) ? expr.expression.expression : void 0;
+  const unwrapped = unwrapQueryExpression(expr);
+  if (ts8.isIdentifier(unwrapped) && initializers.has(unwrapped.text)) return queryEntityFromAst(initializers.get(unwrapped.text), initializers);
+  if (ts8.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 = ts8.isPropertyAccessExpression(unwrapped.expression) ? unwrapped.expression.expression : void 0;
     if (receiver) return queryEntityFromAst(receiver, initializers);
   }
   return void 0;
 }
+var capQueryBuilderRoots = /* @__PURE__ */ new Set([
+  "SELECT.from",
+  "SELECT.one.from",
+  "SELECT.one",
+  "INSERT.into",
+  "UPSERT.into",
+  "UPDATE.entity",
+  "UPDATE",
+  "DELETE.from"
+]);
+function wrapperParent(node) {
+  const parent = node.parent;
+  if ((ts8.isParenthesizedExpression(parent) || ts8.isAsExpression(parent) || ts8.isTypeAssertionExpression(parent) || ts8.isNonNullExpression(parent) || ts8.isSatisfiesExpression(parent)) && parent.expression === node)
+    return parent;
+  return void 0;
+}
+function fluentCallParent(node) {
+  const property = node.parent;
+  if (!ts8.isPropertyAccessExpression(property) || property.expression !== node) return void 0;
+  const call = property.parent;
+  return ts8.isCallExpression(call) && call.expression === property ? call : void 0;
+}
+function queryBuilderRoot(expr) {
+  const unwrapped = unwrapQueryExpression(expr);
+  if (!ts8.isCallExpression(unwrapped)) return void 0;
+  if (capQueryBuilderRoots.has(expressionName(unwrapped.expression))) return unwrapped;
+  return ts8.isPropertyAccessExpression(unwrapped.expression) ? queryBuilderRoot(unwrapped.expression.expression) : void 0;
+}
+function outerFluentQueryCall(root) {
+  let current = 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) {
+  const root = queryBuilderRoot(node);
+  if (!root) return void 0;
+  const logicalCall = outerFluentQueryCall(root);
+  if (logicalCall !== node) return void 0;
+  let current = logicalCall;
+  while (true) {
+    const wrapper = wrapperParent(current);
+    if (wrapper) {
+      current = wrapper;
+      continue;
+    }
+    const parent = current.parent;
+    return ts8.isAwaitExpression(parent) && parent.expression === current ? { root, logicalCall, awaitExpression: parent } : void 0;
+  }
+}
+function queryBuilderEvidence(source, statement) {
+  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, argument) {
+  const root = argument ? queryBuilderRoot(argument) : void 0;
+  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) {
   const source = ts8.createSourceFile("query.ts", `const __query = (${expr});`, ts8.ScriptTarget.Latest, true, ts8.ScriptKind.TS);
   const initializers = variableInitializers(source);
@@ -3410,11 +3496,16 @@ function classifyOutboundCallsInSource(source, filePath) {
       }
       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) : void 0;
         const payload = arg?.getText(source) ?? "";
-        add(node, { callType: "local_db_query", queryEntity: entity, payloadSummary: summarizeExpression(payload), confidence: entity ? 0.9 : 0.55, unresolvedReason: entity ? void 0 : queryWarning(payload) });
+        add(node, { callType: "local_db_query", queryEntity: entity, payloadSummary: summarizeExpression(payload), confidence: entity ? 0.9 : 0.55, unresolvedReason: entity ? void 0 : 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 ? void 0 : queryWarning(payload) }, queryBuilderEvidence(source, directQuery));
       } else if (ts8.isPropertyAccessExpression(expr) && expr.name.text === "send" && (ts8.isIdentifier(expr.expression) || ts8.isPropertyAccessExpression(expr.expression))) {
         const objectArg = node.arguments[0];
         if (objectArg && ts8.isObjectLiteralExpression(objectArg)) {
@@ -8250,4 +8341,4 @@ export {
   selectorRepoAmbiguousDiagnostic,
   trace
 };
-//# sourceMappingURL=chunk-ERIZHM5C.js.map
+//# sourceMappingURL=chunk-GXYVIHJ5.js.map