@saptools/service-flow 0.1.67 → 0.1.69

package/src/db/004-package-target-invalidation.ts

@@ -0,0 +1,183 @@
+import type { Db } from './connection.js';
+import { ANALYZER_VERSION } from '../version.js';
+import {
+  parsePackageImportReference,
+} from '../parsers/012-package-fact-contract.js';
+
+interface PackageCallRow {
+  id: number;
+  repoId: number;
+  evidence: Record<string, unknown>;
+}
+
+export interface PackageInvalidationBatch {
+  publishingRepoIds: ReadonlySet<number>;
+  affectedCallerRepoIds: Set<number>;
+  affectedWorkspaceIds: Set<number>;
+}
+
+const resolverKeys = new Set([
+  'candidateStrategy', 'candidateCount', 'eligibleCandidateCount',
+  'selectedCandidateCount', 'candidateSetComplete', 'resolvedModulePath',
+  'resolvedTargetRepositoryId', 'unresolvedReason',
+  'targetRepositoryCandidateCount', 'targetRepositoryCandidates',
+  'shownTargetRepositoryCandidateCount',
+  'omittedTargetRepositoryCandidateCount', 'publicSurface',
+]);
+
+function record(value: unknown): Record<string, unknown> | undefined {
+  return value && typeof value === 'object' && !Array.isArray(value)
+    ? value as Record<string, unknown> : undefined;
+}
+
+function parsedEvidence(value: unknown): Record<string, unknown> | undefined {
+  if (typeof value !== 'string') return undefined;
+  try {
+    return record(JSON.parse(value) as unknown);
+  } catch {
+    return undefined;
+  }
+}
+
+function packageName(evidence: Record<string, unknown>): string | undefined {
+  return parsePackageImportReference(evidence.importBinding)
+    ?.requestedPackageName ?? undefined;
+}
+
+function packageCallEvidenceValid(
+  evidence: Record<string, unknown>,
+): boolean {
+  const binding = record(evidence.importBinding);
+  const classified = evidence.relation === 'package_import'
+    || binding?.moduleKind === 'package';
+  return !classified || packageName(evidence) !== undefined;
+}
+
+function currentCalls(
+  db: Db,
+  workspaceId: number,
+  targetRepoId: number,
+): PackageCallRow[] {
+  const rows = db.prepare(`SELECT sc.id,sc.repo_id repoId,
+    sc.evidence_json evidenceJson FROM symbol_calls sc
+    JOIN repositories r ON r.id=sc.repo_id
+    WHERE r.workspace_id=? AND r.id<>? AND r.fact_analyzer_version=?
+    ORDER BY sc.id`).all(workspaceId, targetRepoId, ANALYZER_VERSION);
+  return rows.flatMap((row) => {
+    const evidence = parsedEvidence(row.evidenceJson);
+    if (!evidence || typeof row.id !== 'number'
+      || typeof row.repoId !== 'number')
+      throw new Error('invalid_current_package_import_evidence');
+    if (!packageCallEvidenceValid(evidence))
+      throw new Error('invalid_current_package_import_evidence');
+    return evidence.relation === 'package_import'
+      || record(evidence.importBinding)?.moduleKind === 'package'
+      ? [{ id: row.id, repoId: row.repoId, evidence }]
+      : [];
+  });
+}
+
+function pendingEvidence(evidence: Record<string, unknown>): string {
+  const parser = Object.fromEntries(Object.entries(evidence).filter(
+    ([key]) => !resolverKeys.has(key),
+  ));
+  if (!packageName(parser))
+    throw new Error('invalid_current_package_import_evidence');
+  return JSON.stringify({
+    ...parser,
+    candidateStrategy: 'package_import_pending',
+    candidateCount: 0,
+    eligibleCandidateCount: 0,
+    selectedCandidateCount: 0,
+    candidateSetComplete: false,
+    unresolvedReason: 'package_resolution_pending',
+  });
+}
+
+function targetWorkspace(
+  db: Db,
+  repoId: number,
+): { workspaceId: number; packageName?: string | null } {
+  const row = db.prepare(`SELECT workspace_id workspaceId,
+    package_name packageName FROM repositories WHERE id=?`).get(repoId);
+  if (typeof row?.workspaceId !== 'number')
+    throw new Error('Repository target is missing its workspace');
+  return {
+    workspaceId: row.workspaceId,
+    packageName: typeof row.packageName === 'string'
+      || row.packageName === null ? row.packageName : undefined,
+  };
+}
+
+function packageIdentityChanged(
+  previous: string | null | undefined,
+  next: string | undefined,
+): boolean {
+  const previousName = typeof previous === 'string' ? previous : null;
+  const nextName = typeof next === 'string' ? next : null;
+  return previousName !== nextName;
+}
+
+export function invalidatePackageTargetFacts(
+  db: Db,
+  targetRepoId: number,
+  newPackageName: string | undefined,
+  batch: PackageInvalidationBatch,
+): void {
+  const target = targetWorkspace(db, targetRepoId);
+  const names = new Set(
+    [target.packageName, newPackageName].filter(
+      (value): value is string => typeof value === 'string' && value.length > 0,
+    ),
+  );
+  if (names.size === 0) return;
+  const update = db.prepare(`UPDATE symbol_calls SET callee_symbol_id=NULL,
+    status='unresolved',unresolved_reason='package_resolution_pending',
+    evidence_json=? WHERE id=?`);
+  let matched = false;
+  for (const call of currentCalls(db, target.workspaceId, targetRepoId)) {
+    const requested = packageName(call.evidence);
+    if (!requested || !names.has(requested)) continue;
+    update.run(pendingEvidence(call.evidence), call.id);
+    batch.affectedCallerRepoIds.add(call.repoId);
+    matched = true;
+  }
+  if (matched || packageIdentityChanged(
+    target.packageName, newPackageName,
+  )) batch.affectedWorkspaceIds.add(target.workspaceId);
+}
+
+export function createPackageInvalidationBatch(
+  publishingRepoIds: readonly number[],
+): PackageInvalidationBatch {
+  return {
+    publishingRepoIds: new Set(publishingRepoIds),
+    affectedCallerRepoIds: new Set(),
+    affectedWorkspaceIds: new Set(),
+  };
+}
+
+export function mergePackageInvalidationEffects(
+  target: PackageInvalidationBatch,
+  source: PackageInvalidationBatch,
+): void {
+  for (const repoId of source.affectedCallerRepoIds)
+    target.affectedCallerRepoIds.add(repoId);
+  for (const workspaceId of source.affectedWorkspaceIds)
+    target.affectedWorkspaceIds.add(workspaceId);
+}
+
+export function finalizePackageTargetInvalidations(
+  db: Db,
+  batch: PackageInvalidationBatch,
+): void {
+  const increment = db.prepare(`UPDATE repositories
+    SET fact_generation=fact_generation+1 WHERE id=?`);
+  for (const repoId of batch.affectedCallerRepoIds)
+    if (!batch.publishingRepoIds.has(repoId)) increment.run(repoId);
+  const stale = db.prepare(`UPDATE repositories
+    SET graph_stale_reason='package_target_facts_changed',
+      graph_stale_at=datetime('now') WHERE workspace_id=?`);
+  for (const workspaceId of batch.affectedWorkspaceIds)
+    stale.run(workspaceId);
+}

