@saptools/service-flow 0.1.70 → 0.1.72

package/src/linker/event-shape-candidate-linker.ts

@@ -0,0 +1,161 @@
+import type { Db } from '../db/connection.js';
+import { parseEventSkeletonFact } from '../utils/event-skeleton.js';
+
+export interface EventShapeCandidateLinkSummary {
+  edgeCount: number;
+}
+
+interface EventShapeRow extends Record<string, unknown> {
+  id: number;
+  repoId: number;
+  repoName: string;
+  signature: string;
+  skeletonJson: string;
+}
+
+interface SubscriberAssociation extends Record<string, unknown> {
+  graphEdgeId: number;
+  subscribeCallId: number;
+  targetKind: string;
+  targetId: string;
+  status: string;
+  evidenceJson: string;
+}
+
+function eventRows(
+  db: Db,
+  workspaceId: number,
+  callType: 'async_emit' | 'async_subscribe',
+): EventShapeRow[] {
+  return db.prepare(`SELECT c.id,c.repo_id repoId,r.name repoName,
+    c.event_skeleton_signature signature,
+    c.event_skeleton_json skeletonJson
+    FROM outbound_calls c JOIN repositories r ON r.id=c.repo_id
+    WHERE r.workspace_id=? AND c.call_type=?
+      AND c.event_skeleton_signature IS NOT NULL
+      AND c.event_skeleton_json IS NOT NULL
+    ORDER BY c.event_skeleton_signature COLLATE BINARY,
+      r.name COLLATE BINARY,r.id,c.source_file COLLATE BINARY,
+      c.call_site_start_offset,c.call_site_end_offset,c.id`).all(
+    workspaceId, callType,
+  ) as unknown as EventShapeRow[];
+}
+
+function associations(
+  db: Db,
+  workspaceId: number,
+  generation: number,
+): SubscriberAssociation[] {
+  return db.prepare(`SELECT id graphEdgeId,
+    CAST(json_extract(evidence_json,'$.subscribeCallId') AS INTEGER)
+      subscribeCallId,
+    to_kind targetKind,to_id targetId,status,evidence_json evidenceJson
+    FROM graph_edges
+    WHERE workspace_id=? AND generation=?
+      AND edge_type='EVENT_SUBSCRIPTION_HANDLED_BY'
+      AND to_kind='symbol'
+    ORDER BY subscribeCallId,id`).all(
+    workspaceId, generation,
+  ) as unknown as SubscriberAssociation[];
+}
+
+function parsedEvidence(value: string): Record<string, unknown> {
+  try {
+    const parsed: unknown = JSON.parse(value);
+    return parsed && typeof parsed === 'object' && !Array.isArray(parsed)
+      ? parsed as Record<string, unknown> : {};
+  } catch {
+    return {};
+  }
+}
+
+function candidateEligible(
+  emit: EventShapeRow,
+  subscribe: EventShapeRow,
+): boolean {
+  if (emit.signature !== subscribe.signature) return false;
+  const left = parseEventSkeletonFact(emit.skeletonJson);
+  const right = parseEventSkeletonFact(subscribe.skeletonJson);
+  return Boolean(left?.candidateEligible && right?.candidateEligible
+    && left.holeCount === right.holeCount
+    && JSON.stringify(left.literalSpans) === JSON.stringify(right.literalSpans));
+}
+
+function candidateEvidence(
+  emit: EventShapeRow,
+  subscribe: EventShapeRow,
+  association: SubscriberAssociation,
+): Record<string, unknown> {
+  const evidence = parsedEvidence(association.evidenceJson);
+  return {
+    publishCallId: emit.id,
+    subscribeCallId: subscribe.id,
+    eventSkeletonSignature: emit.signature,
+    dispatchScope: 'workspace_event_name_only',
+    dispatchCertainty: 'skeleton_equivalent',
+    subscriptionRepositoryId: subscribe.repoId,
+    subscriptionRepositoryName: subscribe.repoName,
+    subscriptionConsumerRepositoryId:
+      evidence.subscriptionConsumerRepositoryId,
+    subscriptionConsumerRepositoryName:
+      evidence.subscriptionConsumerRepositoryName,
+    handlerSymbolId: Number(association.targetId),
+    associationGraphEdgeId: association.graphEdgeId,
+  };
+}
+
+function insertCandidate(
+  db: Db,
+  workspaceId: number,
+  generation: number,
+  emit: EventShapeRow,
+  subscribe: EventShapeRow,
+  association: SubscriberAssociation,
+): void {
+  db.prepare(`INSERT INTO graph_edges(
+    workspace_id,edge_type,status,from_kind,from_id,to_kind,to_id,
+    confidence,evidence_json,is_dynamic,unresolved_reason,generation
+  ) VALUES(?,?,?,?,?,?,?,?,?,?,?,?)`).run(
+    workspaceId,
+    'EVENT_SHAPE_CANDIDATE_SUBSCRIBER',
+    'dynamic',
+    'call',
+    String(emit.id),
+    association.targetKind,
+    association.targetId,
+    0.3,
+    JSON.stringify(candidateEvidence(
+      emit, subscribe, association,
+    )),
+    1,
+    'event_skeleton_equivalent_non_authoritative',
+    generation,
+  );
+}
+
+export function linkEventShapeCandidates(
+  db: Db,
+  workspaceId: number,
+  generation: number,
+): EventShapeCandidateLinkSummary {
+  const emits = eventRows(db, workspaceId, 'async_emit');
+  const subscriptions = eventRows(db, workspaceId, 'async_subscribe');
+  const bySubscription = new Map<number, SubscriberAssociation[]>();
+  for (const association of associations(db, workspaceId, generation))
+    bySubscription.set(association.subscribeCallId, [
+      ...(bySubscription.get(association.subscribeCallId) ?? []),
+      association,
+    ]);
+  let edgeCount = 0;
+  for (const emit of emits)
+    for (const subscription of subscriptions) {
+      if (!candidateEligible(emit, subscription)) continue;
+      for (const association of bySubscription.get(subscription.id) ?? []) {
+        insertCandidate(
+          db, workspaceId, generation, emit, subscription, association,
+        );
+        edgeCount += 1;
+      }
+    }
+  return { edgeCount };
+}

