@saptools/service-flow 0.1.52 → 0.1.53

package/dist/index.js

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

package/src/cli/001-doctor-projection.ts

@@ -0,0 +1,140 @@
+import {
+  projectBounded,
+  stableProjectionValue,
+  type BoundedProjection,
+} from '../utils/000-bounded-projection.js';
+
+type Diagnostic = Record<string, unknown>;
+
+const boundedDoctorArrayKeys = new Set([
+  'candidates',
+  'candidateScores',
+  'candidateFamilies',
+  'candidateEvidence',
+  'candidatePaths',
+  'candidateRawPaths',
+  'candidateNormalizedOperationPaths',
+  'normalizedCandidateOperations',
+  'candidateLiterals',
+  'bindingCandidates',
+  'bindingAlternatives',
+  'registrations',
+  'implementationHintSuggestions',
+  'selectableImplementationRepositories',
+  'matchedHints',
+  'candidateSuggestions',
+  'dynamicTargetCandidates',
+  'dynamicTargetCandidateSuggestions',
+  'rejectedCandidates',
+  'suggestedVarSets',
+  'copyableExamples',
+  'examples',
+  'expandedExamples',
+  'selectorSuggestions',
+  'serviceSuggestions',
+  'repositories',
+]);
+
+export function boundDoctorDiagnostics(diagnostics: Diagnostic[]): Diagnostic[] {
+  return diagnostics.map(boundDoctorDiagnostic);
+}
+
+function boundDoctorDiagnostic(diagnostic: Diagnostic): Diagnostic {
+  const bounded = boundDoctorValue(diagnostic);
+  return isDiagnostic(bounded) ? bounded : {};
+}
+
+function boundDoctorValue(value: unknown): unknown {
+  if (Array.isArray(value)) return value.map(boundDoctorValue);
+  if (!isDiagnostic(value)) return value;
+  const input = value;
+  const output: Diagnostic = {};
+  for (const [key, child] of Object.entries(input)) {
+    if (!Array.isArray(child) || !boundedDoctorArrayKeys.has(key)) {
+      output[key] = boundDoctorValue(child);
+      continue;
+    }
+    const projection = projectBounded(child.map(boundDoctorValue), compareDiagnostic);
+    output[key] = projection.items;
+    addProjectionMetadata(output, input, key, projection);
+  }
+  return output;
+}
+
+function isDiagnostic(value: unknown): value is Diagnostic {
+  return Boolean(value && typeof value === 'object' && !Array.isArray(value));
+}
+
+function addProjectionMetadata(
+  output: Diagnostic,
+  input: Diagnostic,
+  key: string,
+  projection: BoundedProjection<unknown>,
+): void {
+  const names = projectionNames(key);
+  const total = Math.max(
+    numericValue(input[names.total]),
+    projection.totalCount,
+    siblingCollectionCount(input, key),
+  );
+  output[names.total] = total;
+  output[names.shown] = projection.shownCount;
+  output[names.omitted] = Math.max(0, total - projection.shownCount);
+}
+
+function siblingCollectionCount(input: Diagnostic, key: string): number {
+  if (key !== 'examples' || !Array.isArray(input.expandedExamples)) return 0;
+  return input.expandedExamples.length;
+}
+
+function projectionNames(key: string): { total: string; shown: string; omitted: string } {
+  const stem = projectionStem(key);
+  return {
+    total: `${stem}Count`,
+    shown: `shown${upperFirst(stem)}Count`,
+    omitted: `omitted${upperFirst(stem)}Count`,
+  };
+}
+
+function projectionStem(key: string): string {
+  const stems: Record<string, string> = {
+    candidates: 'candidate',
+    candidateScores: 'candidateScore',
+    candidateFamilies: 'candidateFamily',
+    candidateEvidence: 'candidateEvidence',
+    candidatePaths: 'candidatePath',
+    candidateRawPaths: 'candidateRawPath',
+    candidateNormalizedOperationPaths: 'candidateNormalizedOperationPath',
+    normalizedCandidateOperations: 'normalizedCandidateOperation',
+    candidateLiterals: 'candidateLiteral',
+    bindingCandidates: 'bindingCandidate',
+    bindingAlternatives: 'bindingAlternative',
+    registrations: 'registration',
+    implementationHintSuggestions: 'implementationHintSuggestion',
+    selectableImplementationRepositories: 'selectableImplementationRepository',
+    matchedHints: 'matchedHint',
+    candidateSuggestions: 'candidateSuggestion',
+    dynamicTargetCandidates: 'dynamicTargetCandidate',
+    dynamicTargetCandidateSuggestions: 'dynamicTargetCandidateSuggestion',
+    rejectedCandidates: 'rejectedCandidate',
+    suggestedVarSets: 'suggestedVarSet',
+    copyableExamples: 'copyableExample',
+    examples: 'example',
+    expandedExamples: 'expandedExample',
+    selectorSuggestions: 'selectorSuggestion',
+    serviceSuggestions: 'serviceSuggestion',
+  };
+  return stems[key] ?? 'repository';
+}
+
+function compareDiagnostic(left: unknown, right: unknown): number {
+  return stableProjectionValue(left).localeCompare(stableProjectionValue(right));
+}
+
+function numericValue(value: unknown): number {
+  return typeof value === 'number' && Number.isFinite(value) ? value : 0;
+}
+
+function upperFirst(value: string): string {
+  return value ? `${value[0]?.toUpperCase() ?? ''}${value.slice(1)}` : value;
+}

