@saptools/service-flow 0.1.40 → 0.1.42

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## 0.1.42
+
+- Continued inherited CDS extension operations into the selected base implementation while retaining concrete routing evidence.
+- Reconciled materialized inherited operations on reindex so renamed or removed base operations do not leave stale effective rows.
+- Kept ambiguous or unresolved extension bases without a selected base id and ignored commented CDS `using` declarations.
+- Added positional remote CAP `Service.send(method, path, ...)` classification for proven CAP clients and tightened catch/loop lexical constant resolution.
+
+## 0.1.41
+
+- Added imported CDS extension provenance and materialized inherited operations at concrete extension paths without guessing by simple service name.
+- Resolved TypeScript identifier expressions through lexical bindings so module constants work and inaccessible shadowed block values are excluded.
+- Classified positional CAP `Service.send(...)` dispatch only for proven CAP service receivers while leaving generic `send` calls untouched.
+- Bumped the SQLite schema to persist extension/base and operation provenance metadata.
+
 ## 0.1.40
 
 - Hardened operation path expression analysis to respect lexical scope, declaration order, aliases, and bounded branch candidates.

package/dist/{chunk-774PPGGK.js → chunk-RP3BJ64F.js}

@@ -161,6 +161,37 @@ function maskCommentsAndStrings(text) {
   }
   return out;
 }
