@saptools/service-flow 0.1.68 → 0.1.69

package/src/linker/cross-repo-linker.ts

@@ -1,19 +1,9 @@
 import type { Db } from '../db/connection.js';
-import { applyVariables } from './dynamic-edge-resolver.js';
-import { classifyODataPathIntent, normalizeODataOperationInvocationPath } from './odata-path-normalizer.js';
-import { buildRemoteQueryTarget } from './remote-query-target.js';
-import { resolveOperation } from './service-resolver.js';
 import { linkHelperPackages } from './helper-package-linker.js';
-import { externalHttpTarget } from './external-http-target.js';
 import { linkImplementations as linkCanonicalImplementations } from './000-implementation-candidates.js';
-import {
-  ambiguousPathCandidates,
-  linkedCallEvidence,
-  objectJson,
-  objectValue,
-} from './002-call-evidence.js';
 import { linkPackageImportSymbolCalls } from './003-package-import-symbol-resolver.js';
 import { linkEventSubscriptionHandlers } from './004-event-subscription-handler-linker.js';
+import { insertCallEdge } from './007-call-edge-insertion.js';
 import { assertWorkspaceLinkable } from '../db/001-fact-lifecycle.js';
 export interface LinkWorkspaceResult {
   edgeCount: number;
@@ -43,7 +33,7 @@ export function linkWorkspace(db: Db, workspaceId: number, vars: Record<string,
     db.prepare('DELETE FROM graph_edges WHERE workspace_id=?').run(workspaceId);
     const deps = linkHelperPackages(db, workspaceId, generation);
     const subscriptions = linkEventSubscriptionHandlers(
-      db, workspaceId, generation,
+      db, workspaceId, generation, vars,
     );
     const impl = linkCanonicalImplementations(db, workspaceId, generation);
     const callSummary = linkCalls(db, workspaceId, vars, generation);
@@ -89,156 +79,3 @@ function linkCalls(db: Db, workspaceId: number, vars: Record<string, string>, ge
   }
   return { edgeCount, unresolvedCount, resolvedCount, remoteResolvedCount, localResolvedCount, ambiguousCount, dynamicCount, terminalCount };
 }
-function insertCallEdge(db: Db, workspaceId: number, call: Record<string, unknown>, vars: Record<string, string>, generation: number): { status: string; callType: string } {
-  const callType = String(call.call_type);
-  const rawOp = applyVariables(String(call.operation_path_expr ?? ''), vars);
-  const intent = classifyODataPathIntent(rawOp, call.method as string | undefined);
-  const isEntityQueryIntent = ['entity_query', 'entity_key_read', 'entity_navigation_query'].includes(intent.kind);
-  const resolutionRawOp = callType === 'remote_query' && isEntityQueryIntent ? intent.pathWithoutQuery : rawOp;
-  const normalized = normalizeODataOperationInvocationPath(resolutionRawOp);
-  const op = normalized?.normalizedOperationPath ?? resolutionRawOp;
-  const servicePath = applyVariables((call.servicePathExpr as string | undefined) ?? (call.requireServicePath as string | undefined), vars);
-  const destination = (call.destinationExpr as string | undefined) ?? (call.requireDestination as string | undefined);
-  const isDynamic = Boolean(Number(call.isDynamic ?? 0));
-  const isRemoteEntityCall = callType.startsWith('remote_entity_');
-  const indexedOperationCandidateCount = operationCandidateCount(db, workspaceId, op, intent.topLevelOperationName);
-  const credibleOperationSignal = Boolean(normalized?.wasInvocation) || (Boolean(intent.topLevelOperationNameCandidate) && indexedOperationCandidateCount > 0);
-  const strongEntitySignal = ['entity_media', 'entity_delete', 'entity_key_read', 'entity_navigation_query'].includes(intent.kind) || (intent.kind === 'entity_mutation' && (intent.hasEntityKeyPredicate || intent.hasNavigationSuffix));
-  const operationLikeRemoteEntity = isRemoteEntityCall && Boolean(op) && credibleOperationSignal && (!strongEntitySignal || indexedOperationCandidateCount > 0);
-  const isOperationCall = operationLikeRemoteEntity || ((callType === 'remote_action' || callType === 'local_service_call') || (callType === 'remote_query' && Boolean(op)));
-  const resolution = isOperationCall ? resolveOperation(db, { servicePath, operationPath: op, serviceName: call.local_service_name as string | undefined, repoId: callType === 'local_service_call' ? Number(call.repo_id) : undefined, alias: applyVariables((call.aliasExpr as string | undefined) ?? (call.alias as string | undefined), vars), destination: destination ? applyVariables(destination, vars) : undefined, isDynamic, hasExplicitOverride: Object.keys(vars).length > 0 || callType === 'local_service_call' }, workspaceId) : { status: 'unresolved' as const, candidates: [], reasons: [] };
-  const evidence: Record<string, unknown> = {
-    ...linkedCallEvidence(
-      call,
-      resolution,
-      servicePath,
-      op,
-      destination ? applyVariables(destination, vars) : undefined,
-      normalized,
-      intent,
-    ),
-    indexedOperationCandidateCount,
-    parserCallType: callType,
-    entityOperationPrecedence: operationPrecedence(
-      callType,
-      intent,
-      indexedOperationCandidateCount,
-      Boolean(resolution.target),
-    ),
-  };
-  const pathAnalysis = objectValue(objectJson(call.evidence_json)?.pathAnalysis);
-  if (callType === 'remote_action' && pathAnalysis?.status === 'ambiguous') {
-    const candidatePaths = ambiguousPathCandidates(pathAnalysis);
-    db.prepare('INSERT INTO graph_edges(workspace_id,edge_type,status,from_kind,from_id,to_kind,to_id,confidence,evidence_json,is_dynamic,unresolved_reason,generation) VALUES(?,?,?,?,?,?,?,?,?,?,?,?)').run(
-      workspaceId,
-      'UNRESOLVED_EDGE',
-      'ambiguous',
-      'call',
-      String(call.id),
-      'operation_candidates',
-      candidatePaths.items.join(','),
-      Number(call.confidence ?? 0.5),
-      JSON.stringify({
-        ...evidence,
-        ambiguousOperationPathCandidateCount: candidatePaths.totalCount,
-        shownAmbiguousOperationPathCandidateCount: candidatePaths.shownCount,
-        omittedAmbiguousOperationPathCandidateCount: candidatePaths.omittedCount,
-      }),
-      0,
-      'Ambiguous operation path candidates require explicit disambiguation',
-      generation,
-    );
-    return { status: 'ambiguous', callType };
-  }
-  if (isRemoteEntityCall && (resolution.target || resolution.candidates.length > 0 || resolution.status === 'dynamic')) {
-    if (resolution.target) {
-      db.prepare('INSERT INTO graph_edges(workspace_id,edge_type,status,from_kind,from_id,to_kind,to_id,confidence,evidence_json,is_dynamic,generation) VALUES(?,?,?,?,?,?,?,?,?,?,?)').run(workspaceId, 'REMOTE_CALL_RESOLVES_TO_OPERATION', 'resolved', 'call', String(call.id), 'operation', String(resolution.target.operationId), resolution.target.score, JSON.stringify({ ...evidence, operationEntityPrecedence: 'indexed_operation_over_parser_entity' }), 0, generation);
-      return { status: 'resolved', callType };
-    }
-    const status = resolution.status === 'dynamic' ? 'dynamic' : resolution.status === 'ambiguous' ? 'ambiguous' : 'unresolved';
-    db.prepare('INSERT INTO graph_edges(workspace_id,edge_type,status,from_kind,from_id,to_kind,to_id,confidence,evidence_json,is_dynamic,unresolved_reason,generation) VALUES(?,?,?,?,?,?,?,?,?,?,?,?)').run(workspaceId, status === 'dynamic' ? 'DYNAMIC_EDGE_CANDIDATE' : 'UNRESOLVED_EDGE', status, 'call', String(call.id), 'operation_candidate', op ? `Remote action: ${op}` : 'Remote action: unknown path', Number(call.confidence ?? 0.2), JSON.stringify({ ...evidence, operationEntityPrecedence: resolution.candidates.length > 0 ? 'parser_entity_with_indexed_operation_candidates' : 'parser_entity_operation_candidate_without_indexed_match' }), status === 'dynamic' ? 1 : 0, unresolvedOperationReason(resolution), generation);
-    return { status, callType };
-  }
-  if (isRemoteEntityCall) {
-    const target = buildRemoteQueryTarget({ queryEntity: intent.entitySegment ?? call.query_entity, servicePath, serviceAlias: call.alias, serviceAliasExpr: call.aliasExpr, destination: destination ? applyVariables(destination, vars) : undefined, isDynamic, parserWarning: evidence.parserWarning });
-    const entityKind = callType;
-    db.prepare('INSERT INTO graph_edges(workspace_id,edge_type,status,from_kind,from_id,to_kind,to_id,confidence,evidence_json,is_dynamic,generation) VALUES(?,?,?,?,?,?,?,?,?,?,?)').run(workspaceId, 'HANDLER_ACCESSES_REMOTE_ENTITY', 'terminal', 'call', String(call.id), target.toKind, target.toId, Number(call.confidence ?? 0.5), JSON.stringify({ ...evidence, ...target.evidence, remoteEntityAccess: entityKind }), 0, generation);
-    return { status: 'terminal', callType };
-  }
-  if (callType === 'remote_query' && (isEntityQueryIntent || !op) && !resolution.target) {
-    const target = buildRemoteQueryTarget({ queryEntity: call.query_entity, servicePath, serviceAlias: call.alias, serviceAliasExpr: call.aliasExpr, destination: destination ? applyVariables(destination, vars) : undefined, isDynamic, parserWarning: evidence.parserWarning });
-    db.prepare('INSERT INTO graph_edges(workspace_id,edge_type,status,from_kind,from_id,to_kind,to_id,confidence,evidence_json,is_dynamic,generation) VALUES(?,?,?,?,?,?,?,?,?,?,?)').run(workspaceId, 'HANDLER_RUNS_REMOTE_QUERY', 'terminal', 'call', String(call.id), target.toKind, target.toId, Number(call.confidence ?? 0.5), JSON.stringify({ ...evidence, ...target.evidence }), 0, generation);
-    return { status: 'terminal', callType };
-  }
-  if (callType === 'local_service_call' && call.unresolved_reason === 'transport_client_method' && !resolution.target && resolution.candidates.length === 0) {
-    db.prepare('INSERT INTO graph_edges(workspace_id,edge_type,status,from_kind,from_id,to_kind,to_id,confidence,evidence_json,is_dynamic,generation) VALUES(?,?,?,?,?,?,?,?,?,?,?)').run(workspaceId, 'HANDLER_CALLS_TRANSPORT_METHOD', 'terminal', 'call', String(call.id), 'transport_method', String(op || 'transport_client_method'), Number(call.confidence ?? 0.5), JSON.stringify({ ...evidence, classification: 'transport_client_method' }), 0, generation);
-    return { status: 'terminal', callType };
-  }
-  if (resolution.target) {
-    db.prepare('INSERT INTO graph_edges(workspace_id,edge_type,status,from_kind,from_id,to_kind,to_id,confidence,evidence_json,is_dynamic,generation) VALUES(?,?,?,?,?,?,?,?,?,?,?)').run(workspaceId, callType === 'local_service_call' ? 'LOCAL_CALL_RESOLVES_TO_OPERATION' : 'REMOTE_CALL_RESOLVES_TO_OPERATION', 'resolved', 'call', String(call.id), 'operation', String(resolution.target.operationId), resolution.target.score, JSON.stringify(evidence), 0, generation);
-    return { status: 'resolved', callType };
-  }
-  const edgeType = callType === 'local_db_query' ? 'HANDLER_RUNS_DB_QUERY' : callType === 'external_http' ? 'HANDLER_CALLS_EXTERNAL_HTTP' : callType === 'async_emit' ? 'HANDLER_EMITS_EVENT' : callType === 'async_subscribe' ? 'EVENT_CONSUMED_BY_HANDLER' : resolution.status === 'dynamic' ? 'DYNAMIC_EDGE_CANDIDATE' : 'UNRESOLVED_EDGE';
-  const status = edgeType === 'DYNAMIC_EDGE_CANDIDATE' ? 'dynamic' : resolution.status === 'ambiguous' ? 'ambiguous' : edgeType === 'UNRESOLVED_EDGE' ? 'unresolved' : 'terminal';
-  const unresolvedReason = status === 'terminal' ? null : String(call.unresolved_reason ?? unresolvedOperationReason(resolution));
-  const externalTarget = callType === 'external_http' ? externalHttpTarget(call) : undefined;
-  const targetKind = callType === 'local_db_query' ? 'db_entity' : callType.startsWith('async_') ? 'event' : callType === 'external_http' ? (externalTarget?.toKind ?? 'external_endpoint') : 'operation_candidate';
-  const targetId = callType === 'local_db_query' ? String(call.query_entity ?? 'unknown') : callType === 'remote_action' ? (op ? `Remote action: ${op}` : (call.unresolved_reason === 'dynamic_operation_path_identifier' ? 'Remote action: dynamic path' : 'Remote action: unknown path')) : callType === 'external_http' ? String(externalTarget?.toId ?? 'unknown') : String(call.event_name_expr ?? op ?? 'unknown');
-  const graphLevelDynamic = edgeType === 'DYNAMIC_EDGE_CANDIDATE' && resolution.status === 'dynamic';
-  const finalEvidence = externalTarget ? { ...evidence, externalTarget } : evidence;
-  db.prepare('INSERT INTO graph_edges(workspace_id,edge_type,status,from_kind,from_id,to_kind,to_id,confidence,evidence_json,is_dynamic,unresolved_reason,generation) VALUES(?,?,?,?,?,?,?,?,?,?,?,?)').run(workspaceId, edgeType, status, 'call', String(call.id), targetKind, targetId, Number(call.confidence ?? 0.2), JSON.stringify(finalEvidence), graphLevelDynamic ? 1 : 0, unresolvedReason, generation);
-  return { status, callType };
-}
-function operationCandidateCount(db: Db, workspaceId: number, operationPath: string | undefined, operationName: string | undefined): number {
-  if (!operationPath && !operationName) return 0;
-  const normalizedName = operationName ?? operationPath?.replace(/^\//, '').split('.').at(-1);
-  const row = db.prepare(`SELECT COUNT(*) count 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_path=? OR o.operation_path=? OR o.operation_name=?)`).get(workspaceId, operationPath, normalizedName ? `/${normalizedName}` : operationPath, normalizedName) as { count?: number } | undefined;
-  return Number(row?.count ?? 0);
-}
-
-function operationPrecedence(
-  callType: string,
-  intent: ReturnType<typeof classifyODataPathIntent>,
-  indexedOperationCandidateCount: number,
-  resolvedOperation: boolean,
-): Record<string, unknown> {
-  if (resolvedOperation) {
-    return {
-      decision: 'operation',
-      reason: 'indexed_operation_with_strong_service_context',
-      indexedOperationCandidateCount,
-    };
-  }
-  if (callType === 'remote_action' && intent.kind === 'operation_invocation') {
-    return {
-      decision: 'operation_candidate',
-      rejectionReason: indexedOperationCandidateCount > 0
-        ? 'indexed_candidates_lack_unique_strong_service_context'
-        : 'no_indexed_operation_candidate',
-      indexedOperationCandidateCount,
-    };
-  }
-  if (intent.kind.startsWith('entity_')) {
-    return {
-      decision: 'entity',
-      rejectionReason: indexedOperationCandidateCount > 0
-        ? 'entity_shape_has_precedence_without_resolved_operation_context'
-        : 'entity_shape_has_no_indexed_operation_evidence',
-      indexedOperationCandidateCount,
-    };
-  }
-  return {
-    decision: 'unresolved',
-    rejectionReason: 'path_has_no_safe_entity_or_operation_precedence',
-    indexedOperationCandidateCount,
-  };
-}
-
-function unresolvedOperationReason(resolution: { candidates: unknown[]; status: string; reasons: string[] }): string {
-  if (resolution.status === 'dynamic') return `Dynamic target requires runtime variable overrides: ${(resolution.reasons.length ? resolution.reasons : ['missing runtime variables']).join(', ')}`;
-  if (resolution.candidates.length === 0) return 'No indexed target operation matched';
-  if (resolution.reasons.includes('operation_path_only_has_no_strong_target_signal')) return 'Operation candidates found but no strong service signal is available';
-  if (resolution.reasons.includes('candidate_score_below_resolution_threshold')) return 'Operation candidates found but resolution score is below threshold';
-  if (resolution.status === 'ambiguous') return 'Ambiguous operation candidates require a strong service signal';
-  return 'Operation candidates found but resolution could not select a target';
-}

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

@@ -43,6 +43,17 @@ export function queryBuilderRoot(
     : undefined;
 }
 
+export function chainIncludesForUpdate(node: ts.Expression): boolean {
+  let current = unwrapQueryExpression(node);
+  while (ts.isCallExpression(current)
+    && ts.isPropertyAccessExpression(current.expression)) {
+    if (isCapQueryBuilderRootName(expressionName(current.expression))) break;
+    if (current.expression.name.text === 'forUpdate') return true;
+    current = unwrapQueryExpression(current.expression.expression);
+  }
+  return false;
+}
+
 export function directQueryBuilderStatement(
   node: ts.CallExpression,
 ): DirectQueryBuilderStatement | undefined {

package/src/parsers/006-binding-identity.ts

@@ -230,6 +230,9 @@ function resolvedReference(
   chain: LexicalScopeFact[],
   scopeIndex: number,
 ): ServiceBindingReference {
+  const helperReturn = selected.fact.helperChain?.some(
+    (step) => step.bindingOrigin === 'single_hop_helper_return',
+  ) ?? false;
   return {
     status: 'resolved_exact',
     variableName: call.serviceVariableName,
@@ -240,7 +243,9 @@ function resolvedReference(
       ? 'deterministic_reaching_assignment'
       : selected.site.aliasSource
         ? 'lexical_alias_declaration'
-        : 'lexical_declaration',
+        : helperReturn
+          ? 'single_hop_helper_return'
+          : 'lexical_declaration',
     lexicalScopeChain: chain,
     bindingScopeIndex: scopeIndex,
     scopeChainTotal: chain.length,

package/src/parsers/014-service-binding-helper-flow.ts

@@ -157,12 +157,58 @@ function returnedProperty(
   return { propertyName, variableName: property.initializer.text };
 }
 
-function branchDependent(node: ts.Node, fn: ts.FunctionLikeDeclaration): boolean {
+function hazardousTryClause(
+  node: ts.Node | undefined,
+  fn: ts.FunctionLikeDeclaration,
+  anyReturn: boolean,
+): boolean {
+  if (!node) return false;
+  let found = false;
+  const visit = (current: ts.Node): void => {
+    if (found || current !== fn && ts.isFunctionLike(current)) return;
+    if (ts.isReturnStatement(current)
+      && (anyReturn || current.expression !== undefined)
+      || ts.isCallExpression(current) && connectFactFromCall(current)) {
+      found = true;
+      return;
+    }
+    ts.forEachChild(current, visit);
+  };
+  visit(node);
+  return found;
+}
+
+function hasAncestor(node: ts.Node, ancestor: ts.Node): boolean {
+  let current: ts.Node | undefined = node.parent;
+  while (current) {
+    if (current === ancestor) return true;
+    current = current.parent;
+  }
+  return false;
+}
+
+function unsupportedTryAncestor(
+  statement: ts.TryStatement,
+  returned: ts.Node,
+  fn: ts.FunctionLikeDeclaration,
+): boolean {
+  if (!hasAncestor(returned, statement.tryBlock)) return true;
+  if (hazardousTryClause(statement.catchClause?.block, fn, false))
+    return true;
+  return hazardousTryClause(statement.finallyBlock, fn, true);
+}
+
+function branchDependent(
+  node: ts.Node,
+  fn: ts.FunctionLikeDeclaration,
+): boolean {
   let current: ts.Node | undefined = node.parent;
   while (current && current !== fn) {
     if (ts.isIfStatement(current) || ts.isConditionalExpression(current)
-      || ts.isSwitchStatement(current) || ts.isIterationStatement(current, false)
-      || ts.isTryStatement(current)) return true;
+      || ts.isSwitchStatement(current)
+      || ts.isIterationStatement(current, false)) return true;
+    if (ts.isTryStatement(current)
+      && unsupportedTryAncestor(current, node, fn)) return true;
     current = current.parent;
   }
   return false;
@@ -231,10 +277,30 @@ function directReturnConnectFact(
   return directConnectFact(returned);
 }
 
+function hasTryAncestor(
+  returned: ts.ReturnStatement,
+  fn: ts.FunctionLikeDeclaration,
+): boolean {
+  let current: ts.Node | undefined = returned.parent;
+  while (current && current !== fn) {
+    if (ts.isTryStatement(current)) return true;
+    current = current.parent;
+  }
+  return false;
+}
+
 export function directConnectFactFromFunctionLike(
   fn: ts.FunctionLikeDeclaration,
 ): LocalBindingFact | undefined {
   if (ts.isArrowFunction(fn) && fn.body && !ts.isBlock(fn.body))
     return directConnectFact(fn.body);
-  return directReturnConnectFact(fn);
+  const returned = singleReturn(fn);
+  const fact = directReturnConnectFact(fn);
+  if (!fact || !returned || !hasTryAncestor(returned, fn)) return fact;
+  return {
+    ...fact,
+    helperChain: [...(fact.helperChain ?? []), {
+      bindingOrigin: 'single_hop_helper_return',
+    }],
+  };
 }

package/src/parsers/021-binding-visibility.ts

@@ -72,6 +72,20 @@ function candidatesAtSite<T>(
     && candidate.bindingSiteEndOffset === site.endOffset);
 }
 
+function helperCallDeclaration(site: BindingLexicalSite): boolean {
+  if (!ts.isVariableDeclaration(site.node) || !site.node.initializer)
+    return false;
+  let expression = site.node.initializer;
+  while (ts.isAwaitExpression(expression)
+    || ts.isParenthesizedExpression(expression)
+    || ts.isAsExpression(expression)
+    || ts.isSatisfiesExpression(expression)
+    || ts.isTypeAssertionExpression(expression))
+    expression = expression.expression;
+  return ts.isCallExpression(expression)
+    && ts.isIdentifier(expression.expression);
+}
+
 function compatibleCaseClause(
   site: BindingLexicalSite,
   useNode: ts.Node,
@@ -108,7 +122,9 @@ function matchedBinding<T>(
     status: 'unresolved',
     reason: site.flow === 'assignment'
       ? 'unsupported_reaching_assignment'
-      : 'binding_not_found',
+      : helperCallDeclaration(site)
+        ? 'binding_flow_unsupported'
+        : 'binding_not_found',
   };
   if (matches.length > 1) return { status: 'ambiguous' };
   return matches[0] ? { status: 'resolved', candidate: matches[0] } : undefined;