package/src/db/005-schema-structure.ts

@@ -0,0 +1,201 @@
+import type { Db } from './connection.js';
+
+export interface SchemaStructureCategoryCount {
+  category: string;
+  count: number;
+}
+
+const requiredColumns = {
+  workspaces: [
+    'id', 'root_path', 'db_path', 'created_at', 'updated_at',
+  ],
+  repositories: [
+    'id', 'workspace_id', 'name', 'absolute_path', 'relative_path',
+    'package_name', 'package_version', 'dependencies_json',
+    'package_public_surface_json', 'kind', 'is_git_repo', 'last_indexed_at',
+    'index_status', 'error_count', 'fingerprint', 'fact_generation',
+    'graph_generation', 'graph_stale_reason', 'graph_stale_at',
+    'fact_analyzer_version',
+  ],
+  files: [
+    'id', 'repo_id', 'relative_path', 'extension', 'sha256', 'size_bytes',
+    'last_indexed_at',
+  ],
+  cds_requires: [
+    'id', 'repo_id', 'alias', 'kind', 'model', 'destination',
+    'service_path', 'request_timeout', 'raw_json',
+  ],
+  cds_services: [
+    'id', 'repo_id', 'namespace', 'service_name', 'qualified_name',
+    'service_path', 'is_extend', 'source_file', 'source_line',
+    'extension_local_ref', 'extension_imported_symbol',
+    'extension_local_alias', 'extension_module_specifier',
+    'extension_import_kind', 'extension_base_service_id',
+    'extension_base_status',
+  ],
+  cds_operations: [
+    'id', 'service_id', 'operation_type', 'operation_name', 'operation_path',
+    'params_json', 'return_type', 'source_file', 'source_line', 'provenance',
+    'base_operation_id',
+  ],
+  symbols: [
+    'id', 'repo_id', 'file_id', 'kind', 'name', 'qualified_name',
+    'exported', 'start_line', 'end_line', 'start_offset', 'end_offset',
+    'source_file', 'exported_name', 'evidence_json',
+  ],
+  handler_classes: [
+    'id', 'repo_id', 'symbol_id', 'class_name', 'source_file', 'source_line',
+  ],
+  handler_methods: [
+    'id', 'handler_class_id', 'method_name', 'decorator_kind',
+    'decorator_value', 'decorator_raw_expression',
+    'decorator_resolution_json', 'source_file', 'source_line',
+  ],
+  handler_registrations: [
+    'id', 'repo_id', 'handler_class_id', 'class_name', 'import_source',
+    'registration_file', 'registration_line', 'registration_kind',
+    'confidence',
+  ],
+  service_bindings: [
+    'id', 'repo_id', 'symbol_id', 'variable_name', 'alias', 'alias_expr',
+    'destination_expr', 'service_path_expr', 'is_dynamic',
+    'placeholders_json', 'source_file', 'source_line',
+    'binding_site_start_offset', 'binding_site_end_offset',
+    'owner_resolution', 'helper_chain_json',
+  ],
+  outbound_calls: [
+    'id', 'repo_id', 'source_symbol_id', 'service_binding_id', 'call_type',
+    'method', 'operation_path_expr', 'query_entity', 'event_name_expr',
+    'payload_summary', 'source_file', 'source_line',
+    'call_site_start_offset', 'call_site_end_offset', 'evidence_json',
+    'confidence', 'unresolved_reason', 'local_service_name',
+    'local_service_lookup', 'alias_chain_json', 'external_target_kind',
+    'external_target_id', 'external_target_label', 'external_target_dynamic',
+  ],
+  symbol_calls: [
+    'id', 'repo_id', 'caller_symbol_id', 'callee_symbol_id',
+    'callee_expression', 'import_source', 'source_file', 'source_line',
+    'call_site_start_offset',
+    'call_site_end_offset', 'call_role', 'status', 'evidence_json',
+    'confidence', 'unresolved_reason',
+  ],
+  graph_edges: [
+    'id', 'workspace_id', 'edge_type', 'status', 'from_kind', 'from_id',
+    'to_kind', 'to_id', 'confidence', 'evidence_json', 'is_dynamic',
+    'unresolved_reason', 'generation',
+  ],
+  index_runs: [
+    'id', 'workspace_id', 'started_at', 'finished_at', 'status',
+    'repo_count', 'file_count', 'diagnostic_count', 'error_message',
+    'owner_pid',
+  ],
+  diagnostics: [
+    'id', 'repo_id', 'file_id', 'severity', 'code', 'message',
+    'source_file', 'source_line',
+  ],
+  search_index: ['kind', 'name', 'path', 'repo'],
+} as const;
+
+type RequiredTable = keyof typeof requiredColumns;
+
+function tableNames(db: Db): Set<string> {
+  const rows = db.prepare(
+    "SELECT name FROM sqlite_master WHERE type='table'",
+  ).all();
+  return new Set(rows.flatMap((row) =>
+    typeof row.name === 'string' ? [row.name] : []));
+}
+
+function columnNames(db: Db, table: RequiredTable): Set<string> {
+  const rows = db.prepare(`PRAGMA table_info(${table})`).all();
+  return new Set(rows.flatMap((row) =>
+    typeof row.name === 'string' ? [row.name] : []));
+}
+
+function missingTableCount(db: Db): number {
+  const actual = tableNames(db);
+  return Object.keys(requiredColumns).filter((table) =>
+    !actual.has(table)).length;
+}
+
+function missingColumnCount(db: Db): number {
+  const actualTables = tableNames(db);
+  return Object.entries(requiredColumns).reduce(
+    (total, [table, columns]) => {
+      if (!actualTables.has(table)) return total;
+      const actual = columnNames(db, table as RequiredTable);
+      return total + columns.filter((column) => !actual.has(column)).length;
+    },
+    0,
+  );
+}
+
+const bindingSiteColumns = [
+  'repo_id', 'source_file', 'variable_name',
+  'binding_site_start_offset', 'binding_site_end_offset',
+];
+const exactSitePredicate =
+  'where binding_site_start_offset is not null and '
+  + 'binding_site_end_offset is not null';
+
+function indexColumns(db: Db, name: string): string[] {
+  return db.prepare(`PRAGMA index_info(${name})`).all().flatMap((item) =>
+    typeof item.name === 'string' ? [item.name] : []);
+}
+
+function indexMetadata(
+  db: Db,
+  name: string,
+): Record<string, unknown> | undefined {
+  return db.prepare("PRAGMA index_list('service_bindings')")
+    .all().find((item) => item.name === name);
+}
+
+function normalizedSql(value: string): string {
+  return value.toLowerCase().replace(/\s+/g, ' ').trim();
+}
+
+function bindingIndexInvalid(
+  db: Db,
+  name: string,
+  unique: number,
+  partial: number,
+): number {
+  const metadata = indexMetadata(db, name);
+  const columns = indexColumns(db, name);
+  return columns.join('\0') === bindingSiteColumns.join('\0')
+    && metadata?.unique === unique && metadata.partial === partial ? 0 : 1;
+}
+
+function exactBindingIndexInvalid(db: Db): number {
+  const row = db.prepare(`SELECT sql FROM sqlite_master
+    WHERE type='index' AND name='uq_service_binding_exact_site'`).get();
+  if (typeof row?.sql !== 'string'
+    || !normalizedSql(row.sql).endsWith(exactSitePredicate)) return 1;
+  return bindingIndexInvalid(
+    db, 'uq_service_binding_exact_site', 1, 1,
+  );
+}
+
+function category(
+  name: string,
+  count: number,
+): SchemaStructureCategoryCount[] {
+  return count > 0 ? [{ category: name, count }] : [];
+}
+
+export function invalidSchemaStructureCategories(
+  db: Db,
+): SchemaStructureCategoryCount[] {
+  const missingTables = missingTableCount(db);
+  if (missingTables > 0)
+    return category('schema_required_table_missing', missingTables);
+  return [
+    ...category('schema_required_column_missing', missingColumnCount(db)),
+    ...category(
+      'schema_binding_exact_site_index_invalid',
+      exactBindingIndexInvalid(db)
+        + bindingIndexInvalid(db, 'idx_service_binding_site', 0, 0),
+    ),
+  ];
+}