@saptools/service-flow 0.1.68 → 0.1.69

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

@@ -1,5 +1,7 @@
 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 {
@@ -33,6 +35,7 @@ interface MappingTarget {
 interface MappedExecutableRows {
   rows: TargetRow[];
   ambiguous: boolean;
+  packageTargetUnsupported: boolean;
 }
 
 const stripExtension = (value: string): string =>
@@ -138,8 +141,12 @@ function handlerMemberPubliclyCarried(
 ): boolean {
   if (row.exported) return true;
   const evidence = parsedRecord(row.evidenceJson);
-  return evidence?.source === 'exported_class_instance_member'
-    && evidence.exportedClass === binding.importedName;
+  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(
@@ -287,9 +294,12 @@ function mappingTargetScope(
 ): RelativeModuleScope | undefined {
   const target = mappingTarget(row);
   if (!target) return undefined;
-  return target.specifier
-    ? relativeModuleScope(db, repoId, row.sourceFile, target.specifier)
-    : { paths: new Set([stripExtension(row.sourceFile)]), ambiguous: false };
+  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(
@@ -298,18 +308,24 @@ function mappedExecutableRows(
   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 };
+    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 };
+  return {
+    rows: uniqueRows(mapped), ambiguous: false, packageTargetUnsupported,
+  };
 }
 
 function proxyResolution(
@@ -326,6 +342,11 @@ function proxyResolution(
     '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([

package/src/db/008-relative-fact-semantics.ts

@@ -81,9 +81,12 @@ function derivedRelativeProvenance(
   targetName: string,
 ): boolean {
   if (!memberReference(binding)) return false;
-  if (evidence.relation === 'class_instance_method')
-    return targetName === binding.requestedPublicName
-      && evidence.methodName === binding.referencedMemberName;
+  if (evidence.relation === 'class_instance_method') {
+    if (evidence.methodName !== binding.referencedMemberName) return false;
+    return binding.bindingKind === 'esm_default'
+      ? targetName === `${binding.localName}.${binding.referencedMemberName}`
+      : targetName === binding.requestedPublicName;
+  }
   if (evidence.relation !== 'relative_import_proxy_member') return false;
   return targetName === binding.referencedMemberName
     && typeof evidence.proxyVariableName === 'string';

package/src/db/009-binding-fact-semantics.ts

@@ -9,6 +9,9 @@ import {
   validBindingLexicalScope,
   type BindingProofTarget,
 } from './012-binding-reference-proof.js';
+import {
+  hasSingleHopHelperReturn,
+} from './014-binding-helper-provenance.js';
 
 export interface BindingFactCategoryCount {
   category: string;
@@ -114,6 +117,7 @@ function bindingTargets(
     binding.binding_site_start_offset startOffset,
     binding.binding_site_end_offset endOffset,
     binding.owner_resolution ownerResolution,
+    binding.helper_chain_json helperChainJson,
     owner.start_offset ownerStartOffset,owner.end_offset ownerEndOffset
     FROM service_bindings binding
     JOIN repositories repo ON repo.id=binding.repo_id
@@ -140,6 +144,7 @@ function bindingTarget(
     ownerResolution: row.ownerResolution,
     ownerStartOffset: row.ownerStartOffset,
     ownerEndOffset: row.ownerEndOffset,
+    singleHopHelperReturn: hasSingleHopHelperReturn(row.helperChainJson),
   }];
 }
 

package/src/db/012-binding-reference-proof.ts

@@ -23,6 +23,7 @@ export interface BindingProofTarget {
   ownerResolution: string;
   ownerStartOffset: number | null;
   ownerEndOffset: number | null;
+  singleHopHelperReturn: boolean;
 }
 
 interface ResolvedBindingProof {
@@ -45,6 +46,7 @@ const strategies = new Set([
   'lexical_declaration',
   'lexical_alias_declaration',
   'deterministic_reaching_assignment',
+  'single_hop_helper_return',
 ]);
 
 function record(value: unknown): Record<string, unknown> | undefined {
@@ -242,6 +244,8 @@ function targetMatches(
   target: BindingProofTarget | undefined,
 ): boolean {
   if (!target || call.bindingId !== target.id) return false;
+  if (reference.resolutionStrategy === 'single_hop_helper_return'
+    && !target.singleHopHelperReturn) return false;
   return all([
     target.repoId === call.repoId,
     target.sourceFile === call.sourceFile,

package/src/db/013-index-publication-failure.ts

@@ -0,0 +1,91 @@
+import type { Db } from './connection.js';
+
+export type PreparedRepositoryFactKind =
+  | 'outbound_call'
+  | 'service_binding'
+  | 'symbol_call';
+
+export type PreparedSnapshotFailureCode =
+  | 'binding_lexical_proof_invalid'
+  | 'binding_owner_mismatch'
+  | 'binding_reference_mismatch'
+  | 'binding_reference_missing'
+  | 'binding_site_missing'
+  | 'duplicate_service_binding_site'
+  | 'outbound_owner_mismatch'
+  | 'package_import_provenance_missing'
+  | 'symbol_call_owner_mismatch';
+
+export interface PreparedSnapshotFailureSite {
+  factKind: PreparedRepositoryFactKind;
+  sourceFile?: string;
+  sourceLine?: number;
+  callSiteStartOffset?: number;
+  callSiteEndOffset?: number;
+}
+
+export class PreparedRepositorySnapshotError extends Error {
+  readonly failureCode: PreparedSnapshotFailureCode;
+  readonly site: PreparedSnapshotFailureSite;
+
+  constructor(
+    failureCode: PreparedSnapshotFailureCode,
+    site: PreparedSnapshotFailureSite,
+  ) {
+    super(`invalid_prepared_repository_snapshot:${failureCode}`);
+    this.name = 'PreparedRepositorySnapshotError';
+    this.failureCode = failureCode;
+    this.site = site;
+  }
+}
+
+interface PreparedCallSite {
+  sourceFile: string;
+  sourceLine: number;
+  callSiteStartOffset?: number;
+  callSiteEndOffset?: number;
+}
+
+export function preparedCallSnapshotError(
+  failureCode: PreparedSnapshotFailureCode,
+  factKind: 'outbound_call' | 'symbol_call',
+  call: PreparedCallSite,
+): PreparedRepositorySnapshotError {
+  return new PreparedRepositorySnapshotError(failureCode, {
+    factKind,
+    sourceFile: call.sourceFile,
+    sourceLine: call.sourceLine,
+    callSiteStartOffset: call.callSiteStartOffset,
+    callSiteEndOffset: call.callSiteEndOffset,
+  });
+}
+
+export function isPreparedRepositorySnapshotError(
+  error: unknown,
+): error is PreparedRepositorySnapshotError {
+  return error instanceof PreparedRepositorySnapshotError;
+}
+
+export function recordPreparedSnapshotFailure(
+  db: Db,
+  repoId: number,
+  error: PreparedRepositorySnapshotError,
+): void {
+  db.prepare(`UPDATE repositories SET index_status='failed',
+    error_count=1 WHERE id=?`).run(repoId);
+  db.prepare(`DELETE FROM diagnostics WHERE repo_id=? AND (
+    code IN ('index_failed_snapshot_preserved','source_read_failed')
+    OR code GLOB 'invalid_prepared_repository_snapshot:*'
+  )`).run(repoId);
+  db.prepare(`INSERT INTO diagnostics(
+    repo_id,severity,code,message,source_file,source_line
+  ) VALUES(?,?,?,?,?,?)`).run(
+    repoId,
+    'error',
+    error.message,
+    'Index publication failed before commit for this repository; previous facts and fingerprint were preserved. '
+      + `factKind=${error.site.factKind}`,
+    error.site.sourceFile,
+    error.site.sourceLine,
+  );
+}

package/src/db/014-binding-helper-provenance.ts

@@ -0,0 +1,17 @@
+function record(value: unknown): value is Record<string, unknown> {
+  return Boolean(value && typeof value === 'object' && !Array.isArray(value));
+}
+
+function parsed(value: string): unknown {
+  try {
+    return JSON.parse(value) as unknown;
+  } catch {
+    return undefined;
+  }
+}
+
+export function hasSingleHopHelperReturn(value: unknown): boolean {
+  const chain = typeof value === 'string' ? parsed(value) : value;
+  return Array.isArray(chain) && chain.some((step) =>
+    record(step) && step.bindingOrigin === 'single_hop_helper_return');
+}

package/src/db/repositories.ts

@@ -12,6 +12,10 @@ import {
   selectCallOwner,
   type OwnerCandidate,
 } from '../parsers/004-fact-identity.js';
+import {
+  PreparedRepositorySnapshotError,
+  type PreparedSnapshotFailureCode,
+} from './013-index-publication-failure.js';
 export interface RepoRow {
   id: number;
   name: string;
@@ -414,6 +418,19 @@ interface PersistedOwnerCandidate extends OwnerCandidate {
   id: number;
 }
 
+function bindingSnapshotError(
+  failureCode: PreparedSnapshotFailureCode,
+  fact: ServiceBindingFact,
+): PreparedRepositorySnapshotError {
+  return new PreparedRepositorySnapshotError(failureCode, {
+    factKind: 'service_binding',
+    sourceFile: fact.sourceFile,
+    sourceLine: fact.sourceLine,
+    callSiteStartOffset: fact.bindingSiteStartOffset,
+    callSiteEndOffset: fact.bindingSiteEndOffset,
+  });
+}
+
 function persistedOwnerCandidates(
   db: Db,
   repoId: number,
@@ -454,16 +471,16 @@ function bindingOwnerId(
   );
   if (fact.ownerResolution === 'ownerless_file_scope') {
     if (selected.status !== 'none')
-      throw new Error('invalid_prepared_repository_snapshot:binding_owner_mismatch');
+      throw bindingSnapshotError('binding_owner_mismatch', fact);
     return null;
   }
   if (fact.ownerResolution !== 'owned_exact'
     || selected.status !== 'resolved'
     || selected.owner?.qualifiedName !== fact.sourceSymbolQualifiedName)
-    throw new Error('invalid_prepared_repository_snapshot:binding_owner_mismatch');
+    throw bindingSnapshotError('binding_owner_mismatch', fact);
   const owner = selected.owner;
   if (!owner)
-    throw new Error('invalid_prepared_repository_snapshot:binding_owner_mismatch');
+    throw bindingSnapshotError('binding_owner_mismatch', fact);
   return owner.id;
 }
 
@@ -474,13 +491,13 @@ function assertUniquePreparedBindingSites(
   for (const row of rows) {
     if (row.bindingSiteStartOffset === undefined
       || row.bindingSiteEndOffset === undefined)
-      throw new Error('invalid_prepared_repository_snapshot:binding_site_missing');
+      throw bindingSnapshotError('binding_site_missing', row);
     const key = [
       row.sourceFile, row.variableName,
       row.bindingSiteStartOffset, row.bindingSiteEndOffset,
     ].join('\u0000');
     if (seen.has(key))
-      throw new Error('invalid_prepared_repository_snapshot:duplicate_service_binding_site');
+      throw bindingSnapshotError('duplicate_service_binding_site', row);
     seen.add(key);
   }
 }

package/src/indexer/cds-extension-resolver.ts

@@ -15,9 +15,12 @@ interface BaseRow { id: number; repoId: number }
 interface DesiredOperation { id: number; operationType: string; operationName: string; operationPath: string; paramsJson: string; returnType: string | null; sourceFile: string; sourceLine: number }
 interface ExistingOperation extends DesiredOperation { baseOperationId: number | null }
 
-export function materializeCdsExtensionOperations(db: Db, workspaceId: number): void {
-  const extensions = db.prepare(`SELECT s.id,r.id repoId,s.service_name serviceName,s.qualified_name qualifiedName,s.source_file sourceFile,s.extension_module_specifier moduleSpecifier,s.extension_imported_symbol importedSymbol,s.extension_import_kind importKind
-    FROM cds_services s JOIN repositories r ON r.id=s.repo_id WHERE r.workspace_id=? AND s.is_extend=1`).all(workspaceId) as unknown as ExtensionRow[];
+export function materializeCdsExtensionOperations(
+  db: Db,
+  workspaceId: number,
+  excludedRepoIds: ReadonlySet<number> = new Set(),
+): void {
+  const extensions = extensionRows(db, workspaceId, excludedRepoIds);
   db.transaction(() => {
     const changedRepos = new Set<number>();
     for (const extension of extensions) {
@@ -27,6 +30,27 @@ export function materializeCdsExtensionOperations(db: Db, workspaceId: number):
   });
 }
 
+function extensionRows(
+  db: Db,
+  workspaceId: number,
+  excludedRepoIds: ReadonlySet<number>,
+): ExtensionRow[] {
+  const excluded = [...excludedRepoIds].sort((left, right) => left - right);
+  const exclusion = excluded.length > 0
+    ? ` AND r.id NOT IN (${excluded.map(() => '?').join(',')})`
+    : '';
+  return db.prepare(`SELECT s.id,r.id repoId,s.service_name serviceName,
+    s.qualified_name qualifiedName,s.source_file sourceFile,
+    s.extension_module_specifier moduleSpecifier,
+    s.extension_imported_symbol importedSymbol,
+    s.extension_import_kind importKind
+    FROM cds_services s JOIN repositories r ON r.id=s.repo_id
+    WHERE r.workspace_id=? AND s.is_extend=1${exclusion}
+    ORDER BY r.id,s.id`).all(
+    workspaceId, ...excluded,
+  ) as unknown as ExtensionRow[];
+}
+
 function reconcileExtension(db: Db, workspaceId: number, extension: ExtensionRow): boolean {
   const bases = resolveBase(db, workspaceId, extension);
   const status = bases.length === 1 ? 'resolved' : bases.length > 1 ? 'ambiguous' : 'unresolved';

package/src/indexer/repository-indexer.ts

@@ -45,6 +45,10 @@ import {
   invalidatePackageTargetFacts,
   type PackageInvalidationBatch,
 } from '../db/004-package-target-invalidation.js';
+import {
+  isPreparedRepositorySnapshotError,
+  recordPreparedSnapshotFailure,
+} from '../db/013-index-publication-failure.js';
 import {
   loadRepositorySourceContext,
   type RepositorySourceContext,
@@ -82,12 +86,21 @@ export async function indexRepository(
 ): Promise<IndexRepoResult> {
   try {
     const prepared = await prepareRepositoryIndex(repo, force, instrumentation);
-    if (!prepared.skipped) db.transaction(() => {
+    if (prepared.skipped)
+      return { fileCount: 0, diagnosticCount: 0, skipped: true };
+    const outcome = db.transaction(() => {
       const batch = createPackageInvalidationBatch([prepared.repo.id]);
-      publishPreparedRepositoryIndex(db, prepared, batch);
-      finalizePackageTargetInvalidations(db, batch);
+      const published = publishOneRepository(db, prepared, batch);
+      if (published.ok) finalizePackageTargetInvalidations(db, batch);
+      return published;
     });
-    return { fileCount: prepared.fileCount, diagnosticCount: prepared.diagnosticCount, skipped: prepared.skipped };
+    return outcome.ok
+      ? {
+          fileCount: prepared.fileCount,
+          diagnosticCount: prepared.diagnosticCount,
+          skipped: false,
+        }
+      : { fileCount: 0, diagnosticCount: 1, skipped: false };
   } catch (error) {
     recordIndexFailure(db, repo.id, error);
     return { fileCount: 0, diagnosticCount: 1, skipped: false };
@@ -172,10 +185,58 @@ export function publishPreparedRepositoryIndex(
   insertCalls(db, repoId, prepared.parsed.calls);
   db.prepare("UPDATE repositories SET last_indexed_at=?, index_status='indexed', error_count=0, fingerprint=?, fact_generation=COALESCE(fact_generation,0)+1, graph_stale_reason='facts_changed', graph_stale_at=?, fact_analyzer_version=? WHERE id=?").run(now, prepared.fingerprint, now, ANALYZER_VERSION, repoId);
 }
+
+export type RepositoryPublicationOutcome =
+  | { ok: true }
+  | { ok: false; error: unknown };
+
+export function publishOneRepository(
+  db: Db,
+  prepared: PreparedRepositoryIndex,
+  invalidations: PackageInvalidationBatch,
+): RepositoryPublicationOutcome {
+  try {
+    db.transaction(() => withPublicationSavepoint(
+      db,
+      prepared.repo.id,
+      () => publishPreparedRepositoryIndex(db, prepared, invalidations),
+    ));
+    return { ok: true };
+  } catch (error) {
+    recordIndexFailure(db, prepared.repo.id, error);
+    return { ok: false, error };
+  }
+}
+
+function withPublicationSavepoint<T>(
+  db: Db,
+  repoId: number,
+  publish: () => T,
+): T {
+  const name = `service_flow_repository_${repoId}`;
+  db.exec(`SAVEPOINT ${name}`);
+  try {
+    const result = publish();
+    db.exec(`RELEASE SAVEPOINT ${name}`);
+    return result;
+  } catch (error) {
+    db.exec(`ROLLBACK TO SAVEPOINT ${name}`);
+    db.exec(`RELEASE SAVEPOINT ${name}`);
+    throw error;
+  }
+}
+
 export function recordIndexFailure(db: Db, repoId: number, error: unknown): void {
+  if (isPreparedRepositorySnapshotError(error)) {
+    recordPreparedSnapshotFailure(db, repoId, error);
+    return;
+  }
   const message = errorMessage(error);
   db.prepare("UPDATE repositories SET index_status='failed', error_count=1 WHERE id=?").run(repoId);
-  db.prepare("DELETE FROM diagnostics WHERE repo_id=? AND code IN ('index_failed_snapshot_preserved','source_read_failed')").run(repoId);
+  db.prepare(`DELETE FROM diagnostics WHERE repo_id=? AND (
+    code IN ('index_failed_snapshot_preserved','source_read_failed')
+    OR code GLOB 'invalid_prepared_repository_snapshot:*'
+  )`).run(repoId);
   db.prepare('INSERT INTO diagnostics(repo_id,severity,code,message) VALUES(?,?,?,?)').run(repoId, 'error', 'source_read_failed', `Index failed before publication; previous facts and fingerprint were preserved. ${message}`);
 }
 async function parseAllSourceFacts(