@saptools/service-flow 0.1.68 → 0.1.69

package/src/indexer/workspace-indexer.ts

@@ -1,12 +1,23 @@
 import type { Db } from '../db/connection.js';
 import { listRepositories, reposByName } from '../db/repositories.js';
 import { errorMessage } from '../utils/diagnostics.js';
-import { prepareRepositoryIndex, publishPreparedRepositoryIndex, recordIndexFailure, type PreparedRepositoryIndex } from './repository-indexer.js';
+import {
+  prepareRepositoryIndex,
+  publishOneRepository,
+  recordIndexFailure,
+  type PreparedRepositoryIndex,
+} from './repository-indexer.js';
 import { materializeCdsExtensionOperations } from './cds-extension-resolver.js';
 import {
   createPackageInvalidationBatch,
   finalizePackageTargetInvalidations,
+  mergePackageInvalidationEffects,
+  type PackageInvalidationBatch,
 } from '../db/004-package-target-invalidation.js';
+import {
+  isPreparedRepositorySnapshotError,
+} from '../db/013-index-publication-failure.js';
+import { binaryCompare } from '../parsers/004-fact-identity.js';
 // Ownerless rows predate PID coordination; this matches doctor's stale-run threshold without taking over a recent legacy writer.
 const LEGACY_OWNER_RECOVERY_MS = 60 * 60 * 1_000;
 type RunningIndexRow = Record<string, unknown>;
@@ -80,11 +91,21 @@ export function claimIndexRun(
     throw error;
   }
 }
