from __future__ import annotations
from typing import Any
import yaml
from jsonschema import Draft202012Validator
from jsonschema.exceptions import SchemaError
from sqlalchemy import select
from sqlalchemy.orm import Session
from ..freshness import REQUIRED_FRONTMATTER
from ..validation import (
PRIVATE_KEY_BLOCK_RE,
SAFE_SECRET_REFERENCE_RE,
SECRET_ASSIGNMENT_RE,
)
from .db import Database
from .db_repositories import latest_doc_rows
from .models import InventoryItem, InventoryType, JsonSchema
def _issue(path: str, code: str, message: str) -> dict[str, str]:
return {
"path": path,
"severity": "error",
"code": code,
"message": message,
}
def validate_database(database: Database) -> dict[str, object]:
with database.session() as session:
return validate_session(session)
def validate_session(session: Session) -> dict[str, object]:
issues: list[dict[str, str]] = []
issues.extend(_validate_schemas(session))
issues.extend(_validate_documents(session))
issues.extend(_validate_inventory(session))
return {
"status": "ok" if not issues else "issues",
"issue_count": len(issues),
"issues": issues,
}
def _validate_schemas(session: Session) -> list[dict[str, str]]:
issues: list[dict[str, str]] = []
for schema in session.scalars(select(JsonSchema)).all():
try:
Draft202012Validator.check_schema(schema.body)
except SchemaError as exc:
issues.append(
_issue(f"schemas/{schema.name}", "invalid-json-schema", exc.message)
)
return issues
def _validate_documents(session: Session) -> list[dict[str, str]]:
issues: list[dict[str, str]] = []
for document, version in session.execute(latest_doc_rows(session)).all():
slug = document.slug
frontmatter_required = slug != "README.md" and not slug.startswith("server/")
if frontmatter_required:
frontmatter = version.frontmatter or {}
if not frontmatter:
issues.append(
_issue(
slug,
"missing-frontmatter",
"Markdown document is missing frontmatter",
)
)
else:
missing = sorted(REQUIRED_FRONTMATTER - set(frontmatter))
if missing:
issues.append(
_issue(
slug,
"missing-frontmatter-fields",
"Missing frontmatter fields: " + ", ".join(missing),
)
)
_scan_text(slug, version.raw, issues)
return issues
def _validate_inventory(session: Session) -> list[dict[str, str]]:
issues: list[dict[str, str]] = []
schemas = {schema.id: schema for schema in session.scalars(select(JsonSchema)).all()}
for inventory_type in session.scalars(
select(InventoryType).order_by(InventoryType.name)
).all():
path = f"40-inventory/{inventory_type.name}.yml"
items = session.scalars(
select(InventoryItem)
.where(
InventoryItem.type == inventory_type.name,
InventoryItem.deleted_at.is_(None),
)
.order_by(InventoryItem.position, InventoryItem.item_id)
).all()
data = [dict(item.data or {}) for item in items]
schema = schemas.get(inventory_type.schema_id) if inventory_type.schema_id else None
if schema is not None:
validator = Draft202012Validator(schema.body)
for error in sorted(validator.iter_errors(data), key=lambda item: list(item.path)):
issues.append(
_issue(
path,
"json-schema-validation-error",
f"{_format_json_path(error.path)}: {error.message}",
)
)
for item in items:
text = yaml.safe_dump(item.data or {}, sort_keys=False, allow_unicode=True)
_scan_text(path, text, issues)
return issues
def _scan_text(path: str, text: str, issues: list[dict[str, str]]) -> None:
if PRIVATE_KEY_BLOCK_RE.search(text):
issues.append(
_issue(path, "possible-secret", "File contains a private key block marker")
)
for line_number, line in enumerate(text.splitlines(), start=1):
match = SECRET_ASSIGNMENT_RE.search(line)
if not match:
continue
value = match.group("value").strip().strip("\"'")
if not value or SAFE_SECRET_REFERENCE_RE.search(value):
continue
issues.append(
_issue(
path,
"possible-secret",
f"Possible raw secret assignment at line {line_number}",
)
)
def _format_json_path(path: Any) -> str:
parts = list(path)
if not parts:
return "$"
formatted = "$"
for part in parts:
if isinstance(part, int):
formatted += f"[{part}]"
else:
formatted += f".{part}"
return formatted