@saptools/service-flow 0.1.42 → 0.1.44

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/indexer/repository-indexer.ts

@@ -42,42 +42,68 @@ interface ParsedFacts {
   symbolCalls: SymbolCallFact[];
   fileRecords: Array<{ relativePath: string; extension: string; sha256: string; sizeBytes: number }>;
 }
+export interface PreparedRepositoryIndex extends IndexRepoResult {
+  repo: RepoRow;
+  packageFacts?: Awaited<ReturnType<typeof parsePackageJson>>;
+  fingerprint?: string;
+  kind?: string;
+  parsed?: ParsedFacts;
+}
 export async function indexRepository(
   db: Db,
   repo: RepoRow,
   force: boolean,
 ): Promise<IndexRepoResult> {
   try {
-    const sourceFiles = await findSourceFiles(repo.absolute_path);
-    const packageFacts = await parsePackageJson(repo.absolute_path);
-    const fingerprint = await repositoryFingerprint(repo.absolute_path, sourceFiles, packageFacts);
-    if (!force && repo.fingerprint === fingerprint) return { fileCount: 0, diagnosticCount: 0, skipped: true };
-    const kind = await classifyRepository(repo.absolute_path, packageFacts);
-    const parsed = await parseAllSourceFacts(repo.absolute_path, sourceFiles);
-    db.transaction(() => {
-      db.prepare('UPDATE repositories SET package_name=?, package_version=?, dependencies_json=?, kind=?, index_status=? WHERE id=?').run(packageFacts.packageName, packageFacts.packageVersion, JSON.stringify(packageFacts.dependencies), kind, 'indexing', repo.id);
-      clearRepoFacts(db, repo.id);
-      insertRequires(db, repo.id, packageFacts.cdsRequires);
-      const fileStmt = db.prepare('INSERT INTO files(repo_id,relative_path,extension,sha256,size_bytes,last_indexed_at) VALUES(?,?,?,?,?,?) ON CONFLICT(repo_id,relative_path) DO UPDATE SET sha256=excluded.sha256,size_bytes=excluded.size_bytes,last_indexed_at=excluded.last_indexed_at');
-      for (const file of parsed.fileRecords) fileStmt.run(repo.id, file.relativePath, file.extension, file.sha256, file.sizeBytes, new Date().toISOString());
-      for (const s of parsed.services) insertService(db, repo.id, s);
-      for (const h of parsed.handlers) insertHandler(db, repo.id, h);
-      insertExecutableSymbols(db, repo.id, parsed.symbols);
-      insertSymbolCalls(db, repo.id, parsed.symbolCalls);
-      insertRegistrations(db, repo.id, parsed.registrations);
-      insertBindings(db, repo.id, parsed.bindings);
-      insertCalls(db, repo.id, parsed.calls);
-      db.prepare("UPDATE repositories SET last_indexed_at=?, index_status='indexed', error_count=0, fingerprint=?, fact_generation=COALESCE(fact_generation,0)+1, graph_stale_reason='facts_changed', graph_stale_at=?, fact_analyzer_version=? WHERE id=?").run(new Date().toISOString(), fingerprint, new Date().toISOString(), ANALYZER_VERSION, repo.id);
-    });
-    return { fileCount: sourceFiles.length, diagnosticCount: 0, skipped: false };
+    const prepared = await prepareRepositoryIndex(repo, force);
+    if (!prepared.skipped) db.transaction(() => publishPreparedRepositoryIndex(db, prepared));
+    return { fileCount: prepared.fileCount, diagnosticCount: prepared.diagnosticCount, skipped: prepared.skipped };
   } catch (error) {
-    const message = errorMessage(error);
-    db.prepare("UPDATE repositories SET index_status='failed', error_count=1 WHERE id=?").run(repo.id);
-    db.prepare("DELETE FROM diagnostics WHERE repo_id=? AND code IN ('index_failed_snapshot_preserved','source_read_failed')").run(repo.id);
-    db.prepare('INSERT INTO diagnostics(repo_id,severity,code,message) VALUES(?,?,?,?)').run(repo.id, 'error', 'source_read_failed', `Index failed before publication; previous facts and fingerprint were preserved. ${message}`);
+    recordIndexFailure(db, repo.id, error);
     return { fileCount: 0, diagnosticCount: 1, skipped: false };
   }
 }
