@saptools/service-flow 0.1.52 → 0.1.54

package/src/linker/001-implementation-evidence-projection.ts

@@ -0,0 +1,191 @@
+import {
+  projectBounded,
+  projectBoundedInOrder,
+  type BoundedProjection,
+} from '../utils/000-bounded-projection.js';
+
+export interface SelectedHandlerSource {
+  methodId: number;
+  className?: string;
+  methodName?: string;
+  repositoryId?: number;
+  repositoryName?: string;
+  repositoryPackageName?: string;
+  sourceFile?: string;
+  sourceLine?: number;
+}
+
+export interface SelectedHandlerProvenance {
+  status: 'selected';
+  accepted: true;
+  graphTargetId: string;
+  methodId: number;
+  className?: string;
+  methodName?: string;
+  repository?: {
+    id?: number;
+    name?: string;
+    packageName?: string;
+  };
+  sourceFile?: string;
+  sourceLine?: number;
+}
+
+export function selectedHandlerProvenance(
+  source: SelectedHandlerSource,
+): SelectedHandlerProvenance {
+  return {
+    status: 'selected',
+    accepted: true,
+    graphTargetId: String(source.methodId),
+    methodId: source.methodId,
+    className: source.className,
+    methodName: source.methodName,
+    repository: {
+      id: source.repositoryId,
+      name: source.repositoryName,
+      packageName: source.repositoryPackageName,
+    },
+    sourceFile: source.sourceFile,
+    sourceLine: source.sourceLine,
+  };
+}
+
+export function displayImplementationCandidates(
+  candidates: Array<Record<string, unknown>>,
+  selectedMethodId: number | undefined,
+): Array<Record<string, unknown>> {
+  return [...candidates]
+    .sort((left, right) => compareDisplayCandidate(
+      left, right, selectedMethodId,
+    ))
+    .map((candidate, index) => ({
+      ...candidate,
+      discoveryRank: candidate.rank,
+      displayRank: index + 1,
+      selected: selectedMethodId !== undefined
+        && Number(candidate.methodId) === selectedMethodId,
+    }));
+}
+
+function compareDisplayCandidate(
+  left: Record<string, unknown>,
+  right: Record<string, unknown>,
+  selectedMethodId: number | undefined,
+): number {
+  return Number(Number(right.methodId) === selectedMethodId)
+    - Number(Number(left.methodId) === selectedMethodId)
+    || Number(right.accepted === true) - Number(left.accepted === true)
+    || numberValue(left.rank) - numberValue(right.rank)
+    || compareTargetCandidates(left, right);
+}
+
+export function boundedImplementationEvidence(
+  evidence: Record<string, unknown>,
+  targetCandidateCount: number,
+): Record<string, unknown> {
+  const candidates = recordArray(evidence.candidates);
+  const candidateProjection = projectBoundedInOrder(candidates);
+  const families = recordArray(evidence.candidateFamilies);
+  const familyProjection = projectBounded(families, compareFamilies);
+  const hints = recordArray(evidence.implementationHintSuggestions);
+  const hintProjection = projectBounded(hints, compareHints);
+  const hintCount = Math.max(
+    numberValue(evidence.implementationHintSuggestionCount),
+    hintProjection.totalCount,
+  );
+  const targets = Math.max(0, targetCandidateCount);
+  return {
+    ...evidence,
+    candidates: candidateProjection.items.map(boundedCandidateEvidence),
+    candidateCount: candidateProjection.totalCount,
+    shownCandidateCount: candidateProjection.shownCount,
+    omittedCandidateCount: candidateProjection.omittedCount,
+    candidateFamilies: familyProjection.items.map(boundedFamilyEvidence),
+    candidateFamilyCount: familyProjection.totalCount,
+    shownCandidateFamilyCount: familyProjection.shownCount,
+    omittedCandidateFamilyCount: familyProjection.omittedCount,
+    implementationHintSuggestions: hintProjection.items,
+    implementationHintSuggestionCount: hintCount,
+    shownImplementationHintSuggestionCount: hintProjection.shownCount,
+    omittedImplementationHintSuggestionCount: Math.max(0, hintCount - hintProjection.shownCount),
+    candidateTargetCount: targets,
+    shownCandidateTargetCount: Math.min(targets, candidateProjection.shownCount),
+    omittedCandidateTargetCount: Math.max(0, targets - candidateProjection.shownCount),
+  };
+}
+
+export function boundedImplementationTargetIds(
+  candidates: Array<Record<string, unknown>>,
+): BoundedProjection<string> {
+  const projection = projectBounded(candidates, compareTargetCandidates);
+  return {
+    totalCount: projection.totalCount,
+    shownCount: projection.shownCount,
+    omittedCount: projection.omittedCount,
+    items: projection.items.map((candidate) => String(candidate.methodId ?? '')),
+  };
+}
+
+function boundedCandidateEvidence(candidate: Record<string, unknown>): Record<string, unknown> {
+  const registrations = recordArray(candidate.registrations);
+  const projection = projectBounded(registrations, compareRegistrations);
+  return {
+    ...candidate,
+    registrations: projection.items,
+    registrationCount: projection.totalCount,
+    shownRegistrationCount: projection.shownCount,
+    omittedRegistrationCount: projection.omittedCount,
+  };
+}
+
+function boundedFamilyEvidence(family: Record<string, unknown>): Record<string, unknown> {
+  const repositories = stringArray(family.repositories);
+  const projection = projectBounded(repositories, (left, right) => left.localeCompare(right));
+  return {
+    ...family,
+    repositories: projection.items,
+    repositoryCount: projection.totalCount,
+    shownRepositoryCount: projection.shownCount,
+    omittedRepositoryCount: projection.omittedCount,
+  };
+}
+
+function compareTargetCandidates(left: Record<string, unknown>, right: Record<string, unknown>): number {
+  return Number(right.score ?? 0) - Number(left.score ?? 0)
+    || String(left.className ?? '').localeCompare(String(right.className ?? ''))
+    || Number(left.methodId ?? 0) - Number(right.methodId ?? 0);
+}
+
+function compareFamilies(left: Record<string, unknown>, right: Record<string, unknown>): number {
+  return String(left.packageName ?? '').localeCompare(String(right.packageName ?? ''))
+    || String(left.reason ?? '').localeCompare(String(right.reason ?? ''));
+}
+
+function compareHints(left: Record<string, unknown>, right: Record<string, unknown>): number {
+  return String(left.cli ?? '').localeCompare(String(right.cli ?? ''))
+    || String(left.implementationRepo ?? '').localeCompare(String(right.implementationRepo ?? ''));
+}
+
+function compareRegistrations(left: Record<string, unknown>, right: Record<string, unknown>): number {
+  return String(left.file ?? '').localeCompare(String(right.file ?? ''))
+    || Number(left.line ?? 0) - Number(right.line ?? 0)
+    || Number(left.id ?? 0) - Number(right.id ?? 0);
+}
+
+function recordArray(value: unknown): Array<Record<string, unknown>> {
+  return Array.isArray(value)
+    ? value.filter((item): item is Record<string, unknown> =>
+        Boolean(item && typeof item === 'object' && !Array.isArray(item)))
+    : [];
+}
+
+function stringArray(value: unknown): string[] {
+  return Array.isArray(value)
+    ? value.filter((item): item is string => typeof item === 'string')
+    : [];
+}
+
+function numberValue(value: unknown): number {
+  return typeof value === 'number' && Number.isFinite(value) ? value : 0;
+}

