@saptools/service-flow 0.1.70 → 0.1.72

package/src/linker/package-event-constant-resolver.ts

@@ -0,0 +1,298 @@
+import type { Db } from '../db/connection.js';
+import {
+  parsePackageImportReference,
+  parsePackagePublicSurfaceFact,
+} from '../parsers/package-fact-contract.js';
+import type {
+  PackagePublicSurfaceFact,
+} from '../parsers/package-public-surface.js';
+import type {
+  SymbolImportReference,
+} from '../parsers/symbol-import-bindings.js';
+
+export interface PackageEventConstantLinkSummary {
+  resolved: number;
+  ambiguous: number;
+  unresolved: number;
+}
+
+interface EventConstantCall {
+  id: number;
+  binding: SymbolImportReference;
+  evidence: Record<string, unknown>;
+  unresolvedReason?: string | null;
+}
+
+interface PackageRepository {
+  id: number;
+  surface: PackagePublicSurfaceFact;
+}
+
+export interface PackageEventConstantResolution {
+  status: 'resolved' | 'ambiguous' | 'unresolved';
+  reason?: string;
+  value?: string;
+  sourceFile?: string;
+  sourceLine?: number;
+  targetRepoId?: number;
+  modulePath?: string;
+  candidateCount: number;
+  eligibleCandidateCount: number;
+  complete: boolean;
+}
+
+function record(value: unknown): Record<string, unknown> | undefined {
+  return value && typeof value === 'object' && !Array.isArray(value)
+    ? value as Record<string, unknown> : undefined;
+}
+
+function jsonRecord(value: unknown): Record<string, unknown> | undefined {
+  if (typeof value !== 'string') return undefined;
+  try {
+    return record(JSON.parse(value) as unknown);
+  } catch {
+    return undefined;
+  }
+}
+
+function callRows(db: Db, workspaceId: number): EventConstantCall[] {
+  const rows = db.prepare(`SELECT c.id,c.evidence_json evidenceJson,
+    c.unresolved_reason unresolvedReason
+    FROM outbound_calls c JOIN repositories r ON r.id=c.repo_id
+    WHERE r.workspace_id=?
+      AND c.call_type IN ('async_emit','async_subscribe')
+      AND json_extract(c.evidence_json,
+        '$.eventNameConstantImportBinding.moduleKind')='package'
+    ORDER BY c.id`).all(workspaceId);
+  return rows.flatMap((row) => {
+    const evidence = jsonRecord(row.evidenceJson);
+    const binding = parsePackageImportReference(
+      evidence?.eventNameConstantImportBinding,
+    );
+    return typeof row.id === 'number' && evidence && binding ? [{
+      id: row.id, evidence, binding,
+      unresolvedReason: typeof row.unresolvedReason === 'string'
+        ? row.unresolvedReason : null,
+    }] : [];
+  });
+}
+
+function parseSurface(
+  value: unknown,
+  packageName: string,
+): PackagePublicSurfaceFact | undefined {
+  if (typeof value !== 'string') return undefined;
+  try {
+    return parsePackagePublicSurfaceFact(
+      JSON.parse(value) as unknown, packageName,
+    );
+  } catch {
+    return undefined;
+  }
+}
+
+function repositories(
+  db: Db,
+  workspaceId: number,
+  packageName: string,
+): PackageRepository[] {
+  return db.prepare(`SELECT id,package_public_surface_json surfaceJson
+    FROM repositories WHERE workspace_id=? AND package_name=?
+    ORDER BY id`).all(workspaceId, packageName).flatMap((row) => {
+    const surface = parseSurface(row.surfaceJson, packageName);
+    return typeof row.id === 'number' && surface
+      ? [{ id: row.id, surface }] : [];
+  });
+}
+
+function failure(
+  reason: string,
+  fields: Partial<PackageEventConstantResolution> = {},
+): PackageEventConstantResolution {
+  return {
+    status: reason === 'event_name_constant_container_ambiguous'
+      ? 'ambiguous' : 'unresolved',
+    reason,
+    candidateCount: 0,
+    eligibleCandidateCount: 0,
+    complete: true,
+    ...fields,
+  };
+}
+
+function entryModule(
+  repository: PackageRepository,
+  binding: SymbolImportReference,
+): string | PackageEventConstantResolution {
+  const surface = repository.surface;
+  if (surface.status !== 'complete' || surface.omitted > 0) return failure(
+    'event_name_constant_container_ambiguous', { complete: false },
+  );
+  const matches = surface.entries.filter((entry) =>
+    entry.entry === binding.requestedModuleSubpath);
+  return matches.length === 1 && matches[0]
+    ? matches[0].modulePath
+    : failure('event_name_constant_container_ambiguous', {
+        complete: matches.length === 0 && surface.omitted === 0,
+      });
+}
+
+function moduleFile(sourceFile: string): string {
+  return sourceFile.replace(/\.(?:d\.)?(?:ts|js)$/, '');
+}
+
+function constantRows(
+  db: Db,
+  repoId: number,
+  modulePath: string,
+  publicName: string,
+): Array<Record<string, unknown>> {
+  return db.prepare(`SELECT id,source_file sourceFile,
+    source_line sourceLine,value,exported,stable,
+    resolution_status resolutionStatus,unresolved_reason unresolvedReason
+    FROM generated_constants
+    WHERE repo_id=? AND name=?
+    ORDER BY source_file COLLATE BINARY,declaration_start_offset,id`).all(
+    repoId, publicName,
+  ).filter((row) =>
+    typeof row.sourceFile === 'string'
+    && moduleFile(row.sourceFile) === modulePath);
+}
+
+function resolveRows(
+  rows: Array<Record<string, unknown>>,
+  repoId: number,
+  modulePath: string,
+): PackageEventConstantResolution {
+  const fields = {
+    targetRepoId: repoId,
+    modulePath,
+    candidateCount: rows.length,
+    complete: true,
+  };
+  if (rows.length !== 1 || !rows[0]) return failure(
+    'event_name_constant_container_ambiguous',
+    fields,
+  );
+  const row = rows[0];
+  if (Number(row.exported) !== 1) return failure(
+    'event_name_constant_container_not_exported', fields,
+  );
+  if (Number(row.stable) !== 1) return failure(
+    'event_name_constant_container_mutable', fields,
+  );
+  if (row.resolutionStatus !== 'resolved'
+    || typeof row.value !== 'string') return failure(
+    String(row.unresolvedReason) === 'event_name_constant_container_mutable'
+      ? 'event_name_constant_container_mutable'
+      : 'event_name_constant_member_not_string',
+    fields,
+  );
+  return {
+    ...fields,
+    status: 'resolved',
+    value: row.value,
+    sourceFile: String(row.sourceFile),
+    sourceLine: Number(row.sourceLine),
+    eligibleCandidateCount: 1,
+  };
+}
+
+function resolveCall(
+  db: Db,
+  workspaceId: number,
+  call: EventConstantCall,
+): PackageEventConstantResolution {
+  const packageName = call.binding.requestedPackageName ?? '';
+  const matches = repositories(db, workspaceId, packageName);
+  if (matches.length !== 1 || !matches[0]) return failure(
+    'event_name_constant_container_ambiguous',
+    { candidateCount: matches.length, complete: matches.length === 0 },
+  );
+  const module = entryModule(matches[0], call.binding);
+  if (typeof module !== 'string') return {
+    ...module, targetRepoId: matches[0].id,
+  };
+  return resolveRows(
+    constantRows(
+      db, matches[0].id, module, call.binding.requestedPublicName,
+    ),
+    matches[0].id,
+    module,
+  );
+}
+
+export function expectedPackageEventConstantResolution(
+  db: Db,
+  workspaceId: number,
+  binding: SymbolImportReference,
+): PackageEventConstantResolution {
+  return resolveCall(db, workspaceId, {
+    id: 0,
+    binding,
+    evidence: {},
+  });
+}
+
+function receiverReason(call: EventConstantCall): string | null {
+  return call.evidence.receiverClassification === 'unproven'
+    ? call.unresolvedReason ?? 'event_receiver_unproven_binding' : null;
+}
+
+function resolutionEvidence(
+  call: EventConstantCall,
+  resolution: PackageEventConstantResolution,
+): string {
+  const evidence = { ...call.evidence };
+  delete evidence.eventNameUnresolvedReason;
+  delete evidence.eventNameStatus;
+  delete evidence.eventNameSourceKind;
+  delete evidence.eventNamePlaceholderKeys;
+  if (resolution.status !== 'resolved')
+    evidence.eventNameUnresolvedReason = resolution.reason;
+  return JSON.stringify({
+    ...evidence,
+    ...(resolution.status === 'resolved' ? {
+      eventNameConstant: {
+        sourceKind: 'package_static_string',
+        sourceFile: resolution.sourceFile,
+        sourceLine: resolution.sourceLine,
+      },
+    } : {}),
+    eventNamePackageConstantResolution: {
+      status: resolution.status,
+      reason: resolution.reason,
+      candidateCount: resolution.candidateCount,
+      eligibleCandidateCount: resolution.eligibleCandidateCount,
+      selectedCandidateCount: resolution.status === 'resolved' ? 1 : 0,
+      candidateSetComplete: resolution.complete,
+      requestedPackageName: call.binding.requestedPackageName,
+      requestedModuleSubpath: call.binding.requestedModuleSubpath,
+      requestedPublicName: call.binding.requestedPublicName,
+      resolvedModulePath: resolution.modulePath,
+      targetRepositoryId: resolution.targetRepoId,
+    },
+  });
+}
+
+export function linkPackageEventConstants(
+  db: Db,
+  workspaceId: number,
+): PackageEventConstantLinkSummary {
+  const summary = { resolved: 0, ambiguous: 0, unresolved: 0 };
+  const update = db.prepare(`UPDATE outbound_calls SET event_name_expr=?,
+    unresolved_reason=?,evidence_json=? WHERE id=?`);
+  for (const call of callRows(db, workspaceId)) {
+    const resolution = resolveCall(db, workspaceId, call);
+    const reason = receiverReason(call) ?? resolution.reason ?? null;
+    const sourceExpression = call.evidence.eventNameConstantSourceExpression;
+    update.run(
+      resolution.value ?? String(sourceExpression ?? ''),
+      reason,
+      resolutionEvidence(call, resolution),
+      call.id,
+    );
+    summary[resolution.status] += 1;
+  }
+  return summary;
+}