+export async function prepareRepositoryIndex(repo: RepoRow, force: boolean): Promise<PreparedRepositoryIndex> {
+  const sourceFiles = await findSourceFiles(repo.absolute_path);
+  const packageFacts = await parsePackageJson(repo.absolute_path);
+  const fingerprint = await repositoryFingerprint(repo.absolute_path, sourceFiles, packageFacts);
+  if (!force && repo.fingerprint === fingerprint) return { repo, fileCount: 0, diagnosticCount: 0, skipped: true };
+  return {
+    repo,
+    packageFacts,
+    fingerprint,
+    kind: await classifyRepository(repo.absolute_path, packageFacts),
+    parsed: await parseAllSourceFacts(repo.absolute_path, sourceFiles),
+    fileCount: sourceFiles.length,
+    diagnosticCount: 0,
+    skipped: false,
+  };
+}
+export function publishPreparedRepositoryIndex(db: Db, prepared: PreparedRepositoryIndex): void {
+  if (prepared.skipped) return;
+  if (!prepared.packageFacts || !prepared.parsed || !prepared.fingerprint || !prepared.kind) throw new Error('Prepared repository index is missing publication facts');
+  const now = new Date().toISOString();
+  const repoId = prepared.repo.id;
+  db.prepare('UPDATE repositories SET package_name=?, package_version=?, dependencies_json=?, kind=?, index_status=? WHERE id=?').run(prepared.packageFacts.packageName, prepared.packageFacts.packageVersion, JSON.stringify(prepared.packageFacts.dependencies), prepared.kind, 'indexing', repoId);
+  clearRepoFacts(db, repoId);
+  insertRequires(db, repoId, prepared.packageFacts.cdsRequires);
+  const fileStmt = db.prepare('INSERT INTO files(repo_id,relative_path,extension,sha256,size_bytes,last_indexed_at) VALUES(?,?,?,?,?,?) ON CONFLICT(repo_id,relative_path) DO UPDATE SET sha256=excluded.sha256,size_bytes=excluded.size_bytes,last_indexed_at=excluded.last_indexed_at');
+  for (const file of prepared.parsed.fileRecords) fileStmt.run(repoId, file.relativePath, file.extension, file.sha256, file.sizeBytes, now);
+  for (const service of prepared.parsed.services) insertService(db, repoId, service);
+  for (const handler of prepared.parsed.handlers) insertHandler(db, repoId, handler);
+  insertExecutableSymbols(db, repoId, prepared.parsed.symbols);
+  insertSymbolCalls(db, repoId, prepared.parsed.symbolCalls);
+  insertRegistrations(db, repoId, prepared.parsed.registrations);
+  insertBindings(db, repoId, prepared.parsed.bindings);
+  insertCalls(db, repoId, prepared.parsed.calls);
+  db.prepare("UPDATE repositories SET last_indexed_at=?, index_status='indexed', error_count=0, fingerprint=?, fact_generation=COALESCE(fact_generation,0)+1, graph_stale_reason='facts_changed', graph_stale_at=?, fact_analyzer_version=? WHERE id=?").run(now, prepared.fingerprint, now, ANALYZER_VERSION, repoId);
+}
+export function recordIndexFailure(db: Db, repoId: number, error: unknown): void {
+  const message = errorMessage(error);
+  db.prepare("UPDATE repositories SET index_status='failed', error_count=1 WHERE id=?").run(repoId);
+  db.prepare("DELETE FROM diagnostics WHERE repo_id=? AND code IN ('index_failed_snapshot_preserved','source_read_failed')").run(repoId);
+  db.prepare('INSERT INTO diagnostics(repo_id,severity,code,message) VALUES(?,?,?,?)').run(repoId, 'error', 'source_read_failed', `Index failed before publication; previous facts and fingerprint were preserved. ${message}`);
+}
 async function parseAllSourceFacts(root: string, files: string[]): Promise<ParsedFacts> {
   const facts: ParsedFacts = { services: [], handlers: [], registrations: [], bindings: [], calls: [], symbols: [], symbolCalls: [], fileRecords: [] };
   for (const file of files) {

package/src/indexer/workspace-indexer.ts

@@ -1,12 +1,12 @@
 import type { Db } from '../db/connection.js';
 import { listRepositories, repoByName } from '../db/repositories.js';
 import { errorMessage } from '../utils/diagnostics.js';
-import { indexRepository } from './repository-indexer.js';
+import { prepareRepositoryIndex, publishPreparedRepositoryIndex, recordIndexFailure, type PreparedRepositoryIndex } from './repository-indexer.js';
 import { materializeCdsExtensionOperations } from './cds-extension-resolver.js';
 export async function indexWorkspace(
   db: Db,
   workspaceId: number,
-  options: { repo?: string; force: boolean },
+  options: { repo?: string; force: boolean; injectDerivedMaterializationFailure?: boolean },
 ): Promise<{ repoCount: number; indexedCount: number; skippedCount: number; fileCount: number; diagnosticCount: number }> {
   const started = new Date().toISOString();
   const repos = options.repo ? [repoByName(db, options.repo)].filter((r) => r !== undefined) : listRepositories(db);
@@ -14,17 +14,29 @@ export async function indexWorkspace(
   let fileCount = 0;
   let diagnosticCount = 0;
   let skippedCount = 0;
+  const preparedRows: PreparedRepositoryIndex[] = [];
+  let activeRepoId: number | undefined;
   try {
     for (const repo of repos) {
-      const result = await indexRepository(db, repo, options.force);
+      activeRepoId = repo.id;
+      const result = await prepareRepositoryIndex(repo, options.force);
+      preparedRows.push(result);
       fileCount += result.fileCount;
       diagnosticCount += result.diagnosticCount;
       skippedCount += result.skipped ? 1 : 0;
     }
-    materializeCdsExtensionOperations(db, workspaceId);
-    db.prepare('UPDATE index_runs SET finished_at=?, status=?, file_count=?, diagnostic_count=? WHERE id=?').run(new Date().toISOString(), diagnosticCount ? 'failed' : 'success', fileCount, diagnosticCount, runId);
+    db.transaction(() => {
+      for (const row of preparedRows) {
+        activeRepoId = row.repo.id;
+        publishPreparedRepositoryIndex(db, row);
+      }
+      if (options.injectDerivedMaterializationFailure) throw new Error('Injected derived materialization failure');
+      materializeCdsExtensionOperations(db, workspaceId);
+      db.prepare('UPDATE index_runs SET finished_at=?, status=?, file_count=?, diagnostic_count=? WHERE id=?').run(new Date().toISOString(), diagnosticCount ? 'failed' : 'success', fileCount, diagnosticCount, runId);
+    });
     return { repoCount: repos.length, indexedCount: repos.length - skippedCount, skippedCount, fileCount, diagnosticCount };
   } catch (error) {
+    if (activeRepoId && preparedRows.length < repos.length) recordIndexFailure(db, activeRepoId, error);
     db.prepare("UPDATE index_runs SET finished_at=?, status='failed', file_count=?, diagnostic_count=?, error_message=? WHERE id=?").run(new Date().toISOString(), fileCount, diagnosticCount + 1, errorMessage(error), runId);
     throw error;
   }

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

@@ -162,7 +162,11 @@ function linkImplementations(db: Db, workspaceId: number, generation: number): {
     const accepted = candidates.filter((candidate) => candidate.accepted);
     const topScore = accepted[0]?.score ?? 0;
     const winners = accepted.filter((candidate) => candidate.score === topScore);
-    const unique = winners.length === 1 ? winners[0] : undefined;
+    const duplicateFamilies = duplicatePackageFamilies(accepted);
+    const duplicatePackageAmbiguous = duplicateFamilies.length > 0 && !accepted.some(hasDirectOwnershipEvidence);
+    const selected = duplicatePackageAmbiguous ? accepted : winners;
+    const unique = !duplicatePackageAmbiguous && winners.length === 1 ? winners[0] : undefined;
+    const ambiguityReasons = duplicatePackageAmbiguous ? ['duplicate_package_name_candidates'] : winners.length > 1 ? ['multiple_equal_score_implementation_candidates'] : [];
     const evidence = {
       servicePath: operation.servicePath,
       operationPath: operation.operationPath,
@@ -171,6 +175,8 @@ function linkImplementations(db: Db, workspaceId: number, generation: number): {
       implementationSource: implementationContext.operationId === operation.operationId ? 'direct_or_concrete_override' : 'inherited_from_base_operation',
       baseOperationId: operation.baseOperationId,
       implementationOperationId: implementationContext.operationId,
+      ambiguityReasons,
+      candidateFamilies: duplicateFamilies,
       candidates: candidates.map((candidate, index) => candidateEvidence(candidate, index + 1)),
     };
     if (accepted.length === 0) {
@@ -179,7 +185,7 @@ function linkImplementations(db: Db, workspaceId: number, generation: number): {
       unresolvedCount += 1;
       continue;
     }
-    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, 'OPERATION_IMPLEMENTED_BY_HANDLER', unique ? 'resolved' : 'ambiguous', 'operation', graphId(operation.operationId), unique ? 'handler_method' : 'handler_method_candidates', unique ? graphId(unique.methodId) : winners.map((row) => graphId(row.methodId)).join(','), unique ? 0.95 : 0.5, JSON.stringify(evidence), 0, unique ? null : 'Ambiguous registered handler implementation candidates', generation);
+    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, 'OPERATION_IMPLEMENTED_BY_HANDLER', unique ? 'resolved' : 'ambiguous', 'operation', graphId(operation.operationId), unique ? 'handler_method' : 'handler_method_candidates', unique ? graphId(unique.methodId) : selected.map((row) => graphId(row.methodId)).join(','), unique ? 0.95 : 0.5, JSON.stringify(evidence), 0, unique ? null : 'Ambiguous registered handler implementation candidates', generation);
     edgeCount += 1;
     if (unique) resolvedCount += 1;
     else ambiguousCount += 1;
@@ -232,6 +238,20 @@ function uniqueRegistrations(rows: Array<Record<string, unknown>>): Array<Record
     return true;
   });
 }
+function duplicatePackageFamilies(candidates: ImplementationCandidate[]): Array<Record<string, unknown>> {
+  const byPackage = new Map<string, ImplementationCandidate[]>();
+  for (const candidate of candidates) {
+    const packageName = typeof candidate.handlerPackage === 'string' ? candidate.handlerPackage : undefined;
+    if (!packageName) continue;
+    byPackage.set(packageName, [...(byPackage.get(packageName) ?? []), candidate]);
+  }
+  return [...byPackage.entries()]
+    .filter(([, rows]) => new Set(rows.map((row) => Number(row.handlerRepoId))).size > 1)
+    .map(([packageName, rows]) => ({ reason: 'duplicate_package_name_candidates', packageName, count: rows.length, repositories: rows.map((row) => row.handlerRepo).sort() }));
+}
+function hasDirectOwnershipEvidence(candidate: ImplementationCandidate): boolean {
+  return candidate.acceptedReasons.some((reason) => reason === 'model package equals registration package' || reason === 'model package equals handler package' || reason === 'registration package contains exact local service path');
+}
 function implementationCandidates(db: Db, workspaceId: number, operation: Record<string, unknown>): Array<Record<string, unknown>> {
   const modelRepoGraphId = graphId(operation.modelRepoId);
   return db.prepare(`SELECT DISTINCT

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');
@@ -335,7 +338,7 @@ function isSupportedEventReceiver(receiver: string | undefined, rootReceiver: st
   if (/^(srv|service|serviceClient|messaging|messageClient|eventClient)$/.test(candidate)) return true;
   return false;
 }
-interface WrapperSpec { clientIndex?: number; clientName?: string; pathIndex: number; methodIndex?: number; methodName?: string; methodLiteral?: string; definitionLine: number; internalStart: number; internalEnd: number }
+interface WrapperSpec { clientIndex?: number; clientName?: string; pathIndex: number; methodIndex?: number; methodName?: string; methodLiteral?: string; nestedWrapperFunction?: string; definitionLine: number; internalStart: number; internalEnd: number }
 function collectWrapperSpecs(source: ts.SourceFile): Map<string, WrapperSpec> {
   const specs = new Map<string, WrapperSpec>();
   const serviceVariables = collectServiceVariables(source);
@@ -351,7 +354,7 @@ function collectWrapperSpecs(source: ts.SourceFile): Map<string, WrapperSpec> {
   const scanFunction = (name: string, fn: ts.FunctionLikeDeclaration): void => {
     if (!calledNames.has(name)) return;
     const params = fn.parameters.map((param) => ts.isIdentifier(param.name) ? param.name.text : undefined);
-    const sends: Array<{ client: string; path: string; method?: string; methodLiteral?: string; start: number; end: number }> = [];
+    const sends: Array<{ client: string; path: string; method?: string; methodLiteral?: string; nestedWrapperFunction?: string; start: number; end: number }> = [];
     const visit = (node: ts.Node): void => {
       if (ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression) && node.expression.name.text === 'send' && ts.isIdentifier(node.expression.expression)) {
         const objectArg = node.arguments[0];
@@ -364,6 +367,14 @@ function collectWrapperSpecs(source: ts.SourceFile): Map<string, WrapperSpec> {
           if (pathName) sends.push({ client: node.expression.expression.text, path: pathName, method: methodName, methodLiteral, start: node.getStart(source), end: node.getEnd() });
         }
       }
+      if (ts.isCallExpression(node) && ts.isIdentifier(node.expression) && specs.has(node.expression.text)) {
+        const nested = specs.get(node.expression.text);
+        const pathArg = nested ? node.arguments[nested.pathIndex] : undefined;
+        const clientArg = nested?.clientIndex === undefined ? undefined : node.arguments[nested.clientIndex];
+        const pathName = pathArg && ts.isIdentifier(pathArg) ? pathArg.text : undefined;
+        const clientName = clientArg && ts.isIdentifier(clientArg) ? clientArg.text : nested?.clientName;
+        if (nested && pathName && clientName) sends.push({ client: clientName, path: pathName, method: nested.methodName, methodLiteral: nested.methodLiteral, nestedWrapperFunction: node.expression.text, start: node.getStart(source), end: node.getEnd() });
+      }
       ts.forEachChild(node, visit);
     };
     visit(fn);
@@ -373,7 +384,7 @@ function collectWrapperSpecs(source: ts.SourceFile): Map<string, WrapperSpec> {
     const pathIndex = params.indexOf(found.path);
     const methodIndex = found.method ? params.indexOf(found.method) : -1;
     const capturesKnownClient = serviceVariables.has(found.client) || /^(srv|service|serviceClient|client|.*Client)$/.test(found.client);
-    if (pathIndex >= 0 && (clientIndex >= 0 || capturesKnownClient)) specs.set(name, { clientIndex: clientIndex >= 0 ? clientIndex : undefined, clientName: clientIndex >= 0 ? undefined : found.client, pathIndex, methodIndex: methodIndex >= 0 ? methodIndex : undefined, methodName: found.method, methodLiteral: found.methodLiteral, definitionLine: lineOf(source.text, fn.getStart(source)), internalStart: found.start, internalEnd: found.end });
+    if (pathIndex >= 0 && (clientIndex >= 0 || capturesKnownClient)) specs.set(name, { clientIndex: clientIndex >= 0 ? clientIndex : undefined, clientName: clientIndex >= 0 ? undefined : found.client, pathIndex, methodIndex: methodIndex >= 0 ? methodIndex : undefined, methodName: found.method, methodLiteral: found.methodLiteral, nestedWrapperFunction: found.nestedWrapperFunction, definitionLine: lineOf(source.text, fn.getStart(source)), internalStart: found.start, internalEnd: found.end });
   };
   const visitTop = (node: ts.Node): void => {
     if (ts.isFunctionDeclaration(node) && node.name) scanFunction(node.name.text, node);
@@ -426,16 +437,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)))) {
@@ -451,7 +464,7 @@ export function classifyOutboundCallsInSource(source: ts.SourceFile, filePath: s
         const operationPathExpr = operationPathFromStatic(resolvedPath.text);
         const normalizedOperationPath = operationPathExpr ? classifyODataPathIntent(operationPathExpr, method).topLevelOperationName : undefined;
         if (spec && receiver && operationPathExpr) {
-          add(node, { callType: 'remote_action', serviceVariableName: receiver, method, operationPathExpr, payloadSummary: summarizeExpression(node.getText(source)), confidence: 0.75 }, { receiver, classifier: resolvedPath.sourceKind === 'literal' ? 'higher_order_wrapper_literal_path' : 'higher_order_wrapper_static_path', wrapperFunction: wrapperName, wrapperDefinitionLine: spec.definitionLine, callerLine: lineOf(source.text, node.getStart(source)), wrapperPathSourceKind: resolvedPath.sourceKind, rawPathExpression: resolvedPath.rawExpression, normalizedOperationPath, literalPathSource: resolvedPath.sourceKind === 'const' ? 'same_scope_const_initializer' : `wrapper_call_${resolvedPath.sourceKind}`, literalCallerArgumentDetected: true });
+          add(node, { callType: 'remote_action', serviceVariableName: receiver, method, operationPathExpr, payloadSummary: summarizeExpression(node.getText(source)), confidence: 0.75 }, { receiver, classifier: resolvedPath.sourceKind === 'literal' ? 'higher_order_wrapper_literal_path' : 'higher_order_wrapper_static_path', wrapperFunction: wrapperName, nestedWrapperFunction: spec.nestedWrapperFunction, wrapperDefinitionLine: spec.definitionLine, callerLine: lineOf(source.text, node.getStart(source)), wrapperPathSourceKind: resolvedPath.sourceKind, rawPathExpression: resolvedPath.rawExpression, normalizedOperationPath, literalPathSource: resolvedPath.sourceKind === 'const' ? 'same_scope_const_initializer' : `wrapper_call_${resolvedPath.sourceKind}`, literalCallerArgumentDetected: true });
         } else if (spec && receiver) {
           add(node, { callType: 'remote_action', serviceVariableName: receiver, method, payloadSummary: summarizeExpression(node.getText(source)), confidence: 0.45, unresolvedReason: 'dynamic_operation_path_identifier' }, { receiver, classifier: 'higher_order_wrapper_dynamic_path', wrapperFunction: wrapperName, wrapperDefinitionLine: spec.definitionLine, callerLine: lineOf(source.text, node.getStart(source)), wrapperPathSourceKind: resolvedPath.sourceKind, rawPathExpression: resolvedPath.rawExpression, parserWarning: 'dynamic_operation_path_identifier' });
         }

package/src/parsers/service-binding-parser-helpers.ts

@@ -0,0 +1,160 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import ts from 'typescript';
+import { normalizePath } from '../utils/path-utils.js';
+
+export interface HelperBinding {
+  exportedName: string;
+  returnedProperty?: string;
+  alias?: string;
+  aliasExpr?: string;
+  destinationExpr?: string;
+  servicePathExpr?: string;
+  isDynamic: boolean;
+  placeholders: string[];
+  helperChain?: Array<Record<string, unknown>>;
+  sourceFile: string;
+  sourceLine: number;
+}
+export interface ImportBinding {
+  localName: string;
+  exportedName: string;
+  sourceFile?: string;
+}
+export interface ClassHelperReturn {
+  className: string;
+  helperName: string;
+  propertyName: string;
+  variableName: string;
+  fact: Omit<HelperBinding, 'exportedName' | 'sourceFile' | 'sourceLine'>;
+  sourceLine: number;
+}
+
+export function lineOf(sf: ts.SourceFile, node: ts.Node): number {
+  return sf.getLineAndCharacterOfPosition(node.getStart(sf)).line + 1;
+}
+
+function stringValue(node: ts.Expression | undefined): string | undefined {
+  if (!node) return undefined;
+  if (ts.isStringLiteralLike(node) || ts.isNoSubstitutionTemplateLiteral(node)) return node.text;
+  if (ts.isTemplateExpression(node)) return node.getText().replace(/^`|`$/g, '');
+  return node.getText();
+}
+
+function placeholders(value?: string): string[] {
+  return [...(value ?? '').matchAll(/\$\{([^}]*)\}/g)].map((m) => (m[1] ?? '').trim()).filter(Boolean);
+}
+
+export function connectFactFromCall(call: ts.CallExpression): Omit<HelperBinding, 'exportedName' | 'sourceFile' | 'sourceLine'> | undefined {
+  const expr = call.expression;
+  if (!ts.isPropertyAccessExpression(expr) || expr.name.text !== 'to') return undefined;
+  const inner = expr.expression;
+  if (!ts.isPropertyAccessExpression(inner) || inner.name.text !== 'connect' || inner.expression.getText() !== 'cds') return undefined;
+  const first = call.arguments[0];
+  if (!first) return undefined;
+  const second = call.arguments[1];
+  const objectArg = ts.isObjectLiteralExpression(first) ? first : second && ts.isObjectLiteralExpression(second) ? second : undefined;
+  let alias: string | undefined;
+  let aliasExpr: string | undefined;
+  if (ts.isStringLiteralLike(first) || ts.isNoSubstitutionTemplateLiteral(first)) alias = first.text;
+  else if (!ts.isObjectLiteralExpression(first)) aliasExpr = stringValue(first);
+  if ((ts.isStringLiteralLike(first) || ts.isNoSubstitutionTemplateLiteral(first)) && !objectArg) return { alias: first.text, isDynamic: false, placeholders: [] };
+  if (!objectArg && aliasExpr) return { aliasExpr, isDynamic: true, placeholders: placeholders(aliasExpr) };
+  const expressions = objectArg ? objectExpressions(objectArg) : {};
+  const ph = [...placeholders(aliasExpr ?? alias), ...placeholders(expressions.destinationExpr), ...placeholders(expressions.servicePathExpr)];
+  return { alias, aliasExpr, ...expressions, isDynamic: ph.length > 0 || (!expressions.destinationExpr && !expressions.servicePathExpr), placeholders: ph };
+}
+
+function objectExpressions(objectArg: ts.ObjectLiteralExpression): { destinationExpr?: string; servicePathExpr?: string } {
+  const out: { destinationExpr?: string; servicePathExpr?: string } = {};
+  function visitObject(obj: ts.ObjectLiteralExpression): void {
+    for (const prop of obj.properties) {
+      if (!ts.isPropertyAssignment(prop)) continue;
+      const name = ts.isIdentifier(prop.name) || ts.isStringLiteralLike(prop.name) ? prop.name.text : undefined;
+      if (name === 'destination') out.destinationExpr = stringValue(prop.initializer);
+      if (name === 'path' || name === 'servicePath') out.servicePathExpr = stringValue(prop.initializer);
+      if (ts.isObjectLiteralExpression(prop.initializer)) visitObject(prop.initializer);
+    }
+  }
+  visitObject(objectArg);
+  return out;
+}
+
+export function unwrapCall(expr: ts.Expression): ts.CallExpression | undefined {
+  if (ts.isAwaitExpression(expr)) return unwrapCall(expr.expression);
+  if (ts.isParenthesizedExpression(expr)) return unwrapCall(expr.expression);
+  if (ts.isAsExpression(expr) || ts.isSatisfiesExpression(expr)) return unwrapCall(expr.expression);
+  if (ts.isTypeAssertionExpression(expr)) return unwrapCall(expr.expression);
+  if (ts.isCallExpression(expr)) return expr;
+  return undefined;
+}
+
+export function unwrapIdentityExpression(expr: ts.Expression): ts.Expression {
+  if (ts.isAwaitExpression(expr)) return unwrapIdentityExpression(expr.expression);
+  if (ts.isParenthesizedExpression(expr)) return unwrapIdentityExpression(expr.expression);
+  if (ts.isAsExpression(expr) || ts.isSatisfiesExpression(expr)) return unwrapIdentityExpression(expr.expression);
+  if (ts.isTypeAssertionExpression(expr)) return unwrapIdentityExpression(expr.expression);
+  return expr;
+}
+
+export function transactionReceiverName(expr: ts.Expression): string | undefined {
+  const call = unwrapCall(expr);
+  if (call && ts.isPropertyAccessExpression(call.expression) && ['tx', 'transaction'].includes(call.expression.name.text) && ts.isIdentifier(call.expression.expression)) return call.expression.expression.text;
+  const unwrapped = unwrapIdentityExpression(expr);
+  if (!ts.isConditionalExpression(unwrapped)) return undefined;
+  const left = transactionReceiverName(unwrapped.whenTrue);
+  const right = transactionReceiverName(unwrapped.whenFalse);
+  return left && left === right ? left : undefined;
+}
+
+export function findConnectInExpression(expr: ts.Expression): Omit<HelperBinding, 'exportedName' | 'sourceFile' | 'sourceLine'> | undefined {
+  const direct = unwrapCall(expr);
+  if (direct) {
+    const fact = connectFactFromCall(direct);
+    if (fact) return fact;
+  }
+  let found: Omit<HelperBinding, 'exportedName' | 'sourceFile' | 'sourceLine'> | undefined;
+  function visit(node: ts.Node): void {
+    if (found) return;
+    if (ts.isCallExpression(node)) found = connectFactFromCall(node);
+    if (!found) ts.forEachChild(node, visit);
+  }
+  visit(expr);
+  return found;
+}
+
+export async function readSource(abs: string): Promise<ts.SourceFile | undefined> {
+  try {
+    const text = await fs.readFile(abs, 'utf8');
+    return ts.createSourceFile(abs, text, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+  } catch {
+    return undefined;
+  }
+}
+
+async function resolveImport(repoPath: string, fromFile: string, spec: string): Promise<string | undefined> {
+  if (!spec.startsWith('.')) return undefined;
+  const rawBase = path.resolve(repoPath, path.dirname(fromFile), spec);
+  const parsed = path.parse(rawBase);
+  const base = ['.js', '.mjs', '.cjs', '.ts', '.mts', '.cts'].includes(parsed.ext) ? path.join(parsed.dir, parsed.name) : rawBase;
+  for (const candidate of [base, `${base}.ts`, `${base}.js`, path.join(base, 'index.ts'), path.join(base, 'index.js')]) {
+    const stat = await fs.stat(candidate).catch(() => undefined);
+    if (stat?.isFile()) return normalizePath(path.relative(repoPath, candidate));
+  }
+  return undefined;
+}
+
+export async function importsFor(repoPath: string, filePath: string, sf: ts.SourceFile): Promise<ImportBinding[]> {
+  const imports: ImportBinding[] = [];
+  for (const stmt of sf.statements) {
+    if (!ts.isImportDeclaration(stmt) || !ts.isStringLiteralLike(stmt.moduleSpecifier)) continue;
+    const sourceFile = await resolveImport(repoPath, filePath, stmt.moduleSpecifier.text);
+    const clause = stmt.importClause;
+    if (!clause) continue;
+    if (clause.name) imports.push({ localName: clause.name.text, exportedName: 'default', sourceFile });
+    const bindings = clause.namedBindings;
+    if (bindings && ts.isNamedImports(bindings))
+      for (const el of bindings.elements) imports.push({ localName: el.name.text, exportedName: el.propertyName?.text ?? el.name.text, sourceFile });
+  }
+  return imports;
+}