@saptools/service-flow 0.1.42 → 0.1.43

package/dist/index.js

@@ -16,7 +16,7 @@ import {
   stripQuotes,
   substituteVariables,
   trace
-} from "./chunk-RP3BJ64F.js";
+} from "./chunk-KHQK7CFH.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.42",
+  "version": "0.1.43",
   "description": "Trace SAP CAP service-to-service flows across multi-repository workspaces with runtime-aware graph resolution",
   "type": "module",
   "publishConfig": {

package/src/indexer/cds-extension-resolver.ts

@@ -12,40 +12,79 @@ interface ExtensionRow {
 }
 interface BaseRow { id: number; repoId: number }
 
+interface DesiredOperation { id: number; operationType: string; operationName: string; operationPath: string; paramsJson: string; returnType: string | null; sourceFile: string; sourceLine: number }
+interface ExistingOperation extends DesiredOperation { baseOperationId: number | null }
+
 export function materializeCdsExtensionOperations(db: Db, workspaceId: number): void {
   const extensions = db.prepare(`SELECT s.id,r.id repoId,s.service_name serviceName,s.qualified_name qualifiedName,s.source_file sourceFile,s.extension_module_specifier moduleSpecifier,s.extension_imported_symbol importedSymbol,s.extension_import_kind importKind
     FROM cds_services s JOIN repositories r ON r.id=s.repo_id WHERE r.workspace_id=? AND s.is_extend=1`).all(workspaceId) as unknown as ExtensionRow[];
-  for (const extension of extensions) {
-    const bases = resolveBase(db, workspaceId, extension);
-    const status = bases.length === 1 ? 'resolved' : bases.length > 1 ? 'ambiguous' : 'unresolved';
-    db.prepare('UPDATE cds_services SET extension_base_status=?, extension_base_service_id=? WHERE id=?').run(status, status === 'resolved' ? bases[0]?.id : null, extension.id);
-    if (bases.length !== 1) {
-      db.prepare("DELETE FROM cds_operations WHERE service_id=? AND provenance='inherited'").run(extension.id);
-      db.prepare("DELETE FROM search_index WHERE repo=? AND kind='operation' AND name NOT IN (SELECT operation_name FROM cds_operations o JOIN cds_services s ON s.id=o.service_id WHERE s.repo_id=?)").run(String(extension.repoId), extension.repoId);
-      continue;
+  db.transaction(() => {
+    const changedRepos = new Set<number>();
+    for (const extension of extensions) {
+      if (reconcileExtension(db, workspaceId, extension)) changedRepos.add(extension.repoId);
     }
-    reconcileInheritedOperations(db, extension, bases[0]);
-  }
+    for (const repoId of changedRepos) markRepositoryDerivedFactsChanged(db, repoId);
+  });
+}
+
+function reconcileExtension(db: Db, workspaceId: number, extension: ExtensionRow): boolean {
+  const bases = resolveBase(db, workspaceId, extension);
+  const status = bases.length === 1 ? 'resolved' : bases.length > 1 ? 'ambiguous' : 'unresolved';
+  const baseId = status === 'resolved' ? bases[0]?.id ?? null : null;
+  const desired = baseId === null ? [] : desiredInheritedOperations(db, extension, baseId);
+  const statusChanged = updateExtensionStatus(db, extension.id, status, baseId);
+  const operationChanged = reconcileInheritedOperations(db, extension, desired);
+  reconcileOperationSearchRows(db, extension.repoId);
+  return statusChanged || operationChanged;
+}
+
+function desiredInheritedOperations(db: Db, extension: ExtensionRow, baseId: number): DesiredOperation[] {
+  return db.prepare("SELECT id,operation_type operationType,operation_name operationName,operation_path operationPath,params_json paramsJson,return_type returnType,source_file sourceFile,source_line sourceLine FROM cds_operations WHERE service_id=? AND provenance='direct' AND NOT EXISTS (SELECT 1 FROM cds_operations direct WHERE direct.service_id=? AND direct.provenance='direct' AND direct.operation_name=cds_operations.operation_name AND direct.operation_path=cds_operations.operation_path) ORDER BY operation_name,operation_path,id").all(baseId, extension.id) as unknown as DesiredOperation[];
+}
+
+function updateExtensionStatus(db: Db, serviceId: number, status: string, baseId: number | null): boolean {
+  const row = db.prepare('SELECT extension_base_status status,extension_base_service_id baseId FROM cds_services WHERE id=?').get(serviceId) as { status?: string | null; baseId?: number | null } | undefined;
+  if (row?.status === status && (row.baseId ?? null) === baseId) return false;
+  db.prepare('UPDATE cds_services SET extension_base_status=?, extension_base_service_id=? WHERE id=?').run(status, baseId, serviceId);
+  return true;
 }
 
-function reconcileInheritedOperations(db: Db, extension: ExtensionRow, base: BaseRow): void {
-  const existing = db.prepare("SELECT id,operation_name operationName,operation_path operationPath,base_operation_id baseOperationId FROM cds_operations WHERE service_id=? AND provenance='inherited'").all(extension.id) as Array<{ id: number; operationName: string; operationPath: string; baseOperationId: number | null }>;
-  const desired = db.prepare("SELECT id,operation_type operationType,operation_name operationName,operation_path operationPath,params_json paramsJson,return_type returnType,source_file sourceFile,source_line sourceLine FROM cds_operations WHERE service_id=? AND provenance='direct' AND NOT EXISTS (SELECT 1 FROM cds_operations direct WHERE direct.service_id=? AND direct.provenance='direct' AND direct.operation_name=cds_operations.operation_name AND direct.operation_path=cds_operations.operation_path)").all(base.id, extension.id) as Array<Record<string, unknown>>;
-  const desiredKeys = new Set(desired.map((row) => `${String(row.operationName)}\0${String(row.operationPath)}`));
+function reconcileInheritedOperations(db: Db, extension: ExtensionRow, desired: DesiredOperation[]): boolean {
+  const existing = db.prepare("SELECT id,operation_type operationType,operation_name operationName,operation_path operationPath,params_json paramsJson,return_type returnType,source_file sourceFile,source_line sourceLine,base_operation_id baseOperationId FROM cds_operations WHERE service_id=? AND provenance='inherited'").all(extension.id) as unknown as ExistingOperation[];
+  const desiredKeys = new Set(desired.map((row) => `${row.operationName}\0${row.operationPath}`));
   const byKey = new Map(existing.map((row) => [`${row.operationName}\0${row.operationPath}`, row]));
+  let changed = false;
   for (const row of existing) {
-    if (!desiredKeys.has(`${row.operationName}\0${row.operationPath}`)) db.prepare('DELETE FROM cds_operations WHERE id=?').run(row.id);
+    if (desiredKeys.has(`${row.operationName}\0${row.operationPath}`)) continue;
+    db.prepare('DELETE FROM cds_operations WHERE id=?').run(row.id);
+    changed = true;
   }
   const update = db.prepare('UPDATE cds_operations SET operation_type=?,params_json=?,return_type=?,source_file=?,source_line=?,base_operation_id=? WHERE id=?');
   const add = db.prepare("INSERT INTO cds_operations(service_id,operation_type,operation_name,operation_path,params_json,return_type,source_file,source_line,provenance,base_operation_id) VALUES(?,?,?,?,?,?,?,?,'inherited',?)");
-  const search = db.prepare('INSERT INTO search_index(kind,name,path,repo) SELECT ?,?,?,? WHERE NOT EXISTS (SELECT 1 FROM search_index WHERE kind=? AND name=? AND path=? AND repo=?)');
   for (const row of desired) {
-    const key = `${String(row.operationName)}\0${String(row.operationPath)}`;
-    const current = byKey.get(key);
+    const current = byKey.get(`${row.operationName}\0${row.operationPath}`);
+    if (current && operationMatches(current, row)) continue;
     if (current) update.run(row.operationType, row.paramsJson, row.returnType, row.sourceFile, row.sourceLine, row.id, current.id);
     else add.run(extension.id, row.operationType, row.operationName, row.operationPath, row.paramsJson, row.returnType, row.sourceFile, row.sourceLine, row.id);
-    search.run('operation', row.operationName, row.operationPath, String(extension.repoId), 'operation', row.operationName, row.operationPath, String(extension.repoId));
+    changed = true;
   }
+  return changed;
+}
+
+function operationMatches(current: ExistingOperation, desired: DesiredOperation): boolean {
+  return current.operationType === desired.operationType && current.paramsJson === desired.paramsJson && current.returnType === desired.returnType && current.sourceFile === desired.sourceFile && current.sourceLine === desired.sourceLine && current.baseOperationId === desired.id;
+}
+
+function reconcileOperationSearchRows(db: Db, repoId: number): void {
+  db.prepare("DELETE FROM search_index WHERE repo=? AND kind='operation'").run(String(repoId));
+  db.prepare(`INSERT INTO search_index(kind,name,path,repo)
+    SELECT 'operation',o.operation_name,o.operation_path,?
+    FROM cds_operations o JOIN cds_services s ON s.id=o.service_id
+    WHERE s.repo_id=? ORDER BY o.operation_name,o.operation_path,o.id`).run(String(repoId), repoId);
+}
+
+function markRepositoryDerivedFactsChanged(db: Db, repoId: number): void {
+  db.prepare("UPDATE repositories SET fact_generation=COALESCE(fact_generation,0)+1, graph_stale_reason='derived_facts_changed', graph_stale_at=? WHERE id=?").run(new Date().toISOString(), repoId);
 }
 
 function resolveBase(db: Db, workspaceId: number, extension: ExtensionRow): BaseRow[] {

package/src/parsers/outbound-call-parser.ts

@@ -111,6 +111,7 @@ function nodeContains(parent: ts.Node, child: ts.Node): boolean {
 }
 function declarationScope(node: ts.VariableDeclaration | ts.ParameterDeclaration): ts.Node {
   if (ts.isParameter(node)) return node.parent;
+  if (ts.isCatchClause(node.parent) && node.parent.variableDeclaration === node) return node.parent;
   const list = node.parent;
   const blockScoped = (list.flags & (ts.NodeFlags.Const | ts.NodeFlags.Let)) !== 0;
   let current: ts.Node = list.parent;
@@ -118,26 +119,23 @@ function declarationScope(node: ts.VariableDeclaration | ts.ParameterDeclaration
     while (current.parent && !isFunctionLikeScope(current)) current = current.parent;
     return current;
   }
-  while (current.parent && !ts.isBlock(current) && !ts.isSourceFile(current) && !ts.isModuleBlock(current) && !ts.isCaseBlock(current) && !ts.isCatchClause(current) && !ts.isForStatement(current) && !ts.isForInStatement(current) && !ts.isForOfStatement(current) && !isFunctionLikeScope(current)) current = current.parent;
+  while (current.parent && !ts.isBlock(current) && !ts.isSourceFile(current) && !ts.isModuleBlock(current) && !ts.isCaseBlock(current) && !isLoopInitializerScope(node, current) && !isFunctionLikeScope(current)) current = current.parent;
   return current;
 }
-function declarationScopedAncestor(node: ts.Node): ts.Node | undefined {
-  let current: ts.Node | undefined = node.parent;
-  while (current) {
-    if (ts.isCatchClause(current) || ts.isForStatement(current) || ts.isForInStatement(current) || ts.isForOfStatement(current)) return current;
-    if (ts.isSourceFile(current) || ts.isFunctionLike(current)) return undefined;
-    current = current.parent;
-  }
-  return undefined;
+function isLoopInitializerScope(declaration: ts.VariableDeclaration, scope: ts.Node): boolean {
+  const list = declaration.parent;
+  return (ts.isForStatement(scope) && scope.initializer === list) || ((ts.isForInStatement(scope) || ts.isForOfStatement(scope)) && scope.initializer === list);
+}
+function catchBindingScope(declaration: ts.VariableDeclaration | ts.ParameterDeclaration): ts.CatchClause | undefined {
+  if (ts.isParameter(declaration)) return undefined;
+  return ts.isCatchClause(declaration.parent) && declaration.parent.variableDeclaration === declaration ? declaration.parent : undefined;
 }
 function isAccessibleDeclaration(declaration: ts.VariableDeclaration | ts.ParameterDeclaration, use: ts.Node): boolean {
   const source = use.getSourceFile();
   if (declaration.name.getStart(source) >= use.getStart(source)) return false;
-  const scopedAncestor = declarationScopedAncestor(declaration);
-  if (scopedAncestor && ts.isCatchClause(scopedAncestor)) return nodeContains(scopedAncestor.block, use);
-  if (scopedAncestor && (ts.isForStatement(scopedAncestor) || ts.isForInStatement(scopedAncestor) || ts.isForOfStatement(scopedAncestor))) return nodeContains(scopedAncestor.statement, use);
+  const catchScope = catchBindingScope(declaration);
+  if (catchScope) return nodeContains(catchScope.block, use);
   const scope = declarationScope(declaration);
-  if (ts.isCatchClause(scope)) return nodeContains(scope.block, use);
   if (ts.isForStatement(scope) || ts.isForInStatement(scope) || ts.isForOfStatement(scope)) return nodeContains(scope.statement, use);
   return ts.isSourceFile(scope) || nodeContains(scope, use);
 }
@@ -247,6 +245,11 @@ function httpMethodFromObject(object: ts.ObjectLiteralExpression, use: ts.Node):
   const text = resolveExpression(propertyInitializer(object, 'method'), use, 'literal').value;
   return text ? stripQuotes(text).toUpperCase() : undefined;
 }
+const supportedHttpMethods = new Set(['GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'HEAD']);
+function safeOperationName(value: string | undefined): string | undefined {
+  if (!value || !/^[A-Za-z_$][\w$]*(?:[./][A-Za-z_$][\w$]*)*$/.test(value)) return undefined;
+  return operationPathFromStatic(value);
+}
 function hasTemplatePlaceholder(value: string): boolean { return /\$\{|%7B|%7D/i.test(value); }
 function urlTargetFromExpression(expr: ts.Expression | undefined, use: ts.Node): Record<string, unknown> {
   const resolved = resolveExpression(expr, use, 'external');
@@ -426,16 +429,18 @@ export function classifyOutboundCallsInSource(source: ts.SourceFile, filePath: s
         } else {
           const receiver = receiverName(expr.expression);
           const rootReceiver = rootReceiverName(expr.expression);
-          const method = resolveExpression(node.arguments[0], node, 'literal').value?.toUpperCase();
+          const firstArg = resolveExpression(node.arguments[0], node, 'literal');
+          const method = firstArg.value?.toUpperCase();
           const pathArg = node.arguments[1];
-          const supported = method && ['GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'HEAD'].includes(method);
+          const supported = method && supportedHttpMethods.has(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 ? undefined : '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) : undefined, odataPathIntent: operationPathExpr ? intent : undefined, parserWarning: operationPathExpr ? undefined : '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' });
+            const operationPathExpr = safeOperationName(firstArg.value);
+            add(node, { callType: 'remote_action', serviceVariableName: rootReceiver ?? receiver, operationPathExpr, payloadSummary: summarizeExpression(node.getText(source)), confidence: operationPathExpr ? 0.75 : 0.35, unresolvedReason: operationPathExpr ? undefined : 'unsupported_cap_send_signature' }, { receiver, rootReceiver, classifier: operationPathExpr ? 'service_client_send_operation_event' : 'service_client_send_unsupported_signature', rawOperationExpression: firstArg.rawExpression, literalOperationSource: firstArg.value ? firstArg.sourceKind : undefined, parserWarning: operationPathExpr ? undefined : 'unsupported_cap_send_signature' });
           }
         }
       } else if (((ts.isCallExpression(expr) && ts.isIdentifier(expr.expression) && wrapperSpecs.has(expr.expression.text)) || (ts.isIdentifier(expr) && wrapperSpecs.has(expr.text)))) {