package/src/output/table-output.ts

@@ -23,7 +23,7 @@ function location(evidence: Record<string, unknown>): string {
 export function renderTraceTable(result: TraceResult): string {
   const lines = ['Step  Type                 From                                To                                  Evidence'];
   for (const e of result.edges) {
-    lines.push(`${String(e.step).padEnd(5)} ${e.type.padEnd(20)} ${e.from.slice(0, 34).padEnd(35)} ${e.to.slice(0, 35).padEnd(36)} ${location(e.evidence)}`);
+    lines.push(`${String(e.step).padEnd(5)} ${e.type.padEnd(20)} ${e.from.slice(0, 34).padEnd(35)} ${e.to.slice(0, 35).padEnd(36)} ${evidenceSummary(e.evidence)}`);
     if (e.unresolvedReason)
       lines.push(...hintLines(e.evidence).map((hint) => `      ${hint}`));
   }
@@ -31,6 +31,18 @@ export function renderTraceTable(result: TraceResult): string {
   return `${lines.join('\n')}\n`;
 }
 
+function evidenceSummary(evidence: Record<string, unknown>): string {
+  const labels = [
+    typeof evidence.dispatchScope === 'string'
+      ? `scope=${evidence.dispatchScope}` : undefined,
+    typeof evidence.dispatchCertainty === 'string'
+      ? `certainty=${evidence.dispatchCertainty}` : undefined,
+  ].filter((value): value is string => Boolean(value));
+  return labels.length > 0
+    ? `${location(evidence)} [${labels.join(',')}]`
+    : location(evidence);
+}
+
 function diagnosticLines(diagnostic: Record<string, unknown>): string[] {
   const first = `${String(diagnostic.severity ?? 'info')} ${String(diagnostic.code ?? 'diagnostic')} ${String(diagnostic.message ?? '')}`;
   const details = diagnosticDetailLines(diagnostic);

package/src/parsers/decorator-parser.ts

@@ -14,6 +14,10 @@ import {
   type RepositorySourceContext,
 } from './ts-project.js';
 import { normalizePath } from '../utils/path-utils.js';
+import {
+  collectStringConstantLookups,
+  type StringConstantLookups,
+} from './string-constant-lookups.js';
 
 type DecoratorResolution = HandlerMethodFact['decoratorResolution'];
 type ResolvedArgumentKind = Exclude<
@@ -21,9 +25,7 @@ type ResolvedArgumentKind = Exclude<
   'lifecycle_implicit' | 'unresolved'
 >;
 interface StringLookups {
-  identifiers: Map<string, string>;
-  enumMembers: Map<string, string>;
-  objectProperties: Map<string, string>;
+  strings: StringConstantLookups;
   capDecoratorNames: Map<string, string>;
   capDecoratorNamespaces: Set<string>;
 }
@@ -94,60 +96,14 @@ function unwrapExpression(expression: ts.Expression): ts.Expression {
   ) current = current.expression;
   return current;
 }
-function stringValue(expression: ts.Expression | undefined): string | undefined {
-  if (!expression) return undefined;
-  const unwrapped = unwrapExpression(expression);
-  return ts.isStringLiteralLike(unwrapped) ? unwrapped.text : undefined;
-}
-function propertyName(node: ts.PropertyName): string | undefined {
-  if (ts.isIdentifier(node) || ts.isStringLiteralLike(node)) return node.text;
-  return undefined;
-}
-function collectEnumMembers(
-  statement: ts.EnumDeclaration,
-  lookups: StringLookups,
-): void {
-  for (const member of statement.members) {
-    const name = propertyName(member.name);
-    const value = stringValue(member.initializer);
-    if (name && value !== undefined)
-      lookups.enumMembers.set(`${statement.name.text}.${name}`, value);
-  }
-}
-function collectObjectProperties(
-  name: string,
-  initializer: ts.Expression,
-  lookups: StringLookups,
-): void {
-  const object = unwrapExpression(initializer);
-  if (!ts.isObjectLiteralExpression(object)) return;
-  for (const property of object.properties) {
-    if (!ts.isPropertyAssignment(property)) continue;
-    const key = propertyName(property.name);
-    const value = stringValue(property.initializer);
-    if (key && value !== undefined)
-      lookups.objectProperties.set(`${name}.${key}`, value);
-  }
-}
 function collectStringLookups(source: ts.SourceFile): StringLookups {
   const lookups: StringLookups = {
-    identifiers: new Map(),
-    enumMembers: new Map(),
-    objectProperties: new Map(),
+    strings: collectStringConstantLookups(source),
     capDecoratorNames: new Map(),
     capDecoratorNamespaces: new Set(),
   };
   for (const statement of source.statements) {
     collectCapDecoratorImports(statement, lookups);
-    if (ts.isEnumDeclaration(statement)) collectEnumMembers(statement, lookups);
-    if (!ts.isVariableStatement(statement)
-      || !(statement.declarationList.flags & ts.NodeFlags.Const)) continue;
-    for (const declaration of statement.declarationList.declarations) {
-      if (!ts.isIdentifier(declaration.name) || !declaration.initializer) continue;
-      const value = stringValue(declaration.initializer);
-      if (value !== undefined) lookups.identifiers.set(declaration.name.text, value);
-      collectObjectProperties(declaration.name.text, declaration.initializer, lookups);
-    }
   }
   return lookups;
 }
@@ -226,7 +182,7 @@ function resolveDecoratorArgument(
   if (ts.isStringLiteralLike(expression))
     return resolved(rawExpression, argumentExpression, expression.text, 'literal');
   if (ts.isIdentifier(expression)) {
-    const value = lookups.identifiers.get(expression.text);
+    const value = lookups.strings.identifiers.get(expression.text)?.value;
     return value === undefined
       ? unresolved(rawExpression, 'identifier_not_resolved_to_local_const_string', argumentExpression)
       : resolved(rawExpression, argumentExpression, value, 'const_identifier');
@@ -234,10 +190,10 @@ function resolveDecoratorArgument(
   if (ts.isPropertyAccessExpression(expression)
     && ts.isIdentifier(expression.expression)) {
     const key = `${expression.expression.text}.${expression.name.text}`;
-    const enumValue = lookups.enumMembers.get(key);
+    const enumValue = lookups.strings.enumMembers.get(key)?.value;
     if (enumValue !== undefined)
       return resolved(rawExpression, argumentExpression, enumValue, 'enum_member');
-    const objectValue = lookups.objectProperties.get(key);
+    const objectValue = lookups.strings.objectProperties.get(key)?.value;
     if (objectValue !== undefined)
       return resolved(rawExpression, argumentExpression, objectValue, 'const_object_property');
   }