///|
fn json_string(value : String) -> Json {
Json::string(value)
}
///|
fn json_int(value : Int) -> Json {
Json::number(value.to_double(), repr=value.to_string())
}
///|
fn json_object(fields : Array[(String, Json)]) -> Json {
Json::object(Map::from_array(fields))
}
///|
fn analysis_model_json() -> Json {
json_object([
("mode", json_string("bounded_semantic")),
("confidence", json_string("conservative")),
(
"pipeline",
Json::array([
json_string("typed_lexer"),
json_string("top_level_statement_split"),
json_string("structural_ddl_parser"),
json_string("schema_state_reducer"),
json_string("statement_coverage_trace"),
json_string("query_reference_analysis"),
json_string("policy_evaluation"),
]),
),
(
"unsupported",
Json::array([
json_string("procedural_blocks"),
json_string("dynamic_sql"),
json_string("query_plan_semantics"),
json_string("live_database_introspection"),
]),
),
])
}
///|
fn finding_json(finding : Finding) -> Json {
json_object([
("rule_id", json_string(finding.rule_id)),
("title", json_string(finding.title)),
("severity", json_string(finding.severity.label())),
("statement", json_int(finding.statement_index)),
("line", json_int(finding.line)),
("column", json_int(finding.column)),
("message", json_string(finding.message)),
("suggestion", json_string(finding.suggestion)),
("evidence", json_string(finding.evidence)),
("fingerprint", json_string(finding.fingerprint)),
])
}
///|
fn suppressed_rule_json(rule : SuppressedRule) -> Json {
json_object([
("rule_id", json_string(rule.rule_id)),
("count", json_int(rule.count)),
])
}
///|
fn severity_override_json(policy : SeverityOverride) -> Json {
json_object([
("rule_id", json_string(policy.rule_id)),
("severity", json_string(policy.severity.label())),
])
}
///|
fn report_json(report : Report) -> Json {
let highest = match report.highest_severity() {
Some(severity) => json_string(severity.label())
None => Json::null()
}
json_object([
("schema_version", json_string("1.0")),
("tool", json_string("SQLSentinel")),
(
"summary",
json_object([
("statements", json_int(report.statement_count)),
("errors", json_int(report.error_count)),
("warnings", json_int(report.warning_count)),
("infos", json_int(report.info_count)),
("suppressed", json_int(report.suppressed_count)),
("dialect", json_string(report.dialect.label())),
("schema", Json::boolean(report.schema_enabled)),
("baseline", Json::boolean(report.baseline_enabled)),
("baseline_suppressed", json_int(report.baseline_suppressed_count)),
("highest_severity", highest),
(
"suppressions",
Json::array(report.suppressions.map(suppressed_rule_json)),
),
(
"severity_overrides",
Json::array(report.severity_overrides.map(severity_override_json)),
),
]),
),
("findings", Json::array(report.findings.map(finding_json))),
])
}
///|
/// Render a single report as stable, machine-readable JSON.
pub fn report_to_json(report : Report) -> String {
report_json(report).stringify(indent=2)
}
///|
/// Render one or more file reports as a single JSON document.
pub fn files_to_json(files : Array[FileReport]) -> String {
let mut statements = 0
let mut errors = 0
let mut warnings = 0
let mut infos = 0
let mut suppressed = 0
let mut baseline_suppressed = 0
let mut baseline_enabled = false
let severity_overrides : Array[SeverityOverride] = []
let file_values = []
for file in files {
statements = statements + file.report.statement_count
errors = errors + file.report.error_count
warnings = warnings + file.report.warning_count
infos = infos + file.report.info_count
suppressed = suppressed + file.report.suppressed_count
baseline_suppressed = baseline_suppressed +
file.report.baseline_suppressed_count
baseline_enabled = baseline_enabled || file.report.baseline_enabled
if severity_overrides.is_empty() {
for policy in file.report.severity_overrides {
severity_overrides.push(policy)
}
}
file_values.push(
json_object([
("path", json_string(file.path)),
("statements", json_int(file.report.statement_count)),
("errors", json_int(file.report.error_count)),
("warnings", json_int(file.report.warning_count)),
("infos", json_int(file.report.info_count)),
("suppressed", json_int(file.report.suppressed_count)),
("dialect", json_string(file.report.dialect.label())),
("schema", Json::boolean(file.report.schema_enabled)),
("baseline", Json::boolean(file.report.baseline_enabled)),
("baseline_suppressed", json_int(file.report.baseline_suppressed_count)),
(
"suppressions",
Json::array(file.report.suppressions.map(suppressed_rule_json)),
),
(
"severity_overrides",
Json::array(
file.report.severity_overrides.map(severity_override_json),
),
),
("findings", Json::array(file.report.findings.map(finding_json))),
]),
)
}
json_object([
("schema_version", json_string("1.0")),
("tool", json_string("SQLSentinel")),
(
"summary",
json_object([
("files", json_int(files.length())),
("statements", json_int(statements)),
("errors", json_int(errors)),
("warnings", json_int(warnings)),
("infos", json_int(infos)),
("suppressed", json_int(suppressed)),
("baseline", Json::boolean(baseline_enabled)),
("baseline_suppressed", json_int(baseline_suppressed)),
(
"severity_overrides",
Json::array(severity_overrides.map(severity_override_json)),
),
]),
),
("files", Json::array(file_values)),
]).stringify(indent=2)
}
///|
/// Render one report as a compact terminal review.
pub fn report_to_text(report : Report, path? : String = "") -> String {
let builder = StringBuilder()
builder.write_string("SQLSentinel \{path}\n")
builder.write_string(
"Dialect: \{report.dialect.label()} Schema: \{if report.schema_enabled { "on" } else { "off" }} Statements: \{report.statement_count} Errors: \{report.error_count} Warnings: \{report.warning_count} Info: \{report.info_count}\n",
)
builder.write_string(
"Baseline: \{if report.baseline_enabled { "on" } else { "off" }} Baseline suppressed: \{report.baseline_suppressed_count}\n",
)
if !report.severity_overrides.is_empty() {
builder.write_string("Overrides:")
for policy in report.severity_overrides {
builder.write_string(" \{policy.rule_id}=\{policy.severity.label()}")
}
builder.write_string("\n")
}
if report.suppressed_count > 0 {
builder.write_string("Suppressed: \{report.suppressed_count} finding(s)")
for rule in report.suppressions {
builder.write_string(" \{rule.rule_id} x\{rule.count}")
}
builder.write_string("\n")
}
if report.findings.is_empty() {
if report.suppressed_count > 0 {
builder.write_string("PASS No unsuppressed policy findings.\n")
} else {
builder.write_string("PASS No policy findings.\n")
}
} else {
for finding in report.findings {
builder.write_string(
"\n\{path}:\{finding.line}:\{finding.column} \{finding.severity.label().to_upper()} \{finding.rule_id} \{finding.title}\n",
)
builder.write_string(" \{finding.message}\n")
builder.write_string(" Evidence: \{finding.evidence}\n")
builder.write_string(" Fix: \{finding.suggestion}\n")
}
}
builder.to_string()
}
///|
fn markdown_cell(value : String) -> String {
value.replace_all(old="|", new="\\|").replace_all(old="\n", new=" ")
}
///|
/// Render one report as a Markdown review packet suitable for a pull request
/// comment or an AI code-review prompt.
pub fn report_to_markdown(report : Report, path? : String = "") -> String {
let builder = StringBuilder()
builder.write_string("# SQLSentinel review: \{path}\n\n")
builder.write_string(
"Dialect: `\{report.dialect.label()}` · Schema: `\{if report.schema_enabled { "enabled" } else { "disabled" }}` · Baseline: `\{if report.baseline_enabled { "enabled" } else { "disabled" }}` with **\{report.baseline_suppressed_count}** baseline suppression(s). Scanned **\{report.statement_count}** statements and found **\{report.error_count} errors**, **\{report.warning_count} warnings**, and **\{report.info_count} info** findings.\n\n",
)
if report.suppressed_count > 0 {
builder.write_string(
"**Suppressed:** \{report.suppressed_count} finding(s) -",
)
for rule in report.suppressions {
builder.write_string(" `\{rule.rule_id}` x\{rule.count}")
}
builder.write_string("\n\n")
}
if !report.severity_overrides.is_empty() {
builder.write_string("**Policy overrides:**")
for policy in report.severity_overrides {
builder.write_string(" `\{policy.rule_id}=\{policy.severity.label()}`")
}
builder.write_string("\n\n")
}
if report.findings.is_empty() {
if report.suppressed_count > 0 {
builder.write_string(
"No unsuppressed policy findings. The SQL passed this review.\n",
)
} else {
builder.write_string("No policy findings. The SQL passed this review.\n")
}
return builder.to_string()
}
builder.write_string("| Location | Severity | Rule | Finding |\n")
builder.write_string("| --- | --- | --- | --- |\n")
for finding in report.findings {
builder.write_string(
"| L\{finding.line}:\{finding.column} | \{finding.severity.label()} | \{finding.rule_id} | \{markdown_cell(finding.title)} |\n",
)
}
builder.write_string("\n## Review details\n")
for finding in report.findings {
builder.write_string("\n### \{finding.rule_id} · \{finding.title}\n\n")
builder.write_string(
"- **Location:** statement \{finding.statement_index}, line \{finding.line}, column \{finding.column}\n",
)
builder.write_string("- **Risk:** \{finding.message}\n")
builder.write_string(
"- **Evidence:** `\{finding.evidence.replace_all(old="`", new="'")}`\n",
)
builder.write_string("- **Suggested action:** \{finding.suggestion}\n")
}
builder.to_string()
}
///|
fn github_escape_data(value : String) -> String {
value
.replace_all(old="%", new="%25")
.replace_all(old="\r", new="%0D")
.replace_all(old="\n", new="%0A")
}
///|
fn github_escape_property(value : String) -> String {
github_escape_data(value)
.replace_all(old=":", new="%3A")
.replace_all(old=",", new="%2C")
}
///|
fn github_annotation_level(severity : Severity) -> String {
match severity {
Error => "error"
Warning => "warning"
Info => "notice"
}
}
///|
/// Render one report as GitHub Actions workflow annotations.
pub fn report_to_github(report : Report, path? : String = "") -> String {
let builder = StringBuilder()
let github_path = path.replace_all(old="\\", new="/")
for finding in report.findings {
let title = github_escape_property("\{finding.rule_id} \{finding.title}")
let message = github_escape_data(
"\{finding.message} Evidence: \{finding.evidence} Fix: \{finding.suggestion}",
)
builder.write_string(
"::\{github_annotation_level(finding.severity)} file=\{github_escape_property(github_path)},line=\{finding.line},col=\{finding.column},title=\{title}::\{message}\n",
)
}
builder.write_string(
"SQLSentinel [\{report.dialect.label()}]: \{report.statement_count} statement(s), \{report.error_count} error(s), \{report.warning_count} warning(s), \{report.info_count} info finding(s), \{report.suppressed_count} suppressed (\{report.baseline_suppressed_count} baseline), schema \{if report.schema_enabled { "on" } else { "off" }}, baseline \{if report.baseline_enabled { "on" } else { "off" }}.\n",
)
if !report.severity_overrides.is_empty() {
builder.write_string("SQLSentinel policy overrides:")
for policy in report.severity_overrides {
builder.write_string(" \{policy.rule_id}=\{policy.severity.label()}")
}
builder.write_string("\n")
}
builder.to_string()
}
///|
/// Render file reports as GitHub Actions workflow annotations.
pub fn files_to_github(files : Array[FileReport]) -> String {
let builder = StringBuilder()
let mut statements = 0
let mut errors = 0
let mut warnings = 0
let mut infos = 0
let mut suppressed = 0
let mut baseline_suppressed = 0
let mut baseline_enabled = false
for file in files {
builder.write_string(report_to_github(file.report, path=file.path))
statements = statements + file.report.statement_count
errors = errors + file.report.error_count
warnings = warnings + file.report.warning_count
infos = infos + file.report.info_count
suppressed = suppressed + file.report.suppressed_count
baseline_suppressed = baseline_suppressed +
file.report.baseline_suppressed_count
baseline_enabled = baseline_enabled || file.report.baseline_enabled
}
builder.write_string(
"SQLSentinel total: \{files.length()} file(s), \{statements} statement(s), \{errors} error(s), \{warnings} warning(s), \{infos} info finding(s), \{suppressed} suppressed (\{baseline_suppressed} baseline), baseline \{if baseline_enabled { "on" } else { "off" }}.\n",
)
builder.to_string()
}
///|
/// Render multiple reports as a Markdown document.
pub fn files_to_markdown(files : Array[FileReport]) -> String {
let builder = StringBuilder()
builder.write_string("# SQLSentinel report\n\n")
if files.is_empty() {
builder.write_string("No SQL files were scanned.\n")
return builder.to_string()
}
for file in files {
builder.write_string("\n---\n\n")
builder.write_string(report_to_markdown(file.report, path=file.path))
}
builder.to_string()
}
///|
fn sarif_level(severity : Severity) -> String {
match severity {
Error => "error"
Warning => "warning"
Info => "note"
}
}
///|
fn sarif_rule_json(rule : RuleDefinition) -> Json {
json_object([
("id", json_string(rule.id)),
("name", json_string(rule.title)),
("shortDescription", json_object([("text", json_string(rule.title))])),
("fullDescription", json_object([("text", json_string(rule.rationale))])),
(
"help",
json_object([
("text", json_string(rule.remediation)),
("markdown", json_string(rule.remediation)),
]),
),
(
"defaultConfiguration",
json_object([("level", json_string(sarif_level(rule.severity)))]),
),
])
}
///|
fn sarif_driver_json() -> Json {
json_object([
("name", json_string("SQLSentinel")),
("version", json_string("0.16.0")),
(
"informationUri",
json_string("https://mooncakes.io/docs/#/Ljh684/sqlsentinel"),
),
("rules", Json::array(rule_catalog().map(sarif_rule_json))),
])
}
///|
fn sarif_result_json(path : String, finding : Finding) -> Json {
json_object([
("ruleId", json_string(finding.rule_id)),
("level", json_string(sarif_level(finding.severity))),
("message", json_object([("text", json_string(finding.message))])),
(
"partialFingerprints",
json_object([
("sqlsentinelStatementFingerprint/v1", json_string(finding.fingerprint)),
]),
),
(
"locations",
Json::array([
json_object([
(
"physicalLocation",
json_object([
(
"artifactLocation",
json_object([
("uri", json_string(path.replace_all(old="\\", new="/"))),
]),
),
(
"region",
json_object([
("startLine", json_int(finding.line)),
("startColumn", json_int(finding.column)),
]),
),
]),
),
]),
]),
),
(
"properties",
json_object([
("statement", json_int(finding.statement_index)),
("evidence", json_string(finding.evidence)),
("fingerprint", json_string(finding.fingerprint)),
("suggestion", json_string(finding.suggestion)),
]),
),
])
}
///|
/// Render reports as SARIF 2.1.0 for GitHub code scanning and other
/// Static Analysis Results Interchange Format consumers.
pub fn files_to_sarif(files : Array[FileReport]) -> String {
let results = []
let mut suppressed = 0
let mut dialect = "auto"
let mut schema_enabled = false
let mut baseline_suppressed = 0
let mut baseline_enabled = false
let severity_overrides : Array[SeverityOverride] = []
for file in files {
suppressed = suppressed + file.report.suppressed_count
baseline_suppressed = baseline_suppressed +
file.report.baseline_suppressed_count
dialect = file.report.dialect.label()
schema_enabled = schema_enabled || file.report.schema_enabled
baseline_enabled = baseline_enabled || file.report.baseline_enabled
if severity_overrides.is_empty() {
for policy in file.report.severity_overrides {
severity_overrides.push(policy)
}
}
for finding in file.report.findings {
results.push(sarif_result_json(file.path, finding))
}
}
json_object([
("$schema", json_string("https://json.schemastore.org/sarif-2.1.0.json")),
("version", json_string("2.1.0")),
(
"runs",
Json::array([
json_object([
("tool", json_object([("driver", sarif_driver_json())])),
("results", Json::array(results)),
(
"properties",
json_object([
("suppressed", json_int(suppressed)),
("dialect", json_string(dialect)),
("schema", Json::boolean(schema_enabled)),
("baseline", Json::boolean(baseline_enabled)),
("baseline_suppressed", json_int(baseline_suppressed)),
(
"severity_overrides",
Json::array(severity_overrides.map(severity_override_json)),
),
]),
),
]),
]),
),
]).stringify(indent=2)
}
///|
/// Render the unified review as SARIF 2.1.0 for GitHub code scanning.
pub fn review_sarif_to_string(
files : Array[FileReport],
migration : MigrationAnalysis,
impact : ImpactAnalysis?,
) -> String {
let results = []
let mut suppressed = 0
for file in files {
suppressed = suppressed + file.report.suppressed_count
for finding in file.report.findings {
results.push(sarif_result_json(file.path, finding))
}
}
for entry in migration.findings {
results.push(sarif_result_json(entry.path, entry.finding))
}
let impacted_query_files = match impact {
Some(analysis) => {
for entry in analysis.findings {
results.push(sarif_result_json(entry.path, entry.finding))
}
analysis.impacted_files.length()
}
None => 0
}
let counts = review_counts(files, migration, impact)
let verdict = review_verdict(counts, migration.coverage)
json_object([
("$schema", json_string("https://json.schemastore.org/sarif-2.1.0.json")),
("version", json_string("2.1.0")),
(
"runs",
Json::array([
json_object([
("tool", json_object([("driver", sarif_driver_json())])),
("results", Json::array(results)),
(
"properties",
json_object([
("analysis_model", analysis_model_json()),
("verdict", json_string(verdict)),
("errors", json_int(counts.errors)),
("warnings", json_int(counts.warnings)),
("infos", json_int(counts.infos)),
("suppressed", json_int(suppressed)),
("schema_changes", json_int(migration.changes.length())),
("breaking_changes", json_int(migration.breaking_changes)),
(
"migration_statements",
json_int(migration.coverage.statement_count),
),
("ignored_statements", json_int(migration.coverage.ignored_count)),
("impacted_query_files", json_int(impacted_query_files)),
]),
),
]),
]),
),
]).stringify(indent=2)
}
///|
/// Render multiple reports as compact terminal output.
pub fn files_to_text(files : Array[FileReport]) -> String {
let builder = StringBuilder()
let mut statements = 0
let mut errors = 0
let mut warnings = 0
let mut infos = 0
let mut suppressed = 0
let mut baseline_suppressed = 0
let mut baseline_enabled = false
for file in files {
builder.write_string(report_to_text(file.report, path=file.path))
builder.write_string("\n")
statements = statements + file.report.statement_count
errors = errors + file.report.error_count
warnings = warnings + file.report.warning_count
infos = infos + file.report.info_count
suppressed = suppressed + file.report.suppressed_count
baseline_suppressed = baseline_suppressed +
file.report.baseline_suppressed_count
baseline_enabled = baseline_enabled || file.report.baseline_enabled
}
builder.write_string(
"Overall: \{files.length()} file(s), \{statements} statement(s), \{errors} error(s), \{warnings} warning(s), \{infos} info finding(s), \{suppressed} suppressed (\{baseline_suppressed} baseline), baseline \{if baseline_enabled { "on" } else { "off" }}.\n",
)
builder.to_string()
}
///|
fn schema_change_json(change : SchemaChange) -> Json {
json_object([
("kind", json_string(change.kind.label())),
("table", json_string(change.table_name)),
("column", json_string(change.column_name)),
("detail", json_string(change.detail)),
("path", json_string(change.path)),
("line", json_int(change.line)),
("statement", json_int(change.statement_index)),
])
}
///|
fn statement_trace_json(trace : StatementTrace) -> Json {
json_object([
("path", json_string(trace.path)),
("statement", json_int(trace.statement_index)),
("line", json_int(trace.line)),
("end_line", json_int(trace.end_line)),
("token_count", json_int(trace.token_count)),
("kind", json_string(trace.kind)),
("status", json_string(trace.status.label())),
("reason", json_string(trace.reason)),
])
}
///|
fn migration_coverage_json(coverage : MigrationCoverage) -> Json {
json_object([
("statements", json_int(coverage.statement_count)),
("analyzed", json_int(coverage.analyzed_count)),
("ignored", json_int(coverage.ignored_count)),
("complete", Json::boolean(coverage.is_complete())),
("traces", Json::array(coverage.traces.map(statement_trace_json))),
])
}
///|
fn migration_finding_json(entry : MigrationFinding) -> Json {
let finding = entry.finding
json_object([
("path", json_string(entry.path)),
("rule_id", json_string(finding.rule_id)),
("title", json_string(finding.title)),
("severity", json_string(finding.severity.label())),
("statement", json_int(finding.statement_index)),
("line", json_int(finding.line)),
("column", json_int(finding.column)),
("message", json_string(finding.message)),
("suggestion", json_string(finding.suggestion)),
("evidence", json_string(finding.evidence)),
("fingerprint", json_string(finding.fingerprint)),
])
}
///|
/// Render a project-level migration analysis as stable JSON.
fn migration_analysis_json(analysis : MigrationAnalysis) -> Json {
json_object([
("schema_version", json_string("1.0")),
("tool", json_string("SQLSentinel migration plan")),
("analysis_model", analysis_model_json()),
(
"summary",
json_object([
("tables_before", json_int(analysis.tables_before.length())),
("tables_after", json_int(analysis.tables_after.length())),
("affected_tables", json_int(analysis.affected_tables.length())),
("changes", json_int(analysis.changes.length())),
("breaking_changes", json_int(analysis.breaking_changes)),
("errors", json_int(analysis.error_count)),
("warnings", json_int(analysis.warning_count)),
("infos", json_int(analysis.info_count)),
("statements", json_int(analysis.coverage.statement_count)),
("analyzed_statements", json_int(analysis.coverage.analyzed_count)),
("ignored_statements", json_int(analysis.coverage.ignored_count)),
]),
),
("coverage", migration_coverage_json(analysis.coverage)),
(
"tables",
json_object([
("before", Json::array(analysis.tables_before.map(json_string))),
("after", Json::array(analysis.tables_after.map(json_string))),
("affected", Json::array(analysis.affected_tables.map(json_string))),
]),
),
("changes", Json::array(analysis.changes.map(schema_change_json))),
("findings", Json::array(analysis.findings.map(migration_finding_json))),
])
}
///|
/// Render a project-level migration analysis as stable JSON.
pub fn migration_analysis_to_json(analysis : MigrationAnalysis) -> String {
migration_analysis_json(analysis).stringify(indent=2)
}
///|
/// Render a migration analysis for terminal review.
pub fn migration_analysis_to_text(analysis : MigrationAnalysis) -> String {
let builder = StringBuilder()
builder.write_string("SQLSentinel migration plan\n")
builder.write_string(
"Model: bounded semantic · confidence: conservative · see --capabilities\n",
)
builder.write_string(
"Tables: \{analysis.tables_before.length()} -> \{analysis.tables_after.length()} Changes: \{analysis.changes.length()} Breaking: \{analysis.breaking_changes} Errors: \{analysis.error_count} Warnings: \{analysis.warning_count}\n",
)
builder.write_string(
"Coverage: \{analysis.coverage.analyzed_count}/\{analysis.coverage.statement_count} statements analyzed, \{analysis.coverage.ignored_count} ignored.\n",
)
for trace in analysis.coverage.traces {
if trace.status == Ignored {
builder.write_string(
" ignored \{trace.kind} \{trace.path}:\{trace.line} \{trace.reason}\n",
)
}
}
if !analysis.affected_tables.is_empty() {
builder.write_string(
"Affected tables: \{analysis.affected_tables.join(", ")}\n",
)
}
for change in analysis.changes {
let target = if change.column_name.is_empty() {
change.table_name
} else {
"\{change.table_name}.\{change.column_name}"
}
builder.write_string(
"\n\{change.kind.label()} \{target} \{change.detail}\n \{change.path}:\{change.line}\n",
)
}
if analysis.findings.is_empty() {
builder.write_string("\nPASS No migration-plan findings.\n")
} else {
for entry in analysis.findings {
let finding = entry.finding
builder.write_string(
"\n\{entry.path}:\{finding.line}:\{finding.column} \{finding.severity.label().to_upper()} \{finding.rule_id} \{finding.title}\n \{finding.message}\n Fix: \{finding.suggestion}\n",
)
}
}
builder.to_string()
}
///|
/// Render a migration analysis as a Markdown review document.
pub fn migration_analysis_to_markdown(analysis : MigrationAnalysis) -> String {
let builder = StringBuilder()
builder.write_string("# SQLSentinel migration plan\n\n")
builder.write_string(
"Analysis model: `bounded_semantic` · confidence: `conservative` · run `sqlsentinel --capabilities` for coverage.\n\n",
)
builder.write_string(
"Tables: **\{analysis.tables_before.length()} -> \{analysis.tables_after.length()}** · Changes: **\{analysis.changes.length()}** · Breaking: **\{analysis.breaking_changes}** · Errors: **\{analysis.error_count}** · Warnings: **\{analysis.warning_count}**\n\n",
)
if !analysis.affected_tables.is_empty() {
builder.write_string(
"Affected tables: \{analysis.affected_tables.map(table => "`\{table}`").join(", ")}\n\n",
)
}
builder.write_string(
"Coverage: **\{analysis.coverage.analyzed_count}/\{analysis.coverage.statement_count}** statements analyzed; **\{analysis.coverage.ignored_count}** ignored.\n\n",
)
if !analysis.coverage.is_complete() {
builder.write_string("### Not modeled\n\n")
builder.write_string("| Location | Kind | Reason |\n")
builder.write_string("| --- | --- | --- |\n")
for trace in analysis.coverage.traces {
if trace.status == Ignored {
builder.write_string(
"| \{trace.path}:\{trace.line} | \{trace.kind} | \{markdown_cell(trace.reason)} |\n",
)
}
}
builder.write_string("\n")
}
builder.write_string("## Schema changes\n\n")
builder.write_string("| Kind | Target | Detail | Location |\n")
builder.write_string("| --- | --- | --- | --- |\n")
for change in analysis.changes {
let target = if change.column_name.is_empty() {
change.table_name
} else {
"\{change.table_name}.\{change.column_name}"
}
builder.write_string(
"| \{change.kind.label()} | \{target} | \{markdown_cell(change.detail)} | \{change.path}:\{change.line} |\n",
)
}
builder.write_string("\n## Findings\n\n")
if analysis.findings.is_empty() {
builder.write_string("No migration-plan findings.\n")
} else {
for entry in analysis.findings {
let finding = entry.finding
builder.write_string(
"### \{finding.rule_id} · \{finding.title}\n\n- **Location:** \{entry.path}:\{finding.line}:\{finding.column}\n- **Risk:** \{finding.message}\n- **Evidence:** `\{finding.evidence.replace_all(old="`", new="'")}`\n- **Suggested action:** \{finding.suggestion}\n\n",
)
}
}
builder.to_string()
}
///|
fn query_reference_json(reference : QueryReference) -> Json {
json_object([
("change_kind", json_string(reference.change_kind.label())),
("table", json_string(reference.table_name)),
("column", json_string(reference.column_name)),
("path", json_string(reference.path)),
("line", json_int(reference.line)),
("statement", json_int(reference.statement_index)),
("evidence", json_string(reference.evidence)),
])
}
///|
/// Render cross-migration query impact as stable JSON.
fn impact_analysis_json(analysis : ImpactAnalysis) -> Json {
json_object([
("schema_version", json_string("1.0")),
("tool", json_string("SQLSentinel impact analysis")),
("analysis_model", analysis_model_json()),
(
"summary",
json_object([
("references", json_int(analysis.references.length())),
("impacted_tables", json_int(analysis.impacted_tables.length())),
("impacted_files", json_int(analysis.impacted_files.length())),
("errors", json_int(analysis.error_count)),
("warnings", json_int(analysis.warning_count)),
("infos", json_int(analysis.info_count)),
(
"migration_statements",
json_int(analysis.migration_coverage.statement_count),
),
(
"ignored_statements",
json_int(analysis.migration_coverage.ignored_count),
),
]),
),
("migration_coverage", migration_coverage_json(analysis.migration_coverage)),
(
"impacted",
json_object([
("tables", Json::array(analysis.impacted_tables.map(json_string))),
("files", Json::array(analysis.impacted_files.map(json_string))),
]),
),
("references", Json::array(analysis.references.map(query_reference_json))),
("findings", Json::array(analysis.findings.map(migration_finding_json))),
])
}
///|
/// Render cross-migration query impact as stable JSON.
pub fn impact_analysis_to_json(analysis : ImpactAnalysis) -> String {
impact_analysis_json(analysis).stringify(indent=2)
}
///|
/// Render query impact for terminal review.
pub fn impact_analysis_to_text(analysis : ImpactAnalysis) -> String {
let builder = StringBuilder()
builder.write_string("SQLSentinel impact analysis\n")
builder.write_string(
"Model: bounded semantic · confidence: conservative · see --capabilities\n",
)
builder.write_string(
"References: \{analysis.references.length()} Impacted tables: \{analysis.impacted_tables.length()} Impacted files: \{analysis.impacted_files.length()} Errors: \{analysis.error_count} Warnings: \{analysis.warning_count}\n",
)
builder.write_string(
"Migration coverage: \{analysis.migration_coverage.analyzed_count}/\{analysis.migration_coverage.statement_count} analyzed, \{analysis.migration_coverage.ignored_count} ignored.\n",
)
if !analysis.impacted_tables.is_empty() {
builder.write_string("Tables: \{analysis.impacted_tables.join(", ")}\n")
}
for reference in analysis.references {
let target = if reference.column_name.is_empty() {
reference.table_name
} else {
"\{reference.table_name}.\{reference.column_name}"
}
builder.write_string(
"\n\{reference.path}:\{reference.line} \{reference.change_kind.label()} \{target}\n \{reference.evidence}\n",
)
}
if analysis.findings.is_empty() {
builder.write_string("\nPASS No downstream query impact found.\n")
} else {
for entry in analysis.findings {
let finding = entry.finding
builder.write_string(
"\n\{entry.path}:\{finding.line}:\{finding.column} \{finding.severity.label().to_upper()} \{finding.rule_id} \{finding.message}\n",
)
}
}
builder.to_string()
}
///|
/// Render query impact as Markdown.
pub fn impact_analysis_to_markdown(analysis : ImpactAnalysis) -> String {
let builder = StringBuilder()
builder.write_string("# SQLSentinel change impact\n\n")
builder.write_string(
"Analysis model: `bounded_semantic` · confidence: `conservative`.\n\n",
)
builder.write_string(
"References: **\{analysis.references.length()}** · Impacted tables: **\{analysis.impacted_tables.length()}** · Impacted files: **\{analysis.impacted_files.length()}** · Errors: **\{analysis.error_count}** · Warnings: **\{analysis.warning_count}**\n\n",
)
if !analysis.impacted_tables.is_empty() {
builder.write_string(
"Impacted tables: \{analysis.impacted_tables.map(table => "`\{table}`").join(", ")}\n\n",
)
}
builder.write_string(
"Migration coverage: **\{analysis.migration_coverage.analyzed_count}/\{analysis.migration_coverage.statement_count}** analyzed; **\{analysis.migration_coverage.ignored_count}** ignored.\n\n",
)
builder.write_string("| Query | Change | Target | Evidence |\n")
builder.write_string("| --- | --- | --- | --- |\n")
for reference in analysis.references {
let target = if reference.column_name.is_empty() {
reference.table_name
} else {
"\{reference.table_name}.\{reference.column_name}"
}
builder.write_string(
"| \{reference.path}:\{reference.line} | \{reference.change_kind.label()} | \{target} | `\{reference.evidence.replace_all(old="`", new="'")}` |\n",
)
}
builder.write_string("\n## Findings\n\n")
if analysis.findings.is_empty() {
builder.write_string("No downstream query impact found.\n")
} else {
for entry in analysis.findings {
let finding = entry.finding
builder.write_string(
"- **\{finding.severity.label()} \{finding.rule_id}** \{entry.path}:\{finding.line} — \{finding.message}\n",
)
}
}
builder.to_string()
}
///|
/// Render the rule catalog as a Markdown reference.
pub fn rule_catalog_markdown() -> String {
let builder = StringBuilder()
builder.write_string("# SQLSentinel rules\n\n")
builder.write_string(
"| ID | Default severity | Rule | Rationale | Remediation |\n",
)
builder.write_string("| --- | --- | --- | --- | --- |\n")
for rule in rule_catalog() {
builder.write_string(
"| \{rule.id} | \{rule.severity.label()} | \{markdown_cell(rule.title)} | \{markdown_cell(rule.rationale)} | \{markdown_cell(rule.remediation)} |\n",
)
}
builder.to_string()
}