+function maskComments(text) {
+  let out = "";
+  let mode = "code";
+  for (let i = 0; i < text.length; i += 1) {
+    const c = text[i] ?? "";
+    const n = text[i + 1] ?? "";
+    if (mode === "code" && c === "/" && n === "/") {
+      mode = "line";
+      out += "  ";
+      i += 1;
+      continue;
+    }
+    if (mode === "code" && c === "/" && n === "*") {
+      mode = "block";
+      out += "  ";
+      i += 1;
+      continue;
+    }
+    if (mode === "line" && c === "\n") mode = "code";
+    if (mode === "block" && c === "*" && n === "/") {
+      mode = "code";
+      out += "  ";
+      i += 1;
+      continue;
+    }
+    if (mode === "code" && (c === "'" || c === '"' || c === "`")) mode = c === "'" ? "single" : c === '"' ? "double" : "template";
+    else if (mode === "single" && c === "'" || mode === "double" && c === '"' || mode === "template" && c === "`") mode = "code";
+    out += mode === "line" || mode === "block" ? c === "\n" ? "\n" : " " : c;
+  }
+  return out;
+}
 function readAnnotation(text, index) {
   if (text[index] !== "@") return void 0;
   let i = index + 1;
@@ -202,6 +233,21 @@ function annotationRawAt(original, masked, index) {
   const collected = collectAnnotations(masked, index);
   return { end: collected.end, raw: original.slice(index, collected.end) };
 }
+function collectUsings(masked) {
+  const imports = /* @__PURE__ */ new Map();
+  for (const m of masked.matchAll(/\busing\s*\{([^}]*)\}\s*from\s*(['"])(.*?)\2\s*;/gs)) {
+    const moduleSpecifier = m[3] ?? "";
+    for (const part of (m[1] ?? "").split(",")) {
+      const text = part.trim();
+      if (!text) continue;
+      const alias = /^(\w+)\s+as\s+(\w+)$/.exec(text) ?? /^(\w+)\s*:\s*(\w+)$/.exec(text);
+      const importedSymbol = alias?.[1] ?? text;
+      const localAlias = alias?.[2] ?? importedSymbol;
+      imports.set(localAlias, { importedSymbol, localAlias, moduleSpecifier, importKind: moduleSpecifier.startsWith(".") ? "relative" : "package" });
+    }
+  }
+  return imports;
+}
 function operationsFromBody(text, maskedBody, bodyOffset, filePath) {
   return [...maskedBody.matchAll(/\b(action|function|event)\s+(\w+)\s*(?:\(([^)]*)\))?\s*(?:returns\s+([^;{]+))?/g)].map((m) => ({
     operationType: m[1] ?? "action",
@@ -220,6 +266,7 @@ async function parseCdsFile(repoPath, filePath) {
   const namespace = /namespace\s+([\w.]+)\s*;/.exec(masked)?.[1];
   const services = [];
   const pendingAnnotations = [];
+  const usings = collectUsings(maskComments(text));
   for (const a of masked.matchAll(/@\s*\(/g)) pendingAnnotations.push(annotationRawAt(text, masked, a.index ?? 0));
   const serviceRegex = /\b(?:(extend)\s+)?(?:(service)\s+)?([A-Za-z_]\w*(?:\.[A-Za-z_]\w*)*)\b/g;
   let match;
@@ -239,6 +286,7 @@ async function parseCdsFile(repoPath, filePath) {
     const body = masked.slice(open + 1, end);
     const name = match[3] ?? "UnknownService";
     const serviceName = name.split(".").pop() ?? name;
+    const imported = isExtend ? usings.get(name) ?? usings.get(serviceName) : void 0;
     const servicePath = ensureLeadingSlash(pathAnnotation(annotations) ?? serviceName);
     services.push({
       namespace,
@@ -248,14 +296,16 @@ async function parseCdsFile(repoPath, filePath) {
       isExtend,
       sourceFile: normalizePath(filePath),
       sourceLine: lineOf(text, match.index),
-      operations: operationsFromBody(text, body, open + 1, filePath)
+      operations: operationsFromBody(text, body, open + 1, filePath),
+      extension: isExtend ? { localReference: name, importedSymbol: imported?.importedSymbol, localAlias: imported?.localAlias, moduleSpecifier: imported?.moduleSpecifier, importKind: imported?.importKind ?? "none" } : void 0
     });
     serviceRegex.lastIndex = end + 1;
   }
   const baseOps = new Map(services.filter((s) => !s.isExtend).map((s) => [s.qualifiedName, s.operations]));
   for (const service of services.filter((s) => s.isExtend && s.operations.length === 0)) {
+    if (service.extension?.moduleSpecifier) continue;
     const inherited = baseOps.get(service.qualifiedName) ?? baseOps.get(service.serviceName);
-    if (inherited) service.operations = inherited.map((op) => ({ ...op, sourceFile: service.sourceFile, sourceLine: service.sourceLine }));
+    if (inherited) service.operations = inherited.map((op) => ({ ...op, provenance: "inherited" }));
   }
   return services;
 }
@@ -894,37 +944,54 @@ function placeholders(expr) {
 function isFunctionLikeScope(node) {
   return ts4.isFunctionLike(node) || ts4.isSourceFile(node);
 }
-function containingScope(node) {
-  let current = node.parent;
-  while (current && !isFunctionLikeScope(current)) current = current.parent;
-  return current ?? node.getSourceFile();
-}
 function nodeContains(parent, child) {
-  return child.getStart(child.getSourceFile()) >= parent.getStart(parent.getSourceFile()) && child.getEnd() <= parent.getEnd();
-}
-function nestedFunctionContains(scope, candidate, use) {
-  let current = candidate.parent;
-  while (current && current !== scope) {
-    if (isFunctionLikeScope(current) && !nodeContains(current, use)) return true;
+  const source = child.getSourceFile();
+  return child.getStart(source) >= parent.getStart(source) && child.getEnd() <= parent.getEnd();
+}
+function declarationScope(node) {
+  if (ts4.isParameter(node)) return node.parent;
+  const list = node.parent;
+  const blockScoped = (list.flags & (ts4.NodeFlags.Const | ts4.NodeFlags.Let)) !== 0;
+  let current = list.parent;
+  if (!blockScoped) {
+    while (current.parent && !isFunctionLikeScope(current)) current = current.parent;
+    return current;
+  }
+  while (current.parent && !ts4.isBlock(current) && !ts4.isSourceFile(current) && !ts4.isModuleBlock(current) && !ts4.isCaseBlock(current) && !ts4.isCatchClause(current) && !ts4.isForStatement(current) && !ts4.isForInStatement(current) && !ts4.isForOfStatement(current) && !isFunctionLikeScope(current)) current = current.parent;
+  return current;
+}
+function declarationScopedAncestor(node) {
+  let current = node.parent;
+  while (current) {
+    if (ts4.isCatchClause(current) || ts4.isForStatement(current) || ts4.isForInStatement(current) || ts4.isForOfStatement(current)) return current;
+    if (ts4.isSourceFile(current) || ts4.isFunctionLike(current)) return void 0;
     current = current.parent;
   }
-  return false;
+  return void 0;
+}
+function isAccessibleDeclaration(declaration, use) {
+  const source = use.getSourceFile();
+  if (declaration.name.getStart(source) >= use.getStart(source)) return false;
+  const scopedAncestor = declarationScopedAncestor(declaration);
+  if (scopedAncestor && ts4.isCatchClause(scopedAncestor)) return nodeContains(scopedAncestor.block, use);
+  if (scopedAncestor && (ts4.isForStatement(scopedAncestor) || ts4.isForInStatement(scopedAncestor) || ts4.isForOfStatement(scopedAncestor))) return nodeContains(scopedAncestor.statement, use);
+  const scope = declarationScope(declaration);
+  if (ts4.isCatchClause(scope)) return nodeContains(scope.block, use);
+  if (ts4.isForStatement(scope) || ts4.isForInStatement(scope) || ts4.isForOfStatement(scope)) return nodeContains(scope.statement, use);
+  return ts4.isSourceFile(scope) || nodeContains(scope, use);
 }
 function resolveBinding(identifier, use) {
-  const scope = containingScope(use);
   const source = use.getSourceFile();
   let best;
   const visit = (node) => {
-    if (node !== scope && isFunctionLikeScope(node)) return;
-    if (node.getStart(source) >= identifier.getStart(source)) return;
-    if (ts4.isVariableDeclaration(node) && ts4.isIdentifier(node.name) && node.name.text === identifier.text && !nestedFunctionContains(scope, node, use)) best = node;
-    if (ts4.isParameter(node) && ts4.isIdentifier(node.name) && node.name.text === identifier.text && !nestedFunctionContains(scope, node, use)) best = node;
+    if (ts4.isVariableDeclaration(node) && ts4.isIdentifier(node.name) && node.name.text === identifier.text && isAccessibleDeclaration(node, use)) best = node;
+    if (ts4.isParameter(node) && ts4.isIdentifier(node.name) && node.name.text === identifier.text && isAccessibleDeclaration(node, use)) best = node;
     ts4.forEachChild(node, visit);
   };
-  visit(scope);
+  visit(source);
   if (!best) return { immutable: false, evidence: ["binding_not_found"] };
   const immutable = ts4.isVariableDeclaration(best) && (best.parent.flags & ts4.NodeFlags.Const) !== 0;
-  return { declaration: best, initializer: ts4.isVariableDeclaration(best) ? best.initializer : void 0, immutable, evidence: [immutable ? "const_binding_before_use" : "mutable_or_parameter_binding"] };
+  return { declaration: best, initializer: ts4.isVariableDeclaration(best) ? best.initializer : void 0, immutable, evidence: [immutable ? "lexical_const_binding_before_use" : "lexical_mutable_or_parameter_binding"] };
 }
 function resolveExpression(expr, use, policy, depth = 0, seen = /* @__PURE__ */ new Set()) {
   if (!expr) return { status: "unknown", sourceKind: "dynamic_expression", placeholderKeys: [], evidence: ["expression_missing"] };
@@ -964,7 +1031,6 @@ function staticPathCandidates(identifier, call, method) {
   const binding = resolveBinding(identifier, call);
   const declaration = binding.declaration;
   if (!declaration) return void 0;
-  const scope = containingScope(call);
   const source = call.getSourceFile();
   const paths = [];
   let hasDynamicAssignments = false;
@@ -975,12 +1041,15 @@ function staticPathCandidates(identifier, call, method) {
   };
   if (ts4.isVariableDeclaration(declaration)) addExpr(declaration.initializer, declaration);
   const visit = (node) => {
-    if (node !== scope && isFunctionLikeScope(node)) return;
+    if (node !== source && isFunctionLikeScope(node) && !nodeContains(node, call)) return;
     if (node.getStart(source) >= call.getStart(source)) return;
-    if (ts4.isBinaryExpression(node) && node.operatorToken.kind === ts4.SyntaxKind.EqualsToken && ts4.isIdentifier(node.left) && node.left.text === identifier.text) addExpr(node.right, node);
+    if (ts4.isBinaryExpression(node) && node.operatorToken.kind === ts4.SyntaxKind.EqualsToken && ts4.isIdentifier(node.left)) {
+      const target = resolveBinding(node.left, node);
+      if (target.declaration === declaration) addExpr(node.right, node);
+    }
     ts4.forEachChild(node, visit);
   };
-  visit(scope);
+  visit(source);
   const candidatePaths = [...new Set(paths)];
   if (candidatePaths.length === 0) return void 0;
   const normalizedCandidateOperations = [...new Set(candidatePaths.map((candidate) => classifyODataPathIntent(candidate, method).topLevelOperationName).filter((value) => Boolean(value)))];
@@ -1191,6 +1260,20 @@ function classifyOutboundCallsInSource(source, filePath) {
           const entityCallType = entityCallTypes[intent.kind];
           const isODataQueryRead = method.toUpperCase() === "GET" && ["entity_query", "entity_key_read", "entity_navigation_query"].includes(intent.kind);
           add(node, { callType: query ? "remote_query" : entityCallType ?? (isODataQueryRead ? "remote_query" : "remote_action"), serviceVariableName: receiver, method, operationPathExpr, queryEntity: query ? extractQueryEntity(query) : isODataQueryRead ? intent.entitySegment : void 0, payloadSummary: summarizeExpression(objectArg.getText(source)), confidence: op || query ? 0.8 : 0.4, unresolvedReason: !query && pathExpr && !operationPathExpr ? "dynamic_operation_path_identifier" : void 0 }, { receiver, classifier: "service_client_send_object", operationPathExpression: shorthandPath ? op : void 0, rawPathExpression: resolvedPath.rawExpression, literalPathSource: resolvedPath.text ? resolvedPath.sourceKind === "const" ? "same_scope_const_initializer" : resolvedPath.sourceKind : void 0, odataPathIntent: operationPathExpr ? intent : void 0, staticPathCandidates: candidateEvidence2, parserWarning: !query && pathExpr && !operationPathExpr ? "dynamic_operation_path_identifier" : void 0 });
+        } else {
+          const receiver = receiverName(expr.expression);
+          const rootReceiver = rootReceiverName(expr.expression);
+          const method = resolveExpression(node.arguments[0], node, "literal").value?.toUpperCase();
+          const pathArg = node.arguments[1];
+          const supported = method && ["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD"].includes(method);
+          if (receiver && supported && serviceVariables.has(rootReceiver ?? receiver)) {
+            const resolvedPath = staticPathExpression(pathArg, node);
+            const operationPathExpr = operationPathFromStatic(resolvedPath.text);
+            const intent = classifyODataPathIntent(operationPathExpr, method);
+            add(node, { callType: "remote_action", serviceVariableName: rootReceiver ?? receiver, method, operationPathExpr, payloadSummary: summarizeExpression(node.getText(source)), confidence: operationPathExpr ? 0.8 : 0.45, unresolvedReason: operationPathExpr ? void 0 : "dynamic_operation_path_identifier" }, { receiver, rootReceiver, classifier: "service_client_send_method_path", rawPathExpression: resolvedPath.rawExpression, literalPathSource: resolvedPath.text ? resolvedPath.sourceKind === "const" ? "same_scope_const_initializer" : resolvedPath.sourceKind : void 0, odataPathIntent: operationPathExpr ? intent : void 0, parserWarning: operationPathExpr ? void 0 : "dynamic_operation_path_identifier" });
+          } else if (receiver && serviceVariables.has(rootReceiver ?? receiver)) {
+            add(node, { callType: "remote_action", serviceVariableName: rootReceiver ?? receiver, method, payloadSummary: summarizeExpression(node.getText(source)), confidence: 0.35, unresolvedReason: "unsupported_cap_send_signature" }, { receiver, rootReceiver, classifier: "service_client_send_unsupported_signature" });
+          }
         }
       } else if (ts4.isCallExpression(expr) && ts4.isIdentifier(expr.expression) && wrapperSpecs.has(expr.expression.text) || ts4.isIdentifier(expr) && wrapperSpecs.has(expr.text)) {
         const wrapperName = ts4.isIdentifier(expr) ? expr.text : ts4.isCallExpression(expr) && ts4.isIdentifier(expr.expression) ? expr.expression.text : "";
@@ -1251,7 +1334,7 @@ function parseLocalServiceCalls(text, filePath) {
       if (origin) aliases.set(node.name.text, { ...origin, chain: [...origin.chain, node.name.text] });
     }
     if (ts4.isCallExpression(node)) {
-      const parsed = serviceOperationCall(node.expression, aliases);
+      const parsed = serviceOperationCall(node, aliases);
       if (parsed && parsed.operation !== "entities") calls.push({
         callType: "local_service_call",
         operationPathExpr: `/${parsed.operation}`,
@@ -1264,7 +1347,8 @@ function parseLocalServiceCalls(text, filePath) {
         confidence: 0.9,
         unresolvedReason: ["send", "emit", "publish", "on"].includes(parsed.operation) ? "transport_client_method" : void 0,
         evidence: parserEvidence(source, node, {
-          classifier: "local_cap_service_call",
+          classifier: parsed.classifier,
+          parserCallType: parsed.operation === "send" ? "transport_client_method" : parsed.classifier,
           localServiceLookup: parsed.lookup,
           localServiceName: parsed.service,
           operation: parsed.operation,
@@ -1283,12 +1367,19 @@ function serviceLookup(expr, aliases) {
   if (ts4.isElementAccessExpression(expr) && expr.expression.getText() === "cds.services" && ts4.isStringLiteral(expr.argumentExpression)) return { service: expr.argumentExpression.text, lookup: expr.getText(), chain: [expr.getText()] };
   return void 0;
 }
-function serviceOperationCall(expr, aliases) {
+function serviceOperationCall(node, aliases) {
+  const expr = node.expression;
   if (!ts4.isPropertyAccessExpression(expr)) return void 0;
-  const operation = expr.name.text;
   const origin = serviceLookup(expr.expression, aliases);
   if (!origin) return void 0;
-  return { ...origin, operation };
+  if (expr.name.text === "send") {
+    const first = literalText(node.arguments[0]);
+    const second = literalText(node.arguments[1]);
+    const method = first?.toUpperCase();
+    if (method && ["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD"].includes(method) && second) return { ...origin, operation: second.replace(/^\//, ""), classifier: "cap_service_send_method_path" };
+    if (first) return { ...origin, operation: first.replace(/^\//, ""), classifier: "cap_service_send_local_dispatch" };
+  }
+  return { ...origin, operation: expr.name.text, classifier: "local_cap_service_call" };
 }
 
 // src/parsers/service-binding-parser.ts
@@ -2416,13 +2507,14 @@ function callEvidence(call, resolution, servicePath, op, destination, normalized
   return { sourceFile: call.source_file, sourceLine: call.source_line, file: call.source_file, line: call.source_line, callId: call.id, repo: call.repoName, serviceAlias: call.alias, serviceAliasExpr: call.aliasExpr, destination, servicePath, operationPath: op, rawOperationPath: normalized?.wasInvocation ? normalized.rawOperationPath : odataPathIntent?.rawPath, normalizedOperationPath: normalized?.wasInvocation ? normalized.normalizedOperationPath : void 0, invocationArgumentPlaceholderKeys: normalized?.invocationArgumentPlaceholderKeys.length ? normalized.invocationArgumentPlaceholderKeys : void 0, odataOperationNormalizationReason: normalized?.normalizationReason, odataOperationNormalizationRejectedReason: normalized?.normalizationRejectedReason, localServiceName: call.local_service_name, localServiceLookup: call.local_service_lookup, aliasChain: parseJson(call.alias_chain_json), transport: call.call_type === "local_service_call" ? "local" : void 0, targetRepo: resolution.target?.repoName, targetServicePath: resolution.target?.servicePath, targetOperationPath: resolution.target?.operationPath, targetOperation: resolution.target?.operationName, helperChain: parseJson(call.helperChainJson), candidates: resolution.candidates, candidateCount: resolution.candidates.length, resolutionStatus: resolution.status, resolutionReasons: resolution.reasons, odataPathIntent, queryStringPresent: odataPathIntent?.hasQueryString || void 0, queryPlaceholderKeys: odataPathIntent?.placeholderKeys.length ? odataPathIntent.placeholderKeys : void 0, bindingHasDynamicExpression: bindingHasDynamicExpression || void 0, outboundEvidence: objectJson(call.evidence_json), analysisCompleteness: call.unresolved_reason ? "partial" : "complete", parserWarning: call.unresolved_reason ? { code: "parser_warning", message: call.unresolved_reason } : void 0 };
 }
 function linkImplementations(db, workspaceId, generation) {
-  const operations = db.prepare(`SELECT o.id operationId,o.operation_path operationPath,o.operation_name operationName,s.service_path servicePath,s.repo_id modelRepoId,r.name modelRepo,r.package_name modelPackage,r.kind modelKind 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=?`).all(workspaceId);
+  const operations = db.prepare(`SELECT o.id operationId,o.operation_path operationPath,o.operation_name operationName,o.provenance provenance,o.base_operation_id baseOperationId,s.service_path servicePath,s.repo_id modelRepoId,r.name modelRepo,r.package_name modelPackage,r.kind modelKind 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=?`).all(workspaceId);
   let edgeCount = 0;
   let resolvedCount = 0;
   let ambiguousCount = 0;
   let unresolvedCount = 0;
   for (const operation of operations) {
-    const candidates = rankedImplementationCandidates(db, workspaceId, operation);
+    const implementationContext = implementationContextForOperation(db, operation);
+    const candidates = rankedImplementationCandidates(db, workspaceId, implementationContext);
     if (candidates.length === 0) continue;
     const accepted = candidates.filter((candidate) => candidate.accepted);
     const topScore = accepted[0]?.score ?? 0;
@@ -2433,6 +2525,9 @@ function linkImplementations(db, workspaceId, generation) {
       operationPath: operation.operationPath,
       operationName: operation.operationName,
       modelPackage: { id: operation.modelRepoId, name: operation.modelRepo, packageName: operation.modelPackage },
+      implementationSource: implementationContext.operationId === operation.operationId ? "direct_or_concrete_override" : "inherited_from_base_operation",
+      baseOperationId: operation.baseOperationId,
+      implementationOperationId: implementationContext.operationId,
       candidates: candidates.map((candidate, index) => candidateEvidence(candidate, index + 1))
     };
     if (accepted.length === 0) {
@@ -2448,6 +2543,12 @@ function linkImplementations(db, workspaceId, generation) {
   }
   return { edgeCount, resolvedCount, ambiguousCount, unresolvedCount };
 }
+function implementationContextForOperation(db, operation) {
+  if (operation.provenance !== "inherited" || !operation.baseOperationId) return operation;
+  const base = db.prepare(`SELECT o.id operationId,o.operation_path operationPath,o.operation_name operationName,o.provenance provenance,o.base_operation_id baseOperationId,s.service_path servicePath,s.repo_id modelRepoId,r.name modelRepo,r.package_name modelPackage,r.kind modelKind FROM cds_operations o JOIN cds_services s ON s.id=o.service_id JOIN repositories r ON r.id=s.repo_id WHERE o.id=?`).get(operation.baseOperationId);
+  if (!base) return operation;
+  return { ...base, effectiveOperationId: operation.operationId, effectiveServicePath: operation.servicePath, effectiveOperationPath: operation.operationPath };
+}
 function rankedImplementationCandidates(db, workspaceId, operation) {
   const rows2 = implementationCandidates(db, workspaceId, operation);
   return deduplicateCandidates(rows2.map((row) => scoreImplementationCandidate(row, operation))).sort((a, b) => b.score - a.score || String(a.className).localeCompare(String(b.className)) || a.methodId - b.methodId);
@@ -3191,4 +3292,4 @@ export {
   linkWorkspace,
   trace
 };
-//# sourceMappingURL=chunk-774PPGGK.js.map
+//# sourceMappingURL=chunk-RP3BJ64F.js.map