package/src/linker/002-call-evidence.ts

@@ -0,0 +1,226 @@
+import type {
+  NormalizedODataOperationPath,
+  ODataPathIntent,
+} from './odata-path-normalizer.js';
+import {
+  boundCandidateLikeEvidence,
+  projectBounded,
+  type BoundedProjection,
+} from '../utils/000-bounded-projection.js';
+
+export interface LinkedOperationResolution {
+  target?: {
+    repoName?: string;
+    servicePath?: string;
+    operationPath?: string;
+    operationName?: string;
+  };
+  candidates: unknown[];
+  status: string;
+  reasons: string[];
+}
+
+export function linkedCallEvidence(
+  call: Record<string, unknown>,
+  resolution: LinkedOperationResolution,
+  servicePath: string | undefined,
+  operationPath: string | undefined,
+  destination: string | undefined,
+  normalized: NormalizedODataOperationPath | undefined,
+  intent: ODataPathIntent | undefined,
+): Record<string, unknown> {
+  const candidates = boundedCallCandidates(resolution.candidates);
+  return {
+    ...callLocationEvidence(call),
+    ...selectedBindingEvidence(call),
+    ...routingEvidence(call, servicePath, operationPath, destination, normalized, intent),
+    ...candidateEvidence(candidates, resolution),
+    outboundEvidence: boundCandidateLikeEvidence(objectJson(call.evidence_json) ?? {}),
+    analysisCompleteness: call.unresolved_reason ? 'partial' : 'complete',
+    parserWarning: call.unresolved_reason
+      ? { code: 'parser_warning', message: call.unresolved_reason }
+      : undefined,
+  };
+}
+
+export function ambiguousPathCandidates(
+  pathAnalysis: Record<string, unknown>,
+): BoundedProjection<string> {
+  const values = Array.isArray(pathAnalysis.candidateRawPaths)
+    ? pathAnalysis.candidateRawPaths.filter((value): value is string =>
+        typeof value === 'string')
+    : [];
+  return projectBounded(values, (left, right) => left.localeCompare(right));
+}
+
+export function objectJson(value: unknown): Record<string, unknown> | undefined {
+  const parsed = parseJson(value);
+  return isRecord(parsed) ? parsed : undefined;
+}
+
+export function objectValue(value: unknown): Record<string, unknown> | undefined {
+  return isRecord(value) ? value : undefined;
+}
+
+function callLocationEvidence(call: Record<string, unknown>): Record<string, unknown> {
+  return {
+    sourceFile: call.source_file,
+    sourceLine: call.source_line,
+    file: call.source_file,
+    line: call.source_line,
+    callId: call.id,
+    repo: call.repoName,
+  };
+}
+
+function selectedBindingEvidence(call: Record<string, unknown>): Record<string, unknown> {
+  if (!call.selectedBindingId) return {};
+  return {
+    selectedBindingId: call.selectedBindingId,
+    selectedBinding: {
+      bindingId: call.selectedBindingId,
+      alias: call.alias,
+      aliasExpr: call.aliasExpr,
+      destinationExpr: call.destinationExpr,
+      servicePathExpr: call.servicePathExpr,
+      sourceFile: call.bindingSourceFile,
+      sourceLine: call.bindingSourceLine,
+      helperChain: parseJson(call.helperChainJson),
+    },
+  };
+}
+
+function routingEvidence(
+  call: Record<string, unknown>,
+  servicePath: string | undefined,
+  operationPath: string | undefined,
+  destination: string | undefined,
+  normalized: NormalizedODataOperationPath | undefined,
+  intent: ODataPathIntent | undefined,
+): Record<string, unknown> {
+  const routingPlaceholderKeys = placeholderKeys([
+    servicePath,
+    destination,
+    stringValue(call.aliasExpr),
+    stringValue(call.alias),
+  ]);
+  return {
+    serviceAlias: call.alias,
+    serviceAliasExpr: call.aliasExpr,
+    destination,
+    servicePath,
+    operationPath,
+    rawOperationPath: normalized?.wasInvocation
+      ? normalized.rawOperationPath
+      : intent?.rawPath,
+    normalizedOperationPath: normalized?.wasInvocation
+      ? normalized.normalizedOperationPath
+      : undefined,
+    invocationArguments: normalized?.wasInvocation
+      ? normalized.invocationArguments
+      : undefined,
+    invocationArgumentPlaceholderKeys: normalized?.invocationArgumentPlaceholderKeys.length
+      ? normalized.invocationArgumentPlaceholderKeys
+      : undefined,
+    routingPlaceholderKeys: routingPlaceholderKeys.length
+      ? routingPlaceholderKeys
+      : undefined,
+    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' : undefined,
+    helperChain: parseJson(call.helperChainJson),
+    odataPathIntent: intent,
+    queryStringPresent: intent?.hasQueryString || undefined,
+    queryPlaceholderKeys: intent?.placeholderKeys.length
+      ? intent.placeholderKeys
+      : undefined,
+    bindingHasDynamicExpression: Boolean(Number(call.isDynamic ?? 0)) || undefined,
+  };
+}
+
+function candidateEvidence(
+  candidates: ReturnType<typeof boundedCallCandidates>,
+  resolution: LinkedOperationResolution,
+): Record<string, unknown> {
+  return {
+    targetRepo: resolution.target?.repoName,
+    targetServicePath: resolution.target?.servicePath,
+    targetOperationPath: resolution.target?.operationPath,
+    targetOperation: resolution.target?.operationName,
+    candidates: candidates.items,
+    candidateScores: compactCandidateScores(candidates.items),
+    candidateCount: candidates.totalCount,
+    shownCandidateCount: candidates.shownCount,
+    omittedCandidateCount: candidates.omittedCount,
+    candidateScoreCount: candidates.totalCount,
+    shownCandidateScoreCount: candidates.shownCount,
+    omittedCandidateScoreCount: candidates.omittedCount,
+    resolutionStatus: resolution.status,
+    resolutionReasons: resolution.reasons,
+  };
+}
+
+function boundedCallCandidates(
+  candidates: unknown[],
+): BoundedProjection<Record<string, unknown>> {
+  const rows = candidates.flatMap((candidate): Array<Record<string, unknown>> => {
+    const row = objectValue(candidate);
+    return row ? [row] : [];
+  });
+  return projectBounded(rows, compareCallCandidate);
+}
+
+function compareCallCandidate(
+  left: Record<string, unknown>,
+  right: Record<string, unknown>,
+): number {
+  return Number(right.score ?? 0) - Number(left.score ?? 0)
+    || String(left.repoName ?? '').localeCompare(String(right.repoName ?? ''))
+    || String(left.servicePath ?? '').localeCompare(String(right.servicePath ?? ''))
+    || String(left.operationPath ?? '').localeCompare(String(right.operationPath ?? ''))
+    || Number(left.operationId ?? 0) - Number(right.operationId ?? 0);
+}
+
+function compactCandidateScores(
+  candidates: Array<Record<string, unknown>>,
+): Array<Record<string, unknown>> {
+  return candidates.map((candidate) => ({
+    repo: candidate.repoName,
+    servicePath: candidate.servicePath,
+    operationPath: candidate.operationPath,
+    score: candidate.score,
+    reasons: Array.isArray(candidate.reasons)
+      ? candidate.reasons.filter((reason): reason is string =>
+          typeof reason === 'string')
+      : ['operation_path_match'],
+  }));
+}
+
+function placeholderKeys(values: Array<string | undefined>): string[] {
+  const keys = values.flatMap((value) => [...(value ?? '')
+    .matchAll(/\$\{([^}]*)\}/g)]
+    .map((match) => (match[1] ?? '').trim())
+    .filter(Boolean));
+  return [...new Set(keys)].sort();
+}
+
+function parseJson(value: unknown): unknown {
+  if (!value) return undefined;
+  try {
+    const parsed: unknown = JSON.parse(String(value));
+    return parsed;
+  } catch {
+    return undefined;
+  }
+}
+
+function stringValue(value: unknown): string | undefined {
+  return typeof value === 'string' ? value : undefined;
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return Boolean(value && typeof value === 'object' && !Array.isArray(value));
+}