package/src/linker/event-subscription-handler-linker.ts

@@ -3,6 +3,11 @@ import {
   linkEventTemplate,
   type LinkedEventTemplate,
 } from './event-template-link.js';
+import {
+  subscriptionEnvironmentTargets,
+  type SubscriptionEnvironmentTarget,
+} from './event-environment-link.js';
+import { parseEventSkeletonFact } from '../utils/event-skeleton.js';
 
 export interface SubscriptionHandlerLinkSummary {
   edgeCount: number;
@@ -25,6 +30,9 @@ interface SubscriptionRow {
   endOffset?: number | null;
   confidence: number;
   unresolvedReason?: string | null;
+  packageName?: string | null;
+  environmentJson?: string | null;
+  eventSkeletonJson?: string | null;
 }
 
 interface HandlerCallRow {
@@ -63,7 +71,10 @@ function subscriptionRows(db: Db, workspaceId: number): SubscriptionRow[] {
     c.source_symbol_id sourceSymbolId,c.event_name_expr eventName,
     c.source_file sourceFile,c.source_line sourceLine,
     c.call_site_start_offset startOffset,c.call_site_end_offset endOffset,
-    c.confidence,c.unresolved_reason unresolvedReason
+    c.confidence,c.unresolved_reason unresolvedReason,
+    c.event_skeleton_json eventSkeletonJson,
+    r.package_name packageName,
+    r.environment_declarations_json environmentJson
     FROM outbound_calls c JOIN repositories r ON r.id=c.repo_id
     WHERE r.workspace_id=? AND c.call_type='async_subscribe'
       AND json_extract(c.evidence_json,'$.handlerReferenceStatus')
@@ -208,11 +219,18 @@ function evidenceFor(
   subscription: SubscriptionRow,
   association: HandlerAssociation,
   event: LinkedEventTemplate,
+  environment?: SubscriptionEnvironmentTarget,
 ): Record<string, unknown> {
   const call: Partial<HandlerCallRow> = association.call ?? {};
   const symbolCallReason = boundedSymbolCallReason(call.unresolvedReason);
+  const environmentAmbiguous = environment?.resolution.status === 'ambiguous'
+    || Number(environment?.collisionCount ?? 1) > 1;
+  const resolutionStatus = event.isDynamic
+    ? 'unresolved'
+    : environmentAmbiguous ? 'ambiguous' : association.status;
   return {
     eventName: subscription.eventName,
+    ...(eventSkeletonEvidence(subscription.eventSkeletonJson)),
     ...(event.substitution.placeholders.length > 0 ? {
       effectiveEventName: event.targetId,
       eventTemplateResolution: event.substitution,
@@ -226,6 +244,18 @@ function evidenceFor(
     factOrigin: association.factOrigin ?? call.factOrigin,
     repositoryId: subscription.repoId,
     repositoryName: subscription.repoName,
+    subscriptionConsumerRepositoryId: environment?.consumerRepoId,
+    subscriptionConsumerRepositoryName: environment?.consumerRepoName,
+    dispatchCertainty: environment?.resolution.status === 'resolved'
+      ? 'environment_declaration_exact' : 'static_name_only',
+    ...(environment?.resolution.status === 'not_applicable' ? {} : {
+      eventEnvironmentResolution: {
+        status: environment?.resolution.status,
+        reason: environment?.resolution.reason,
+        provenance: environment?.resolution.provenance,
+        collisionCount: environment?.collisionCount,
+      },
+    }),
     sourceFile: subscription.sourceFile,
     sourceLine: subscription.sourceLine,
     callSiteStartOffset: subscription.startOffset,
@@ -237,14 +267,23 @@ function evidenceFor(
     associationStatus: association.status,
     symbolCallResolutionStatus:
       association.symbolCallResolutionStatus ?? call.status,
-    resolutionStatus: association.status,
+    resolutionStatus,
     resolutionStrategy: call.strategy,
     candidateCount: call.candidateCount,
-    reasonCode: association.reasonCode,
+    reasonCode: environmentAmbiguous
+      ? environment?.resolution.reason ?? 'event_environment_value_collision'
+      : association.reasonCode,
     ...symbolCallReason,
   };
 }
 
+function eventSkeletonEvidence(
+  value: string | null | undefined,
+): Record<string, unknown> {
+  const skeleton = parseEventSkeletonFact(value);
+  return skeleton ? { eventSkeleton: skeleton } : {};
+}
+
 function boundedSymbolCallReason(
   reason: string | null | undefined,
 ): Record<string, unknown> {
@@ -264,10 +303,20 @@ function insertAssociationEdge(
   subscription: SubscriptionRow,
   association: HandlerAssociation,
   event: LinkedEventTemplate,
+  environment?: SubscriptionEnvironmentTarget,
 ): void {
-  const status = event.isDynamic ? 'unresolved' : association.status;
+  const environmentAmbiguous = environment?.resolution.status === 'ambiguous'
+    || Number(environment?.collisionCount ?? 1) > 1;
+  const status = event.isDynamic
+    ? 'unresolved'
+    : environmentAmbiguous ? 'ambiguous' : association.status;
   const reason = event.isDynamic
-    ? 'event_template_variables_missing'
+    ? event.substitution.missing.length > 0
+      ? 'event_template_variables_missing'
+      : event.unresolvedReason ?? 'event_name_unsupported_constant_expression'
+    : environmentAmbiguous
+      ? environment?.resolution.reason
+        ?? 'event_environment_value_collision'
     : association.reasonCode ?? association.call?.unresolvedReason ?? null;
   db.prepare(`INSERT INTO graph_edges(
     workspace_id,edge_type,status,from_kind,from_id,to_kind,to_id,
@@ -281,13 +330,68 @@ function insertAssociationEdge(
     association.toKind,
     association.toId,
     association.call?.confidence ?? subscription.confidence,
-    JSON.stringify(evidenceFor(subscription, association, event)),
+    JSON.stringify(evidenceFor(
+      subscription, association, event, environment,
+    )),
     event.isDynamic ? 1 : 0,
     reason,
     generation,
   );
 }
 
+function linkedSubscriptionEvents(
+  db: Db,
+  workspaceId: number,
+  subscription: SubscriptionRow,
+  variables: Record<string, string>,
+): Array<{
+  event: LinkedEventTemplate;
+  environment: SubscriptionEnvironmentTarget;
+}> {
+  const skeleton = parseEventSkeletonFact(subscription.eventSkeletonJson);
+  return subscriptionEnvironmentTargets(
+    db,
+    workspaceId,
+    subscription.packageName ?? undefined,
+    subscription.eventSkeletonJson,
+    subscription.environmentJson,
+    variables,
+  ).map((environment) => ({
+    environment,
+    event: linkEventTemplate(
+      subscription.eventName,
+      environment.resolution.variables,
+      subscription.unresolvedReason ?? undefined,
+      skeleton,
+    ),
+  }));
+}
+
+function targetStatus(
+  association: HandlerAssociation,
+  event: LinkedEventTemplate,
+  environment: SubscriptionEnvironmentTarget,
+): 'resolved' | 'ambiguous' | 'unresolved' {
+  if (event.isDynamic || association.status === 'unresolved')
+    return 'unresolved';
+  if (association.status === 'ambiguous'
+    || environment.resolution.status === 'ambiguous'
+    || environment.collisionCount > 1) return 'ambiguous';
+  return 'resolved';
+}
+
+function incrementSummary(
+  summary: SubscriptionHandlerLinkSummary,
+  status: 'resolved' | 'ambiguous' | 'unresolved',
+  missing: boolean,
+): void {
+  summary.edgeCount += 1;
+  summary.resolvedCount += status === 'resolved' ? 1 : 0;
+  summary.ambiguousCount += status === 'ambiguous' ? 1 : 0;
+  summary.unresolvedCount += status === 'unresolved' ? 1 : 0;
+  summary.missingAssociationCount += missing ? 1 : 0;
+}
+
 export function linkEventSubscriptionHandlers(
   db: Db,
   workspaceId: number,
@@ -302,22 +406,22 @@ export function linkEventSubscriptionHandlers(
     missingAssociationCount: 0,
   };
   for (const subscription of subscriptionRows(db, workspaceId)) {
-    const event = linkEventTemplate(
-      subscription.eventName, variables,
-      subscription.unresolvedReason ?? undefined,
-    );
     const association = associationFor(
       subscription, roleSiteRows(db, subscription),
     );
-    insertAssociationEdge(
-      db, workspaceId, generation, subscription, association, event,
-    );
-    const status = event.isDynamic ? 'unresolved' : association.status;
-    summary.edgeCount += 1;
-    summary.resolvedCount += status === 'resolved' ? 1 : 0;
-    summary.ambiguousCount += status === 'ambiguous' ? 1 : 0;
-    summary.unresolvedCount += status === 'unresolved' ? 1 : 0;
-    summary.missingAssociationCount += association.missing ? 1 : 0;
+    for (const target of linkedSubscriptionEvents(
+      db, workspaceId, subscription, variables,
+    )) {
+      insertAssociationEdge(
+        db, workspaceId, generation, subscription, association,
+        target.event, target.environment,
+      );
+      incrementSummary(
+        summary,
+        targetStatus(association, target.event, target.environment),
+        association.missing,
+      );
+    }
   }
   return summary;
 }

package/src/linker/event-template-link.ts

@@ -3,6 +3,14 @@ import {
   substituteVariables,
   type RuntimeSubstitution,
 } from './dynamic-edge-resolver.js';
+import {
+  resolveEventEnvironment,
+} from './event-environment-link.js';
+import {
+  eventTemplateVariables,
+  parseEventSkeletonFact,
+  type EventSkeletonFact,
+} from '../utils/event-skeleton.js';
 
 export interface LinkedEventTemplate {
   targetId: string;
@@ -17,8 +25,11 @@ export function linkEventTemplate(
   template: string,
   variables: Record<string, string>,
   parserReason?: string,
+  skeleton?: EventSkeletonFact,
 ): LinkedEventTemplate {
-  const substitution = substituteVariables(template, variables);
+  const substitution = substituteVariables(
+    template, eventTemplateVariables(skeleton, variables),
+  );
   const missing = substitution.missing.length > 0;
   const unsupportedDynamic = substitution.placeholders.length === 0
     && parserReason !== undefined;
@@ -47,18 +58,41 @@ export function insertEventCallEdge(
   evidence: Record<string, unknown>,
 ): { status: string; callType: string } {
   const callType = String(call.call_type);
+  const skeleton = parseEventSkeletonFact(call.event_skeleton_json);
+  const environment = resolveEventEnvironment(
+    call.event_skeleton_json,
+    call.environmentDeclarationsJson,
+    variables,
+  );
   const event = linkEventTemplate(
-    String(call.event_name_expr ?? ''), variables,
+    String(call.event_name_expr ?? ''), environment.variables,
     typeof call.unresolved_reason === 'string'
       ? call.unresolved_reason : undefined,
+    skeleton,
   );
   const edgeType = event.isDynamic
     ? 'DYNAMIC_EDGE_CANDIDATE'
     : callType === 'async_emit'
       ? 'HANDLER_EMITS_EVENT' : 'EVENT_CONSUMED_BY_HANDLER';
-  const eventEvidence = event.substitution.placeholders.length > 0
-    ? { ...evidence, eventTemplateResolution: event.substitution }
-    : evidence;
+  const eventEvidence = {
+    ...evidence,
+    dispatchScope: 'workspace_event_name_only',
+    dispatchCertainty: environment.status === 'resolved'
+      ? 'environment_declaration_exact'
+      : event.isDynamic ? 'runtime_variables_required' : 'static_name_only',
+    ...(skeleton ? { eventSkeleton: skeleton } : {}),
+    ...(event.substitution.placeholders.length > 0
+      ? { eventTemplateResolution: event.substitution } : {}),
+    ...(environment.status === 'not_applicable' ? {} : {
+      eventEnvironmentResolution: {
+        status: environment.status,
+        reason: environment.reason,
+        provenance: environment.provenance,
+      },
+    }),
+  };
+  const unresolvedReason = environment.reason
+    ?? event.unresolvedReason;
   db.prepare(`INSERT INTO graph_edges(
     workspace_id,edge_type,status,from_kind,from_id,to_kind,to_id,
     confidence,evidence_json,is_dynamic,unresolved_reason,generation
@@ -66,7 +100,7 @@ export function insertEventCallEdge(
     workspaceId, edgeType, event.status, 'call', String(call.id),
     event.targetKind, event.targetId, Number(call.confidence ?? 0.2),
     JSON.stringify(eventEvidence), event.isDynamic ? 1 : 0,
-    event.unresolvedReason ?? null, generation,
+    unresolvedReason ?? null, generation,
   );
   return { status: event.status, callType };
 }