schemas/base.py

"""
Base utilities for schema definitions.

Provides common functionality for transforming and validating data
across different entity types.
"""

import json
from typing import Any, Dict, Set
from dataclasses import dataclass


@dataclass
class SchemaDefinition:
    """
    Base schema definition for an entity type.

    Attributes:
        table_name: Name of the database table
        schema: Dict mapping field names to SQL types
        field_order: List of fields in order for INSERT statements
        nested_fields: Set of field names that contain nested/complex data
    """
    table_name: str
    schema: Dict[str, str]
    field_order: list[str]
    nested_fields: Set[str]

    def get_create_table_sql(self) -> str:
        """Generate CREATE TABLE SQL statement."""
        columns = [f"{field} {field_type}" for field, field_type in self.schema.items()]
        return f"""
            CREATE TABLE IF NOT EXISTS {self.table_name} (
                {', '.join(columns)}
            )
        """

    def get_insert_sql(self) -> str:
        """Generate INSERT SQL statement."""
        placeholders = ', '.join(['?' for _ in self.field_order])
        return f"""
            INSERT INTO {self.table_name} ({', '.join(self.field_order)})
            VALUES ({placeholders})
            ON CONFLICT (id) DO NOTHING
        """


def transform_value(field_name: str, value: Any, nested_fields: Set[str]) -> Any:
    """
    Transform a field value for database storage.

    Handles nested objects, arrays, and type conversions.

    Args:
        field_name: Name of the field being transformed
        value: The value to transform
        nested_fields: Set of field names that should be stored as JSON

    Returns:
        Transformed value ready for database insertion
    """
    if value is None:
        return None

    # Check if this field should be stored as JSON
    if field_name in nested_fields:
        if isinstance(value, (dict, list)):
            return json.dumps(value)
        elif isinstance(value, str):
            # Already a string, assume it's valid JSON or plain text
            return value
        else:
            # Convert other types to JSON
            return json.dumps(value)

    # Handle non-nested complex types that shouldn't be in the data
    if isinstance(value, (dict, list)):
        # Warn: this field has nested data but isn't marked as nested_fields
        # Store as JSON anyway to avoid data loss
        return json.dumps(value)

    # Return primitive types as-is
    return value