@saptools/service-flow 0.1.67 → 0.1.69

package/src/db/006-relative-symbol-resolution.ts

@@ -0,0 +1,464 @@
+import { posix } from 'node:path';
+import type { SymbolCallFact } from '../types.js';
+import { packageModuleRequest } from
+  '../parsers/002-symbol-import-bindings.js';
+import type { Db } from './connection.js';
+
+export interface RelativeSymbolCallResolution {
+  id: number | null;
+  status: 'resolved' | 'ambiguous' | 'unresolved';
+  reason: string | null;
+  strategy: string;
+  candidateCount: number;
+  eligibleCandidateCount: number;
+  candidateSetComplete: boolean;
+  resolvedModulePath?: string;
+}
+
+interface TargetRow {
+  id: number;
+  kind: string;
+  sourceFile: string;
+  exported: boolean;
+  evidenceJson: string | null;
+}
+
+interface RelativeModuleScope {
+  paths: Set<string>;
+  ambiguous: boolean;
+}
+
+interface MappingTarget {
+  specifier?: string;
+}
+
+interface MappedExecutableRows {
+  rows: TargetRow[];
+  ambiguous: boolean;
+  packageTargetUnsupported: boolean;
+}
+
+const stripExtension = (value: string): string =>
+  value.replace(/\.(?:ts|tsx|js|jsx|cds)$/, '');
+
+function record(value: unknown): Record<string, unknown> | undefined {
+  return value && typeof value === 'object' && !Array.isArray(value)
+    ? value as Record<string, unknown>
+    : undefined;
+}
+
+function parsedRecord(value: string | null): Record<string, unknown> | undefined {
+  if (value === null) return undefined;
+  try {
+    return record(JSON.parse(value) as unknown);
+  } catch {
+    return undefined;
+  }
+}
+
+function targetRows(rows: Array<Record<string, unknown>>): TargetRow[] {
+  return rows.flatMap((row) =>
+    typeof row.id === 'number' && typeof row.kind === 'string'
+      && typeof row.sourceFile === 'string'
+      && typeof row.exported === 'number'
+      ? [{
+          id: row.id,
+          kind: row.kind,
+          sourceFile: row.sourceFile,
+          exported: row.exported === 1,
+          evidenceJson: typeof row.evidenceJson === 'string'
+            ? row.evidenceJson
+            : null,
+        }]
+      : []);
+}
+
+function relativeTargets(sourceFile: string, specifier: string): Set<string> {
+  const joined = stripExtension(posix.normalize(
+    posix.join(posix.dirname(sourceFile), specifier),
+  ));
+  return new Set([joined, `${joined}/index`]);
+}
+
+function relativeModuleScope(
+  db: Db,
+  repoId: number,
+  sourceFile: string,
+  specifier: string,
+): RelativeModuleScope {
+  const requested = relativeTargets(sourceFile, specifier);
+  const rows = db.prepare(`SELECT relative_path relativePath FROM files
+    WHERE repo_id=? ORDER BY relative_path COLLATE BINARY`).all(repoId);
+  const matched = rows.flatMap((row) =>
+    typeof row.relativePath === 'string'
+      && requested.has(stripExtension(row.relativePath))
+      ? [stripExtension(row.relativePath)] : []);
+  return {
+    paths: new Set(matched),
+    ambiguous: matched.length > 1,
+  };
+}
+
+function scopedRows(
+  rows: readonly TargetRow[],
+  paths: ReadonlySet<string>,
+): TargetRow[] {
+  return rows.filter((row) => paths.has(stripExtension(row.sourceFile)));
+}
+
+function bodyEligible(row: TargetRow): boolean {
+  const evidence = parsedRecord(row.evidenceJson);
+  const direct = record(evidence?.executableBodyEligibility);
+  const surface = record(evidence?.packagePublicSurface);
+  const packageBody = record(surface?.bodyEligibility);
+  const body = direct ?? packageBody;
+  return body?.eligible === true && body.reason === 'body_present';
+}
+
+function relativeBinding(
+  call: SymbolCallFact,
+): Record<string, unknown> | undefined {
+  const binding = record(call.evidence.importBinding);
+  return binding?.moduleKind === 'relative'
+    && binding.rawModuleSpecifier === call.importSource
+    ? binding
+    : undefined;
+}
+
+function importedHandlerMember(
+  call: SymbolCallFact,
+  binding = relativeBinding(call),
+): boolean {
+  return call.callRole === 'event_subscribe_handler'
+    && binding?.referenceShape === 'static_member'
+    && typeof binding.importedName === 'string'
+    && binding.requestedPublicName === call.calleeLocalName;
+}
+
+function handlerMemberPubliclyCarried(
+  row: TargetRow,
+  binding: Record<string, unknown>,
+): boolean {
+  if (row.exported) return true;
+  const evidence = parsedRecord(row.evidenceJson);
+  if (evidence?.source !== 'exported_class_instance_member') return false;
+  const exportKind = evidence.exportedClassExportKind;
+  if (exportKind !== 'default' && exportKind !== 'named') return false;
+  return binding.bindingKind === 'esm_default'
+    ? exportKind === 'default'
+    : evidence.exportedClass === binding.importedName;
+}
+
+function requiresPublicClassMember(
+  relation: unknown,
+  call: SymbolCallFact,
+  binding: Record<string, unknown>,
+): boolean {
+  return relation === 'class_instance_method'
+    || importedHandlerMember(call, binding);
+}
+
+function resolved(
+  row: TargetRow,
+  strategy: string,
+  candidateCount: number,
+  resolvedModulePath: string,
+): RelativeSymbolCallResolution {
+  return {
+    id: row.id,
+    status: 'resolved',
+    reason: null,
+    strategy,
+    candidateCount,
+    eligibleCandidateCount: 1,
+    candidateSetComplete: true,
+    resolvedModulePath,
+  };
+}
+
+function unresolved(
+  strategy: string,
+  reason: string,
+  candidateCount: number,
+  eligibleCandidateCount = 0,
+  candidateSetComplete = true,
+): RelativeSymbolCallResolution {
+  return {
+    id: null,
+    status: 'unresolved',
+    reason,
+    strategy,
+    candidateCount,
+    eligibleCandidateCount,
+    candidateSetComplete,
+  };
+}
+
+function ambiguous(
+  strategy: string,
+  reason: string,
+  candidateCount: number,
+  eligibleCandidateCount: number,
+): RelativeSymbolCallResolution {
+  return {
+    id: null,
+    status: 'ambiguous',
+    reason,
+    strategy,
+    candidateCount,
+    eligibleCandidateCount,
+    candidateSetComplete: true,
+  };
+}
+
+function uniqueRows(rows: readonly TargetRow[]): TargetRow[] {
+  return [...new Map(rows.map((row) => [row.id, row])).values()]
+    .sort((left, right) => left.id - right.id);
+}
+
+function executableResolution(
+  rows: readonly TargetRow[],
+  scoped: readonly TargetRow[],
+  modulePath: string | undefined,
+  strategy: string,
+  ambiguousReason: string,
+): RelativeSymbolCallResolution {
+  const eligible = uniqueRows(scoped.filter(bodyEligible));
+  if (eligible.length === 1 && eligible[0] && modulePath)
+    return resolved(eligible[0], strategy, rows.length, modulePath);
+  if (eligible.length > 1) return ambiguous(
+    strategy, ambiguousReason, rows.length, eligible.length,
+  );
+  return unresolved(
+    strategy,
+    scoped.length > 0
+      ? 'relative_import_requested_module_has_no_executable_body'
+      : 'relative_import_requested_module_has_no_target',
+    rows.length,
+  );
+}
+
+function qualifiedRows(
+  db: Db,
+  repoId: number,
+  call: SymbolCallFact,
+): TargetRow[] {
+  return targetRows(db.prepare(`SELECT id,kind,source_file sourceFile,
+    exported,evidence_json evidenceJson FROM symbols
+    WHERE repo_id=? AND source_file<>? AND qualified_name=?
+    ORDER BY id`).all(repoId, call.sourceFile, call.calleeLocalName));
+}
+
+function exportedRows(
+  db: Db,
+  repoId: number,
+  call: SymbolCallFact,
+): TargetRow[] {
+  return targetRows(db.prepare(`SELECT id,kind,source_file sourceFile,
+    exported,evidence_json evidenceJson FROM symbols
+    WHERE repo_id=? AND source_file<>? AND exported=1
+      AND (exported_name=? OR name=? OR qualified_name=?)
+    ORDER BY id`).all(
+    repoId, call.sourceFile,
+    call.calleeLocalName, call.calleeLocalName, call.calleeLocalName,
+  ));
+}
+
+function proxyRows(
+  db: Db,
+  repoId: number,
+  call: SymbolCallFact,
+): TargetRow[] {
+  return targetRows(db.prepare(`SELECT id,kind,source_file sourceFile,
+    exported,evidence_json evidenceJson FROM symbols
+    WHERE repo_id=? AND source_file<>?
+      AND (exported_name=? OR name=? OR qualified_name=?)
+    ORDER BY id`).all(
+    repoId, call.sourceFile,
+    call.calleeLocalName, call.calleeLocalName, call.calleeLocalName,
+  ));
+}
+
+function mappingTarget(row: TargetRow): MappingTarget | undefined {
+  const evidence = parsedRecord(row.evidenceJson);
+  if (row.kind !== 'object_alias'
+    || evidence?.source !== 'exported_object_shorthand') return undefined;
+  const specifier = evidence.targetImportSource;
+  return typeof specifier === 'string' ? { specifier } : {};
+}
+
+function mappingTargetScope(
+  db: Db,
+  repoId: number,
+  row: TargetRow,
+): RelativeModuleScope | undefined {
+  const target = mappingTarget(row);
+  if (!target) return undefined;
+  if (!target.specifier)
+    return {
+      paths: new Set([stripExtension(row.sourceFile)]), ambiguous: false,
+    };
+  if (packageModuleRequest(target.specifier)) return undefined;
+  return relativeModuleScope(db, repoId, row.sourceFile, target.specifier);
+}
+
+function mappedExecutableRows(
+  db: Db,
+  repoId: number,
+  rows: readonly TargetRow[],
+  aliases: readonly TargetRow[],
+): MappedExecutableRows {
+  const packageTargetUnsupported = aliases.some((alias) => {
+    const target = mappingTarget(alias);
+    return Boolean(target?.specifier && packageModuleRequest(target.specifier));
+  });
+  const scopes = aliases.flatMap((alias) => {
+    const scope = mappingTargetScope(db, repoId, alias);
+    return scope ? [scope] : [];
+  });
+  if (scopes.some((scope) => scope.ambiguous))
+    return { rows: [], ambiguous: true, packageTargetUnsupported };
+  const mapped = scopes.flatMap((scope) => {
+    return rows.filter((row) =>
+      row.kind !== 'object_alias' && bodyEligible(row)
+      && scope.paths.has(stripExtension(row.sourceFile)));
+  });
+  return {
+    rows: uniqueRows(mapped), ambiguous: false, packageTargetUnsupported,
+  };
+}
+
+function proxyResolution(
+  db: Db,
+  repoId: number,
+  rows: readonly TargetRow[],
+  scope: RelativeModuleScope,
+): RelativeSymbolCallResolution {
+  const scoped = scopedRows(rows, scope.paths);
+  const aliases = scoped.filter((row) => mappingTarget(row));
+  const mapped = mappedExecutableRows(db, repoId, rows, aliases);
+  if (mapped.ambiguous) return unresolved(
+    'proxy_member_exported_object_map',
+    'relative_import_module_resolution_ambiguous',
+    rows.length, 0, false,
+  );
+  if (mapped.packageTargetUnsupported) return unresolved(
+    'proxy_member_exported_object_map',
+    'relative_import_proxy_alias_targets_package_unsupported',
+    rows.length,
+  );
+  const direct = scoped.filter((row) =>
+    row.kind !== 'object_alias' && row.exported && bodyEligible(row));
+  const eligible = uniqueRows([
+    ...direct,
+    ...mapped.rows,
+  ]);
+  const modulePath = [...scope.paths][0];
+  const strategy = aliases.length > 0
+    ? 'proxy_member_exported_object_map'
+    : 'relative_import_path_disambiguated';
+  if (eligible.length === 1 && eligible[0] && modulePath)
+    return resolved(eligible[0], strategy, rows.length, modulePath);
+  if (eligible.length > 1) return ambiguous(
+    'proxy_member_no_global_name_fallback',
+    'multiple_proxy_targets_in_requested_module',
+    rows.length,
+    eligible.length,
+  );
+  return unresolved(
+    'proxy_member_no_global_name_fallback',
+    scoped.length > 0
+      ? 'relative_import_requested_module_has_no_executable_body'
+      : 'relative_import_requested_module_has_no_target',
+    rows.length,
+  );
+}
+
+function resolutionRows(
+  db: Db,
+  repoId: number,
+  call: SymbolCallFact,
+  relation: unknown,
+): TargetRow[] {
+  if (relation === 'class_instance_method' || isAccessorCall(relation, call)
+    || importedHandlerMember(call))
+    return qualifiedRows(
+    db, repoId, call,
+  );
+  if (relation === 'relative_import_proxy_member') return proxyRows(
+    db, repoId, call,
+  );
+  return exportedRows(db, repoId, call);
+}
+
+function isAccessorCall(relation: unknown, call: SymbolCallFact): boolean {
+  return relation === 'relative_import'
+    && call.calleeExpression.includes('().')
+    && String(call.calleeLocalName).includes('.');
+}
+
+function strategyFor(
+  relation: unknown,
+  call: SymbolCallFact,
+  candidateCount: number,
+): string {
+  if (relation === 'class_instance_method')
+    return 'relative_import_class_instance_method';
+  if (relation === 'relative_import_namespace_member')
+    return 'relative_import_namespace_member';
+  if (isAccessorCall(relation, call))
+    return 'relative_import_static_accessor_instance_method';
+  return candidateCount > 1
+    ? 'relative_import_path_disambiguated'
+    : 'relative_import_exported_exact';
+}
+
+function ambiguousReasonFor(
+  relation: unknown,
+  call: SymbolCallFact,
+): string {
+  if (relation === 'class_instance_method')
+    return 'multiple_relative_class_targets_in_requested_module';
+  if (relation === 'relative_import_namespace_member')
+    return 'multiple_namespace_targets_in_requested_module';
+  return isAccessorCall(relation, call)
+    ? 'multiple_accessor_targets_in_requested_module'
+    : 'multiple_exported_targets_in_requested_module';
+}
+
+export function resolveRelativeSymbolCall(
+  db: Db,
+  repoId: number,
+  call: SymbolCallFact,
+  relation: unknown,
+): RelativeSymbolCallResolution | undefined {
+  if (!call.importSource?.startsWith('.')) return undefined;
+  const rows = resolutionRows(db, repoId, call, relation);
+  const binding = relativeBinding(call);
+  const strategy = strategyFor(relation, call, rows.length);
+  if (!binding) return unresolved(
+    strategy, 'relative_import_provenance_missing', rows.length,
+  );
+  if (binding.typeOnly === true) return unresolved(
+    strategy, 'relative_import_type_only', rows.length,
+  );
+  const moduleScope = relativeModuleScope(
+    db, repoId, call.sourceFile, call.importSource,
+  );
+  if (moduleScope.ambiguous) return unresolved(
+    strategy, 'relative_import_module_resolution_ambiguous',
+    rows.length, 0, false,
+  );
+  if (relation === 'relative_import_proxy_member')
+    return proxyResolution(db, repoId, rows, moduleScope);
+  const moduleRows = scopedRows(rows, moduleScope.paths);
+  const scoped = binding && requiresPublicClassMember(
+    relation, call, binding,
+  )
+    ? moduleRows.filter((row) => handlerMemberPubliclyCarried(row, binding))
+    : moduleRows;
+  return executableResolution(
+    rows, scoped, [...moduleScope.paths][0],
+    strategy, ambiguousReasonFor(relation, call),
+  );
+}