+export interface IndexWorkspaceSummary {
+  repoCount: number;
+  indexedCount: number;
+  skippedCount: number;
+  failedCount: number;
+  failedRepos: Array<{ name: string; code: string }>;
+  fileCount: number;
+  diagnosticCount: number;
+}
+
 export async function indexWorkspace(
   db: Db,
   workspaceId: number,
   options: { repo?: string; force: boolean; injectDerivedMaterializationFailure?: boolean },
-): Promise<{ repoCount: number; indexedCount: number; skippedCount: number; fileCount: number; diagnosticCount: number }> {
+): Promise<IndexWorkspaceSummary> {
   const repos = selectedRepositories(db, workspaceId, options.repo);
   const runId = claimIndexRun(db, workspaceId, repos.length);
   const state: PreparationState = {
@@ -92,8 +113,9 @@ export async function indexWorkspace(
   };
   try {
     await prepareRepositories(repos, options.force, state);
-    publishPreparedRows(db, workspaceId, options, runId, state);
-    return indexSummary(repos.length, state);
+    return publishPreparedWorkspaceRows(
+      db, workspaceId, runId, state.rows, options,
+    );
   } catch (error) {
     finishFailedRun(db, runId, state, error);
     if (state.activeRepoId && state.rows.length < repos.length)
@@ -111,6 +133,18 @@ interface PreparationState {
   activeRepoId?: number;
 }
 
+interface PublicationState {
+  fileCount: number;
+  diagnosticCount: number;
+  skippedCount: number;
+  indexedCount: number;
+  publicationFailureCount: number;
+  failedRepoIds: Set<number>;
+  failedRepos: Array<{ name: string; code: string }>;
+  rows: readonly PreparedRepositoryIndex[];
+  activeRepoId?: number;
+}
+
 function selectedRepositories(
   db: Db,
   workspaceId: number,
@@ -145,38 +179,118 @@ async function prepareRepositories(
   }
 }
 
-function publishPreparedRows(
+export function publishPreparedWorkspaceRows(
   db: Db,
   workspaceId: number,
-  options: { injectDerivedMaterializationFailure?: boolean },
   runId: number,
-  state: PreparationState,
-): void {
+  rows: readonly PreparedRepositoryIndex[],
+  options: { injectDerivedMaterializationFailure?: boolean } = {},
+): IndexWorkspaceSummary {
+  const state = publicationState(rows);
   db.transaction(() => {
-    const invalidations = createPackageInvalidationBatch(
-      state.rows.filter((row) => !row.skipped).map((row) => row.repo.id),
-    );
+    const effects = createPackageInvalidationBatch([]);
+    const publishedRepoIds: number[] = [];
     for (const row of state.rows) {
       state.activeRepoId = row.repo.id;
-      publishPreparedRepositoryIndex(db, row, invalidations);
+      if (row.skipped) continue;
+      const result = publishPreparedRow(db, row);
+      if (result.status === 'failed') {
+        recordPublicationFailure(db, state, row, result.error);
+        continue;
+      }
+      state.indexedCount += 1;
+      publishedRepoIds.push(row.repo.id);
+      mergePackageInvalidationEffects(effects, result.effects);
     }
     if (options.injectDerivedMaterializationFailure)
       throw new Error('Injected derived materialization failure');
-    materializeCdsExtensionOperations(db, workspaceId);
+    materializeCdsExtensionOperations(
+      db, workspaceId, state.failedRepoIds,
+    );
+    const invalidations = createPackageInvalidationBatch(publishedRepoIds);
+    mergePackageInvalidationEffects(invalidations, effects);
     finalizePackageTargetInvalidations(db, invalidations);
-    finishSuccessfulRun(db, runId, state);
+    finishCompletedRun(db, runId, state);
+  });
+  return indexSummary(rows.length, state);
+}
+
+function publicationState(
+  rows: readonly PreparedRepositoryIndex[],
+): PublicationState {
+  return {
+    rows,
+    fileCount: rows.reduce((total, row) => total + row.fileCount, 0),
+    diagnosticCount: rows.reduce(
+      (total, row) => total + row.diagnosticCount, 0,
+    ),
+    skippedCount: rows.filter((row) => row.skipped).length,
+    indexedCount: 0,
+    publicationFailureCount: 0,
+    failedRepoIds: new Set(),
+    failedRepos: [],
+  };
+}
+
+type PublicationResult =
+  | { status: 'published'; effects: PackageInvalidationBatch }
+  | { status: 'failed'; error: unknown };
+
+function publishPreparedRow(
+  db: Db,
+  row: PreparedRepositoryIndex,
+): PublicationResult {
+  const effects = createPackageInvalidationBatch([row.repo.id]);
+  const outcome = publishOneRepository(db, row, effects);
+  if (!outcome.ok && !isPreparedRepositorySnapshotError(outcome.error))
+    throw outcome.error;
+  return outcome.ok
+    ? { status: 'published', effects }
+    : { status: 'failed', error: outcome.error };
+}
+
+function recordPublicationFailure(
+  db: Db,
+  state: PublicationState,
+  row: PreparedRepositoryIndex,
+  error: unknown,
+): void {
+  state.failedRepoIds.add(row.repo.id);
+  state.failedRepos.push({
+    name: row.repo.name,
+    code: isPreparedRepositorySnapshotError(error)
+      ? error.message : 'source_read_failed',
   });
+  state.publicationFailureCount += 1;
 }
 
-function finishSuccessfulRun(
+function finishCompletedRun(
   db: Db,
   runId: number,
-  state: PreparationState,
+  state: PublicationState,
 ): void {
-  db.prepare(`UPDATE index_runs SET finished_at=?,status='success',
-    file_count=?,diagnostic_count=? WHERE id=?`).run(
-    new Date().toISOString(), state.fileCount, state.diagnosticCount, runId,
+  const status = completedRunStatus(
+    state.rows.length, state.publicationFailureCount,
   );
+  const error = status === 'success' ? null
+    : `${state.publicationFailureCount} repositories failed index publication.`;
+  db.prepare(`UPDATE index_runs SET finished_at=?,status=?,
+    file_count=?,diagnostic_count=?,error_message=? WHERE id=?`).run(
+    new Date().toISOString(), status, state.fileCount,
+    completedDiagnosticCount(state), error, runId,
+  );
+}
+
+function completedRunStatus(
+  repoCount: number,
+  failedCount: number,
+): 'success' | 'partial_failure' | 'failed' {
+  if (failedCount === 0) return 'success';
+  return failedCount === repoCount ? 'failed' : 'partial_failure';
+}
+
+function completedDiagnosticCount(state: PublicationState): number {
+  return state.diagnosticCount + state.publicationFailureCount;
 }
 
 function finishFailedRun(
@@ -194,19 +308,17 @@ function finishFailedRun(
 
 function indexSummary(
   repoCount: number,
-  state: PreparationState,
-): {
-  repoCount: number;
-  indexedCount: number;
-  skippedCount: number;
-  fileCount: number;
-  diagnosticCount: number;
-} {
+  state: PublicationState,
+): IndexWorkspaceSummary {
   return {
     repoCount,
-    indexedCount: repoCount - state.skippedCount,
+    indexedCount: state.indexedCount,
     skippedCount: state.skippedCount,
+    failedCount: state.publicationFailureCount,
+    failedRepos: [...state.failedRepos].sort((left, right) =>
+      binaryCompare(left.name, right.name)
+      || binaryCompare(left.code, right.code)),
     fileCount: state.fileCount,
-    diagnosticCount: state.diagnosticCount,
+    diagnosticCount: completedDiagnosticCount(state),
   };
 }

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

@@ -1,4 +1,8 @@
 import type { Db } from '../db/connection.js';
+import {
+  linkEventTemplate,
+  type LinkedEventTemplate,
+} from './006-event-template-link.js';
 
 export interface SubscriptionHandlerLinkSummary {
   edgeCount: number;
@@ -20,6 +24,7 @@ interface SubscriptionRow {
   startOffset?: number | null;
   endOffset?: number | null;
   confidence: number;
+  unresolvedReason?: string | null;
 }
 
 interface HandlerCallRow {
@@ -58,7 +63,7 @@ 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.confidence,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='async_subscribe'
       AND json_extract(c.evidence_json,'$.handlerReferenceStatus')
@@ -202,11 +207,16 @@ function missingAssociation(
 function evidenceFor(
   subscription: SubscriptionRow,
   association: HandlerAssociation,
+  event: LinkedEventTemplate,
 ): Record<string, unknown> {
   const call: Partial<HandlerCallRow> = association.call ?? {};
   const symbolCallReason = boundedSymbolCallReason(call.unresolvedReason);
   return {
     eventName: subscription.eventName,
+    ...(event.substitution.placeholders.length > 0 ? {
+      effectiveEventName: event.targetId,
+      eventTemplateResolution: event.substitution,
+    } : {}),
     associationBasis: 'exact_subscription_call_span',
     dispatchScope: 'workspace_event_name_only',
     subscribeCallId: subscription.id,
@@ -253,22 +263,27 @@ function insertAssociationEdge(
   generation: number,
   subscription: SubscriptionRow,
   association: HandlerAssociation,
+  event: LinkedEventTemplate,
 ): void {
+  const status = event.isDynamic ? 'unresolved' : association.status;
+  const reason = event.isDynamic
+    ? 'event_template_variables_missing'
+    : 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,
     confidence,evidence_json,is_dynamic,unresolved_reason,generation
   ) VALUES(?,?,?,?,?,?,?,?,?,?,?,?)`).run(
     workspaceId,
     'EVENT_SUBSCRIPTION_HANDLED_BY',
-    association.status,
-    'event',
-    subscription.eventName,
+    status,
+    event.targetKind,
+    event.targetId,
     association.toKind,
     association.toId,
     association.call?.confidence ?? subscription.confidence,
-    JSON.stringify(evidenceFor(subscription, association)),
-    0,
-    association.reasonCode ?? association.call?.unresolvedReason ?? null,
+    JSON.stringify(evidenceFor(subscription, association, event)),
+    event.isDynamic ? 1 : 0,
+    reason,
     generation,
   );
 }
@@ -277,6 +292,7 @@ export function linkEventSubscriptionHandlers(
   db: Db,
   workspaceId: number,
   generation: number,
+  variables: Record<string, string> = {},
 ): SubscriptionHandlerLinkSummary {
   const summary: SubscriptionHandlerLinkSummary = {
     edgeCount: 0,
@@ -286,16 +302,21 @@ 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,
+      db, workspaceId, generation, subscription, association, event,
     );
+    const status = event.isDynamic ? 'unresolved' : association.status;
     summary.edgeCount += 1;
-    summary.resolvedCount += association.status === 'resolved' ? 1 : 0;
-    summary.ambiguousCount += association.status === 'ambiguous' ? 1 : 0;
-    summary.unresolvedCount += association.status === 'unresolved' ? 1 : 0;
+    summary.resolvedCount += status === 'resolved' ? 1 : 0;
+    summary.ambiguousCount += status === 'ambiguous' ? 1 : 0;
+    summary.unresolvedCount += status === 'unresolved' ? 1 : 0;
     summary.missingAssociationCount += association.missing ? 1 : 0;
   }
   return summary;

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

@@ -0,0 +1,72 @@
+import type { Db } from '../db/connection.js';
+import {
+  substituteVariables,
+  type RuntimeSubstitution,
+} from './dynamic-edge-resolver.js';
+
+export interface LinkedEventTemplate {
+  targetId: string;
+  targetKind: 'event' | 'event_candidate';
+  status: 'terminal' | 'dynamic';
+  isDynamic: boolean;
+  unresolvedReason?: string;
+  substitution: RuntimeSubstitution;
+}
+
+export function linkEventTemplate(
+  template: string,
+  variables: Record<string, string>,
+  parserReason?: string,
+): LinkedEventTemplate {
+  const substitution = substituteVariables(template, variables);
+  const missing = substitution.missing.length > 0;
+  const unsupportedDynamic = substitution.placeholders.length === 0
+    && parserReason !== undefined;
+  const dynamic = missing || unsupportedDynamic;
+  return {
+    targetId: dynamic
+      ? `Event: ${substitution.effective ?? template}`
+      : substitution.effective ?? template,
+    targetKind: dynamic ? 'event_candidate' : 'event',
+    status: dynamic ? 'dynamic' : 'terminal',
+    isDynamic: dynamic,
+    unresolvedReason: missing
+      ? `Dynamic target requires runtime variable overrides: ${
+          substitution.missing.join(', ')}`
+      : unsupportedDynamic ? parserReason : undefined,
+    substitution,
+  };
+}
+
+export function insertEventCallEdge(
+  db: Db,
+  workspaceId: number,
+  generation: number,
+  call: Record<string, unknown>,
+  variables: Record<string, string>,
+  evidence: Record<string, unknown>,
+): { status: string; callType: string } {
+  const callType = String(call.call_type);
+  const event = linkEventTemplate(
+    String(call.event_name_expr ?? ''), variables,
+    typeof call.unresolved_reason === 'string'
+      ? call.unresolved_reason : undefined,
+  );
+  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;
+  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, 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,
+  );
+  return { status: event.status, callType };
+}