package/src/cli/doctor.ts

@@ -1,6 +1,7 @@
 import type { Db } from '../db/connection.js';
 import { classifyODataPathIntent, normalizeODataOperationInvocationPath } from '../linker/odata-path-normalizer.js';
 import { implementationHintSuggestions } from '../trace/implementation-hints.js';
+import { boundDoctorDiagnostics } from './001-doctor-projection.js';
 import { ANALYZER_VERSION } from '../version.js';
 
 type Diagnostic = Record<string, unknown>;
@@ -15,7 +16,7 @@ export function linkUpgradeWarnings(db: Db): Diagnostic[] {
 
 export function doctorDiagnostics(db: Db, strict: boolean, options: DoctorOptions = {}): Diagnostic[] {
   const diagnostics = db.prepare('SELECT severity,code,message,source_file sourceFile,source_line sourceLine FROM diagnostics ORDER BY id').all() as Diagnostic[];
-  return [
+  return boundDoctorDiagnostics([
     ...diagnostics,
     ...healthDiagnostics(db, strict),
     ...remoteTargetWithoutImplementationDiagnostics(db, strict, Boolean(options.detail)),
@@ -23,7 +24,7 @@ export function doctorDiagnostics(db: Db, strict: boolean, options: DoctorOption
     ...schemaDriftDiagnostics(db, strict),
     ...analyzerVersionDiagnostics(db, strict),
     ...parserQualityDiagnostics(db, strict, options),
-  ];
+  ]);
 }
 
 function healthDiagnostics(db: Db, strict: boolean): Diagnostic[] {
@@ -252,6 +253,10 @@ function addImplementationCategory(grouped: Map<string, Diagnostic & { count: nu
   const current = grouped.get(key) ?? { category, baseOperation, reason, candidateFamily: family, count: 0, servicePaths: [], examples: [] };
   const hintSuggestions = implementationSuggestions(evidence);
   const candidates = asRecords(evidence.candidates);
+  const candidateCount = Math.max(
+    numericValue(evidence.candidateCount),
+    candidates.length,
+  );
   current.count += 1;
   current.servicePaths.push(String(row.servicePath ?? evidence.servicePath ?? ''));
   current.examples.push({
@@ -259,7 +264,15 @@ function addImplementationCategory(grouped: Map<string, Diagnostic & { count: nu
     operation: row.operationName,
     status: row.status,
     reason: row.unresolvedReason,
-    candidateCount: candidates.length,
+    candidateCount,
+    shownCandidateCount: Math.min(
+      candidateCount,
+      numericValue(evidence.shownCandidateCount) || candidates.length,
+    ),
+    omittedCandidateCount: Math.max(
+      0,
+      candidateCount - (numericValue(evidence.shownCandidateCount) || candidates.length),
+    ),
     candidateEvidence: candidates.slice(0, 3),
     implementationHintSuggestions: hintSuggestions,
   });
@@ -655,6 +668,10 @@ function candidateCount(value: unknown): number {
   return Number(parseObject(value).candidateCount ?? 0);
 }
 
+function numericValue(value: unknown): number {
+  return typeof value === 'number' && Number.isFinite(value) ? value : 0;
+}
+
 function parseObject(value: unknown): Diagnostic {
   if (value && typeof value === 'object' && !Array.isArray(value)) return value as Diagnostic;
   try {

package/src/db/repositories.ts

@@ -1,4 +1,5 @@
 import type { Db } from './connection.js';
+import { projectBounded } from '../utils/000-bounded-projection.js';
 import type {
   CdsRequire,
   CdsServiceFact,
@@ -596,12 +597,19 @@ function bindingEvidence(
   candidates: BindingCandidate[],
   selected?: BindingCandidate,
 ): Record<string, unknown> {
+  const projection = projectBounded(candidates, (left, right) =>
+    Number(right.id === selected?.id) - Number(left.id === selected?.id)
+    || left.sourceFile.localeCompare(right.sourceFile)
+    || left.sourceLine - right.sourceLine
+    || left.id - right.id);
   return {
     status,
-    candidateCount: candidates.length,
+    candidateCount: projection.totalCount,
+    shownCandidateCount: projection.shownCount,
+    omittedCandidateCount: projection.omittedCount,
     selectedBindingId: selected?.id,
     sourceOrderRule: 'binding_source_line_must_not_follow_call',
-    candidates: candidates.map((candidate) => ({
+    candidates: projection.items.map((candidate) => ({
       bindingId: candidate.id,
       symbolId: candidate.symbolId,
       variableName: candidate.variableName,