Newer
Older
gnexus-book / server / app / storage / parity.py
from __future__ import annotations

import json
from typing import Any

from ..config import Settings
from ..docs_repository import DocsRepository
from ..inventory import InventoryRepository
from .db import Database
from .db_repositories import PostgresDocsRepository, PostgresInventoryRepository
from .importer import normalize_scalars

DEFAULT_QUERIES = ("gnexus", "host", "GitBucket")


def _canonical(value: Any) -> str:
    return json.dumps(normalize_scalars(value), sort_keys=True, ensure_ascii=False, default=str)


def _preview(value: Any, limit: int = 400) -> Any:
    text = _canonical(value)
    if len(text) <= limit:
        return value
    return text[:limit] + "..."


def _difference(kind: str, key: str, file_value: Any, db_value: Any) -> dict[str, Any]:
    return {
        "kind": kind,
        "key": key,
        "file": _preview(file_value),
        "db": _preview(db_value),
    }


def compare_repositories(
    settings: Settings,
    database: Database,
    queries: list[str] | None = None,
) -> dict[str, Any]:
    file_settings = Settings(repo_root=settings.repo_root, storage_backend="file")
    file_docs = DocsRepository(file_settings)
    db_docs = PostgresDocsRepository(database)
    file_inventory = InventoryRepository(file_settings)
    db_inventory = PostgresInventoryRepository(database)

    differences: list[dict[str, Any]] = []

    file_doc_list = file_docs.list_docs()
    db_doc_list = db_docs.list_docs()
    if _canonical(file_doc_list) != _canonical(db_doc_list):
        differences.append(
            _difference("docs.list", "all", file_doc_list, db_doc_list)
        )

    file_paths = [str(doc["path"]) for doc in file_doc_list]
    db_paths = [str(doc["path"]) for doc in db_doc_list]
    if file_paths != db_paths:
        differences.append(
            _difference("docs.paths", "all", file_paths, db_paths)
        )

    for path in sorted(set(file_paths) & set(db_paths)):
        file_doc = file_docs.read_doc(path)
        db_doc = db_docs.read_doc(path)
        for field in ("path", "frontmatter", "body", "raw"):
            if _canonical(file_doc.get(field)) != _canonical(db_doc.get(field)):
                differences.append(
                    _difference(f"docs.read.{field}", path, file_doc.get(field), db_doc.get(field))
                )

    for query in queries or list(DEFAULT_QUERIES):
        file_results = file_docs.search(query)
        db_results = db_docs.search(query)
        if _canonical(file_results) != _canonical(db_results):
            differences.append(
                _difference("docs.search", query, file_results, db_results)
            )

    file_types = file_inventory.list_types()
    db_types = db_inventory.list_types()
    if file_types != db_types:
        differences.append(
            _difference("inventory.types", "all", file_types, db_types)
        )

    for type_name in sorted(set(file_types) & set(db_types)):
        file_parsed = normalize_scalars(file_inventory.read_parsed(type_name))
        db_parsed = normalize_scalars(db_inventory.read_parsed(type_name))
        if _canonical(file_parsed) != _canonical(db_parsed):
            differences.append(
                _difference("inventory.parsed", type_name, file_parsed, db_parsed)
            )

        for item in file_parsed if isinstance(file_parsed, list) else []:
            if not isinstance(item, dict):
                continue
            item_id = item.get("id")
            if not isinstance(item_id, str) or not item_id:
                continue
            file_item = file_inventory.read_item(type_name, item_id)
            db_item = db_inventory.read_item(type_name, item_id)
            if _canonical(file_item) != _canonical(db_item):
                differences.append(
                    _difference(
                        "inventory.item",
                        f"{type_name}/{item_id}",
                        file_item,
                        db_item,
                    )
                )

    return {
        "ok": not differences,
        "queries": list(queries or DEFAULT_QUERIES),
        "difference_count": len(differences),
        "differences": differences,
    }