@saptools/service-flow 0.1.40 → 0.1.41

package/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## 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-7L4QKKGN.js}

@@ -202,6 +202,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 +235,7 @@ async function parseCdsFile(repoPath, filePath) {
   const namespace = /namespace\s+([\w.]+)\s*;/.exec(masked)?.[1];
   const services = [];
   const pendingAnnotations = [];
+  const usings = collectUsings(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 +255,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 +265,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 +913,40 @@ 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;
-    current = current.parent;
-  }
-  return false;
+  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) && !isFunctionLikeScope(current)) current = current.parent;
+  return current;
+}
+function isAccessibleDeclaration(declaration, use) {
+  const source = use.getSourceFile();
+  if (declaration.name.getStart(source) >= use.getStart(source)) return false;
+  const scope = declarationScope(declaration);
+  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 +986,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 +996,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)))];
@@ -1251,7 +1275,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 +1288,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 +1308,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
@@ -3191,4 +3223,4 @@ export {
   linkWorkspace,
   trace
 };
-//# sourceMappingURL=chunk-774PPGGK.js.map
+//# sourceMappingURL=chunk-7L4QKKGN.js.map