@saptools/service-flow 0.1.52 → 0.1.54

package/src/trace/004-dynamic-candidate-sources.ts

@@ -0,0 +1,155 @@
+import type { Db } from '../db/connection.js';
+import {
+  extractPlaceholders,
+  matchRuntimeTemplate,
+} from '../linker/dynamic-edge-resolver.js';
+import type { OperationTarget } from '../linker/service-resolver.js';
+
+export function dynamicCandidateTargets(
+  db: Db,
+  effectiveOperationPath: string | undefined,
+  originalOperationPath: string | undefined,
+  embedded: unknown,
+  workspaceId: number | undefined,
+  requireCanonical: boolean,
+): OperationTarget[] {
+  const canonical = queryOperationTargets(
+    db, effectiveOperationPath, originalOperationPath, workspaceId,
+  );
+  if (canonical.length > 0 || requireCanonical) return canonical;
+  return targetsFromEvidence(embedded);
+}
+
+function targetsFromEvidence(value: unknown): OperationTarget[] {
+  if (!Array.isArray(value)) return [];
+  return value.flatMap((item): OperationTarget[] => {
+    const row = record(item);
+    const operationId = numberValue(row.operationId);
+    const repoName = stringValue(row.repoName);
+    const servicePath = stringValue(row.servicePath);
+    const operationPath = stringValue(row.operationPath);
+    const operationName = stringValue(row.operationName) ?? operationPath?.replace(/^\//, '');
+    if (operationId === undefined || !repoName || !servicePath || !operationPath || !operationName)
+      return [];
+    return [{
+      operationId,
+      repoId: numberValue(row.repoId),
+      repoName,
+      packageName: stringValue(row.packageName),
+      serviceName: stringValue(row.serviceName) ?? '',
+      qualifiedName: stringValue(row.qualifiedName) ?? '',
+      servicePath,
+      operationPath,
+      operationName,
+      sourceFile: stringValue(row.sourceFile) ?? '',
+      sourceLine: numberValue(row.sourceLine) ?? 0,
+      score: numberValue(row.score) ?? 0,
+      reasons: stringArray(row.reasons),
+    }];
+  });
+}
+
+function queryOperationTargets(
+  db: Db,
+  effectiveOperationPath: string | undefined,
+  originalOperationPath: string | undefined,
+  workspaceId: number | undefined,
+): OperationTarget[] {
+  const operationPath = effectiveOperationPath ?? originalOperationPath;
+  if (!operationPath) return [];
+  if (extractPlaceholders(operationPath).length > 0)
+    return templateOperationTargets(db, operationPath, workspaceId);
+  return exactOperationTargets(db, operationPath, workspaceId);
+}
+
+function exactOperationTargets(
+  db: Db,
+  operationPath: string,
+  workspaceId: number | undefined,
+): OperationTarget[] {
+  const simple = operationPath.replace(/^\//, '').split('.').at(-1) ?? operationPath;
+  const rows = recordRows(db.prepare(
+    `SELECT o.id operationId,r.id repoId,r.name repoName,r.package_name packageName,
+      s.service_name serviceName,s.qualified_name qualifiedName,s.service_path servicePath,
+      o.operation_path operationPath,o.operation_name operationName,o.source_file sourceFile,
+      o.source_line sourceLine FROM cds_operations o
+     JOIN cds_services s ON s.id=o.service_id JOIN repositories r ON r.id=s.repo_id
+     WHERE (? IS NULL OR r.workspace_id=?)
+       AND (o.operation_path IN (?,?) OR o.operation_name=?)
+     ORDER BY r.name,s.service_path,o.operation_name,o.id`,
+  ).all(workspaceId, workspaceId, operationPath, `/${simple}`, simple));
+  return rows.flatMap(targetFromRow);
+}
+
+function templateOperationTargets(
+  db: Db,
+  operationTemplate: string,
+  workspaceId: number | undefined,
+): OperationTarget[] {
+  const rows = recordRows(db.prepare(
+    `SELECT o.id operationId,r.id repoId,r.name repoName,r.package_name packageName,
+      s.service_name serviceName,s.qualified_name qualifiedName,s.service_path servicePath,
+      o.operation_path operationPath,o.operation_name operationName,o.source_file sourceFile,
+      o.source_line sourceLine FROM cds_operations o
+     JOIN cds_services s ON s.id=o.service_id JOIN repositories r ON r.id=s.repo_id
+     WHERE (? IS NULL OR r.workspace_id=?)
+     ORDER BY r.name,s.service_path,o.operation_name,o.id`,
+  ).all(workspaceId, workspaceId));
+  return rows.flatMap((row) => {
+    const operationPath = stringValue(row.operationPath);
+    return matchRuntimeTemplate(operationTemplate, operationPath)
+      ? targetFromRow(row)
+      : [];
+  });
+}
+
+function targetFromRow(row: Record<string, unknown>): OperationTarget[] {
+  const operationId = numberValue(row.operationId);
+  const repoName = stringValue(row.repoName);
+  const servicePath = stringValue(row.servicePath);
+  const operationPath = stringValue(row.operationPath);
+  const operationName = stringValue(row.operationName);
+  if (operationId === undefined || !repoName || !servicePath || !operationPath || !operationName)
+    return [];
+  return [{
+    operationId,
+    repoId: numberValue(row.repoId),
+    repoName,
+    packageName: stringValue(row.packageName),
+    serviceName: stringValue(row.serviceName) ?? '',
+    qualifiedName: stringValue(row.qualifiedName) ?? '',
+    servicePath,
+    operationPath,
+    operationName,
+    sourceFile: stringValue(row.sourceFile) ?? '',
+    sourceLine: numberValue(row.sourceLine) ?? 0,
+    score: 0.2,
+    reasons: ['operation_path_match'],
+  }];
+}
+
+function record(value: unknown): Record<string, unknown> {
+  return isRecord(value) ? value : {};
+}
+
+function recordRows(value: unknown): Array<Record<string, unknown>> {
+  return Array.isArray(value) ? value.filter(isRecord) : [];
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return Boolean(value && typeof value === 'object' && !Array.isArray(value));
+}
+
+function stringValue(value: unknown): string | undefined {
+  return typeof value === 'string' ? value : undefined;
+}
+
+function numberValue(value: unknown): number | undefined {
+  return typeof value === 'number' && Number.isFinite(value) ? value : undefined;
+}
+
+function stringArray(value: unknown): string[] {
+  return Array.isArray(value)
+    ? value.filter((item): item is string => typeof item === 'string')
+    : [];
+}

package/src/trace/005-implementation-selection.ts

@@ -0,0 +1,187 @@
+import type { Db } from '../db/connection.js';
+import { canonicalImplementationEvidence } from '../linker/000-implementation-candidates.js';
+import type { ImplementationHint } from '../types.js';
+import { projectBounded } from '../utils/000-bounded-projection.js';
+import {
+  selectImplementation,
+  type ImplementationSelection,
+} from './implementation-hints.js';
+
+export interface ImplementationGraphEdge {
+  status?: string;
+  evidence_json?: string;
+}
+
+export interface ImplementationSelectionOptions {
+  implementationRepo?: string;
+  implementationHints?: ImplementationHint[];
+}
+
+export function hintedImplementationSelection(
+  db: Db,
+  edge: ImplementationGraphEdge | undefined,
+  operationId: string,
+  options: ImplementationSelectionOptions,
+): ImplementationSelection {
+  if (!edge || edge.status !== 'ambiguous')
+    return { blocksAutomatic: false, evidence: { status: 'not_applicable' } };
+  return selectImplementation(
+    parsedEvidence(edge.evidence_json), options.implementationHints,
+    options.implementationRepo, canonicalImplementationEvidence(db, operationId),
+  );
+}
+
+export function contextualImplementationSelection(
+  db: Db,
+  edge: ImplementationGraphEdge | undefined,
+  operationId: string,
+  callerRepoId: number | undefined,
+  remoteEvidence: Record<string, unknown>,
+  options: ImplementationSelectionOptions,
+): ImplementationSelection {
+  const hinted = hintedImplementationSelection(db, edge, operationId, options);
+  if (hinted.methodId || hinted.blocksAutomatic || !edge
+    || edge.status !== 'ambiguous' || callerRepoId === undefined) return hinted;
+  const candidates = implementationCandidates(
+    canonicalImplementationEvidence(db, operationId) ?? parsedEvidence(edge.evidence_json),
+  );
+  const scores = candidates.filter((candidate) => candidate.accepted)
+    .map((candidate) => contextualScore(candidate, callerRepoId, remoteEvidence))
+    .sort(compareScore);
+  if (scores.length === 0)
+    return { blocksAutomatic: false, evidence: { status: 'not_applicable', candidateScores: [] } };
+  const [first, second] = scores;
+  if (first?.methodId !== undefined && first.score > 0
+    && (!second || first.score > second.score))
+    return selectedContext(first, scores);
+  return tiedContext(hinted, scores);
+}
+
+function selectedContext(
+  first: ContextScore,
+  scores: ContextScore[],
+): ImplementationSelection {
+  const projection = projectBounded(scores, compareScore);
+  return {
+    methodId: String(first.methodId),
+    blocksAutomatic: false,
+    evidence: {
+      status: 'selected',
+      selectedMethodId: first.methodId,
+      candidateScores: projection.items,
+      candidateScoreCount: projection.totalCount,
+      shownCandidateScoreCount: projection.shownCount,
+      omittedCandidateScoreCount: projection.omittedCount,
+    },
+  };
+}
+
+function tiedContext(
+  hinted: ImplementationSelection,
+  scores: ContextScore[],
+): ImplementationSelection {
+  if (hinted.evidence.reason === 'no_scoped_hint_matched_edge') return hinted;
+  const projection = projectBounded(scores, compareScore);
+  return {
+    blocksAutomatic: false,
+    evidence: {
+      status: 'tied',
+      tieReason: scores.length > 1
+        ? 'duplicate_helper_implementation_candidates'
+        : 'no_unique_materially_stronger_candidate',
+      candidateScores: projection.items,
+      candidateScoreCount: projection.totalCount,
+      shownCandidateScoreCount: projection.shownCount,
+      omittedCandidateScoreCount: projection.omittedCount,
+    },
+  };
+}
+
+interface ImplementationCandidate {
+  accepted: boolean;
+  methodId?: number;
+  score: number;
+  handlerPackage: Record<string, unknown>;
+  applicationPackage: Record<string, unknown>;
+}
+
+interface ContextScore {
+  methodId?: number;
+  score: number;
+  reasons: string[];
+  handlerPackage: Record<string, unknown>;
+  applicationPackage: Record<string, unknown>;
+}
+
+function implementationCandidates(evidence: Record<string, unknown>): ImplementationCandidate[] {
+  const rows = Array.isArray(evidence.candidates) ? evidence.candidates : [];
+  return rows.flatMap((value) => {
+    const row = record(value);
+    return Object.keys(row).length === 0 ? [] : [{
+      accepted: row.accepted === true,
+      methodId: numberValue(row.methodId),
+      score: numberValue(row.score) ?? 0,
+      handlerPackage: record(row.handlerPackage),
+      applicationPackage: record(row.applicationPackage),
+    }];
+  });
+}
+
+function contextualScore(
+  candidate: ImplementationCandidate,
+  callerRepoId: number,
+  remoteEvidence: Record<string, unknown>,
+): ContextScore {
+  const reasons: string[] = [];
+  let score = candidate.score;
+  if (numberValue(candidate.handlerPackage.id) === callerRepoId) {
+    score += 10;
+    reasons.push('handler_package_matches_caller_repository');
+  }
+  if (numberValue(candidate.applicationPackage.id) === callerRepoId) {
+    score += 10;
+    reasons.push('registration_package_matches_caller_repository');
+  }
+  if (hasRemoteContext(remoteEvidence)) {
+    score += 1;
+    reasons.push('remote_call_context_available');
+  }
+  return {
+    methodId: candidate.methodId,
+    score,
+    reasons,
+    handlerPackage: candidate.handlerPackage,
+    applicationPackage: candidate.applicationPackage,
+  };
+}
+
+function hasRemoteContext(evidence: Record<string, unknown>): boolean {
+  return typeof evidence.effectiveServicePath === 'string'
+    || typeof evidence.effectiveDestination === 'string'
+    || typeof evidence.effectiveAlias === 'string';
+}
+
+function compareScore(left: ContextScore, right: ContextScore): number {
+  return right.score - left.score
+    || Number(left.methodId ?? 0) - Number(right.methodId ?? 0);
+}
+
+function parsedEvidence(value: string | undefined): Record<string, unknown> {
+  try {
+    return record(JSON.parse(String(value ?? '{}')) as unknown);
+  } catch {
+    return {};
+  }
+}
+
+function record(value: unknown): Record<string, unknown> {
+  return isRecord(value) ? value : {};
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return Boolean(value && typeof value === 'object' && !Array.isArray(value));
+}
+
+function numberValue(value: unknown): number | undefined {
+  return typeof value === 'number' && Number.isFinite(value) ? value : undefined;
+}

package/src/trace/006-contextual-projection.ts

@@ -0,0 +1,30 @@
+import { projectBounded } from '../utils/000-bounded-projection.js';
+
+export function boundedContextCandidates(values: unknown[]): {
+  candidates: Array<Record<string, unknown>>;
+  candidateCount: number;
+  shownCandidateCount: number;
+  omittedCandidateCount: number;
+} {
+  const candidates = values.flatMap((value): Array<Record<string, unknown>> => {
+    return isRecord(value) ? [value] : [];
+  });
+  const projection = projectBounded(candidates, (left, right) =>
+    Number(right.score ?? 0) - Number(left.score ?? 0)
+    || String(left.repoName ?? '').localeCompare(String(right.repoName ?? ''))
+    || String(left.servicePath ?? '').localeCompare(String(right.servicePath ?? ''))
+    || String(left.sourceFile ?? '').localeCompare(String(right.sourceFile ?? ''))
+    || Number(left.sourceLine ?? 0) - Number(right.sourceLine ?? 0)
+    || Number(left.bindingId ?? left.operationId ?? 0)
+      - Number(right.bindingId ?? right.operationId ?? 0));
+  return {
+    candidates: projection.items,
+    candidateCount: projection.totalCount,
+    shownCandidateCount: projection.shownCount,
+    omittedCandidateCount: projection.omittedCount,
+  };
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return Boolean(value && typeof value === 'object' && !Array.isArray(value));
+}

package/src/trace/007-implementation-start-diagnostic.ts

@@ -0,0 +1,61 @@
+interface ImplementationStartEdge {
+  id: number;
+  status?: string;
+}
+
+export function implementationStartDiagnostic(
+  edge: ImplementationStartEdge,
+  evidence: Record<string, unknown>,
+): Record<string, unknown> {
+  return {
+    severity: 'warning',
+    code: edge.status === 'ambiguous'
+      ? 'trace_start_ambiguous'
+      : 'trace_start_implementation_unresolved',
+    message: `Indexed operation matched but implementation edge is ${String(
+      edge.status ?? 'unresolved',
+    )}`,
+    resolutionStage: 'implementation',
+    resolutionStatus: edge.status === 'ambiguous'
+      ? 'ambiguous_implementation'
+      : 'rejected_implementation',
+    implementationEdgeId: edge.id,
+    implementationStatus: edge.status,
+    implementationAmbiguityReasons: evidence.ambiguityReasons,
+    implementationRejectionReasons: implementationRejectionReasons(evidence),
+    implementationHintSuggestions: evidence.implementationHintSuggestions,
+    implementationHintSuggestionCount: evidence.implementationHintSuggestionCount,
+    shownImplementationHintSuggestionCount:
+      evidence.shownImplementationHintSuggestionCount,
+    omittedImplementationHintSuggestionCount:
+      evidence.omittedImplementationHintSuggestionCount,
+    candidates: evidence.candidates,
+    candidateCount: evidence.candidateCount,
+    shownCandidateCount: evidence.shownCandidateCount,
+    omittedCandidateCount: evidence.omittedCandidateCount,
+  };
+}
+
+function implementationRejectionReasons(
+  evidence: Record<string, unknown>,
+): string[] {
+  const candidates = recordArray(evidence.candidates);
+  const reasons = candidates.flatMap((candidate) => stringArray(candidate.rejectedReasons));
+  return [...new Set(reasons)].sort();
+}
+
+function recordArray(value: unknown): Array<Record<string, unknown>> {
+  return Array.isArray(value)
+    ? value.filter(isRecord)
+    : [];
+}
+
+function stringArray(value: unknown): string[] {
+  return Array.isArray(value)
+    ? value.filter((item): item is string => typeof item === 'string')
+    : [];
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return Boolean(value && typeof value === 'object' && !Array.isArray(value));
+}