pycharter 0.0.20__py3-none-any.whl → 0.0.22__py3-none-any.whl

api/routes/v1/metadata.py

@@ -2,13 +2,14 @@
 Route handlers for metadata store operations.
 """
 
+from typing import Any, Dict, List
+
 from fastapi import APIRouter, Depends, HTTPException, Query, status
 from sqlalchemy.orm import Session
-from typing import Any, Dict, List
-import uuid
 
 from api.dependencies.database import get_db_session
 from api.dependencies.store import get_metadata_store
+from api.utils import ensure_uuid, get_by_id_or_404, model_to_dict, safe_uuid_to_str
 from api.models.metadata import (
     CoercionRulesStoreRequest,
     MetadataGetRequest,
@@ -599,160 +600,6 @@ async def get_complete_schema(
     )
 
 
-# Helper function to convert SQLAlchemy models to dictionaries
-def model_to_dict(model_instance) -> dict:
-    """Convert SQLAlchemy model instance to dictionary."""
-    if model_instance is None:
-        return {}
-    
-    result = {}
-    for column in model_instance.__table__.columns:
-        value = getattr(model_instance, column.name, None)
-        if value is None:
-            result[column.name] = None
-        # Convert UUID to string
-        elif hasattr(value, 'hex'):
-            result[column.name] = str(value)
-        # Convert datetime to ISO format string
-        elif hasattr(value, 'isoformat'):
-            result[column.name] = value.isoformat()
-        # Keep JSON fields as-is
-        elif isinstance(value, (dict, list)):
-            result[column.name] = value
-        else:
-            result[column.name] = value
-    return result
-
-
-@router.get(
-    "/metadata/owners",
-    status_code=status.HTTP_200_OK,
-    summary="List all owners",
-    description="Retrieve a list of all owners from the database",
-    response_description="List of owners",
-)
-async def list_owners(
-    db: Session = Depends(get_db_session),
-) -> list[dict]:
-    """
-    List all owners in the database.
-    
-    Returns:
-        List of owner dictionaries
-    """
-    owners = db.query(OwnerModel).all()
-    return [model_to_dict(owner) for owner in owners]
-
-
-@router.get(
-    "/metadata/domains",
-    status_code=status.HTTP_200_OK,
-    summary="List all domains",
-    description="Retrieve a list of all domains from the database",
-    response_description="List of domains",
-)
-async def list_domains(
-    db: Session = Depends(get_db_session),
-) -> list[dict]:
-    """
-    List all domains in the database.
-    
-    Returns:
-        List of domain dictionaries
-    """
-    domains = db.query(DomainModel).all()
-    return [model_to_dict(domain) for domain in domains]
-
-
-@router.get(
-    "/metadata/systems",
-    status_code=status.HTTP_200_OK,
-    summary="List all systems",
-    description="Retrieve a list of all systems from the database",
-    response_description="List of systems",
-)
-async def list_systems(
-    db: Session = Depends(get_db_session),
-) -> list[dict]:
-    """
-    List all systems in the database.
-    
-    Returns:
-        List of system dictionaries
-    """
-    systems = db.query(SystemModel).all()
-    return [model_to_dict(system) for system in systems]
-
-
-@router.get(
-    "/metadata/environments",
-    status_code=status.HTTP_200_OK,
-    summary="List all environments",
-    description="Retrieve a list of all environments from the database",
-    response_description="List of environments",
-)
-async def list_environments(
-    db: Session = Depends(get_db_session),
-) -> list[dict]:
-    """
-    List all environments in the database.
-    
-    Returns:
-        List of environment dictionaries
-    """
-    environments = db.query(EnvironmentModel).all()
-    return [model_to_dict(env) for env in environments]
-
-
-@router.get(
-    "/metadata/storage_locations",
-    status_code=status.HTTP_200_OK,
-    summary="List all storage locations",
-    description="Retrieve a list of all storage locations from the database",
-    response_description="List of storage locations",
-)
-async def list_storage_locations(
-    db: Session = Depends(get_db_session),
-) -> list[dict]:
-    """
-    List all storage locations in the database.
-    
-    Returns:
-        List of storage location dictionaries
-    """
-    storage_locations = db.query(StorageLocationModel).all()
-    result = []
-    for sl in storage_locations:
-        data = model_to_dict(sl)
-        # Include related system and environment names if available
-        if sl.system:
-            data['system_name'] = sl.system.name
-        if sl.environment:
-            data['environment_name'] = sl.environment.name
-        result.append(data)
-    return result
-
-
-@router.get(
-    "/metadata/tags",
-    status_code=status.HTTP_200_OK,
-    summary="List all tags",
-    description="Retrieve a list of all tags from the database",
-    response_description="List of tags",
-)
-async def list_tags(
-    db: Session = Depends(get_db_session),
-) -> list[dict]:
-    """
-    List all tags in the database.
-    
-    Returns:
-        List of tag dictionaries
-    """
-    tags = db.query(TagModel).all()
-    return [model_to_dict(tag) for tag in tags]
-
-
 @router.get(
     "/metadata/{entity_type}",
     status_code=status.HTTP_200_OK,
@@ -763,7 +610,7 @@ async def list_tags(
 async def list_metadata_entities(
     entity_type: str,
     db: Session = Depends(get_db_session),
-) -> list[dict]:
+) -> List[Dict[str, Any]]:
     """
     List metadata entities by type.
     
@@ -818,7 +665,7 @@ async def list_metadata_entities(
     return [model_to_dict(entity) for entity in entities]
 
 
-# Create endpoints
+# Create endpoints (POST routes for creating entities)
 @router.post(
     "/metadata/owners",
     status_code=status.HTTP_201_CREATED,
@@ -829,7 +676,7 @@ async def list_metadata_entities(
 async def create_owner(
     request: OwnerCreateRequest,
     db: Session = Depends(get_db_session),
-) -> dict:
+) -> Dict[str, Any]:
     """Create a new owner."""
     # Check if owner already exists
     existing = db.query(OwnerModel).filter(OwnerModel.id == request.id).first()
@@ -862,7 +709,7 @@ async def create_owner(
 async def create_domain(
     request: DomainCreateRequest,
     db: Session = Depends(get_db_session),
-) -> dict:
+) -> Dict[str, Any]:
     """Create a new domain."""
     # Check if domain already exists
     existing = db.query(DomainModel).filter(DomainModel.name == request.name).first()
@@ -892,7 +739,7 @@ async def create_domain(
 async def create_system(
     request: SystemCreateRequest,
     db: Session = Depends(get_db_session),
-) -> dict:
+) -> Dict[str, Any]:
     """Create a new system."""
     # Check if system already exists
     existing = db.query(SystemModel).filter(SystemModel.name == request.name).first()
@@ -923,7 +770,7 @@ async def create_system(
 async def create_environment(
     request: EnvironmentCreateRequest,
     db: Session = Depends(get_db_session),
-) -> dict:
+) -> Dict[str, Any]:
     """Create a new environment."""
     # Check if environment already exists
     existing = db.query(EnvironmentModel).filter(EnvironmentModel.name == request.name).first()
@@ -956,7 +803,7 @@ async def create_environment(
 async def create_storage_location(
     request: StorageLocationCreateRequest,
     db: Session = Depends(get_db_session),
-) -> dict:
+) -> Dict[str, Any]:
     """Create a new storage location."""
     # Check if storage location already exists
     existing = db.query(StorageLocationModel).filter(StorageLocationModel.name == request.name).first()
@@ -1002,7 +849,7 @@ async def create_storage_location(
 async def create_tag(
     request: TagCreateRequest,
     db: Session = Depends(get_db_session),
-) -> dict:
+) -> Dict[str, Any]:
     """Create a new tag."""
     # Check if tag already exists
     existing = db.query(TagModel).filter(TagModel.name == request.name).first()
@@ -1037,14 +884,13 @@ async def update_owner(
     owner_id: str,
     request: OwnerUpdateRequest,
     db: Session = Depends(get_db_session),
-) -> dict:
+) -> Dict[str, Any]:
     """Update an existing owner."""
-    owner = db.query(OwnerModel).filter(OwnerModel.id == owner_id).first()
-    if not owner:
-        raise HTTPException(
-            status_code=status.HTTP_404_NOT_FOUND,
-            detail=f"Owner with ID '{owner_id}' not found",
-        )
+    owner = get_by_id_or_404(
+        db, OwnerModel, owner_id,
+        error_message=f"Owner with ID '{owner_id}' not found",
+        model_name="Owner"
+    )
     
     if request.name is not None:
         owner.name = request.name
@@ -1071,22 +917,21 @@ async def update_domain(
     domain_id: str,
     request: DomainUpdateRequest,
     db: Session = Depends(get_db_session),
-) -> dict:
+) -> Dict[str, Any]:
     """Update an existing domain."""
     try:
-        domain_uuid = uuid.UUID(domain_id)
+        ensure_uuid(domain_id)
     except ValueError:
         raise HTTPException(
             status_code=status.HTTP_400_BAD_REQUEST,
             detail=f"Invalid domain ID format: {domain_id}",
         )
     
-    domain = db.query(DomainModel).filter(DomainModel.id == domain_uuid).first()
-    if not domain:
-        raise HTTPException(
-            status_code=status.HTTP_404_NOT_FOUND,
-            detail=f"Domain with ID '{domain_id}' not found",
-        )
+    domain = get_by_id_or_404(
+        db, DomainModel, domain_id,
+        error_message=f"Domain with ID '{domain_id}' not found",
+        model_name="Domain"
+    )
     
     if request.name is not None:
         domain.name = request.name
@@ -1109,22 +954,21 @@ async def update_system(
     system_id: str,
     request: SystemUpdateRequest,
     db: Session = Depends(get_db_session),
-) -> dict:
+) -> Dict[str, Any]:
     """Update an existing system."""
     try:
-        system_uuid = uuid.UUID(system_id)
+        ensure_uuid(system_id)
     except ValueError:
         raise HTTPException(
             status_code=status.HTTP_400_BAD_REQUEST,
             detail=f"Invalid system ID format: {system_id}",
         )
     
-    system = db.query(SystemModel).filter(SystemModel.id == system_uuid).first()
-    if not system:
-        raise HTTPException(
-            status_code=status.HTTP_404_NOT_FOUND,
-            detail=f"System with ID '{system_id}' not found",
-        )
+    system = get_by_id_or_404(
+        db, SystemModel, system_id,
+        error_message=f"System with ID '{system_id}' not found",
+        model_name="System"
+    )
     
     if request.name is not None:
         system.name = request.name
@@ -1149,22 +993,21 @@ async def update_environment(
     environment_id: str,
     request: EnvironmentUpdateRequest,
     db: Session = Depends(get_db_session),
-) -> dict:
+) -> Dict[str, Any]:
     """Update an existing environment."""
     try:
-        env_uuid = uuid.UUID(environment_id)
+        ensure_uuid(environment_id)
     except ValueError:
         raise HTTPException(
             status_code=status.HTTP_400_BAD_REQUEST,
             detail=f"Invalid environment ID format: {environment_id}",
         )
     
-    environment = db.query(EnvironmentModel).filter(EnvironmentModel.id == env_uuid).first()
-    if not environment:
-        raise HTTPException(
-            status_code=status.HTTP_404_NOT_FOUND,
-            detail=f"Environment with ID '{environment_id}' not found",
-        )
+    environment = get_by_id_or_404(
+        db, EnvironmentModel, environment_id,
+        error_message=f"Environment with ID '{environment_id}' not found",
+        model_name="Environment"
+    )
     
     if request.name is not None:
         environment.name = request.name
@@ -1193,22 +1036,21 @@ async def update_storage_location(
     storage_location_id: str,
     request: StorageLocationUpdateRequest,
     db: Session = Depends(get_db_session),
-) -> dict:
+) -> Dict[str, Any]:
     """Update an existing storage location."""
     try:
-        sl_uuid = uuid.UUID(storage_location_id)
+        ensure_uuid(storage_location_id)
     except ValueError:
         raise HTTPException(
             status_code=status.HTTP_400_BAD_REQUEST,
             detail=f"Invalid storage location ID format: {storage_location_id}",
         )
     
-    storage_location = db.query(StorageLocationModel).filter(StorageLocationModel.id == sl_uuid).first()
-    if not storage_location:
-        raise HTTPException(
-            status_code=status.HTTP_404_NOT_FOUND,
-            detail=f"Storage location with ID '{storage_location_id}' not found",
-        )
+    storage_location = get_by_id_or_404(
+        db, StorageLocationModel, storage_location_id,
+        error_message=f"Storage location with ID '{storage_location_id}' not found",
+        model_name="StorageLocation"
+    )
     
     if request.name is not None:
         storage_location.name = request.name
@@ -1256,22 +1098,21 @@ async def update_tag(
     tag_id: str,
     request: TagUpdateRequest,
     db: Session = Depends(get_db_session),
-) -> dict:
+) -> Dict[str, Any]:
     """Update an existing tag."""
     try:
-        tag_uuid = uuid.UUID(tag_id)
+        ensure_uuid(tag_id)
     except ValueError:
         raise HTTPException(
             status_code=status.HTTP_400_BAD_REQUEST,
             detail=f"Invalid tag ID format: {tag_id}",
         )
     
-    tag = db.query(TagModel).filter(TagModel.id == tag_uuid).first()
-    if not tag:
-        raise HTTPException(
-            status_code=status.HTTP_404_NOT_FOUND,
-            detail=f"Tag with ID '{tag_id}' not found",
-        )
+    tag = get_by_id_or_404(
+        db, TagModel, tag_id,
+        error_message=f"Tag with ID '{tag_id}' not found",
+        model_name="Tag"
+    )
     
     if request.name is not None:
         tag.name = request.name

api/routes/v1/schemas.py

@@ -47,7 +47,7 @@ async def generate_schema(
     
     return SchemaGenerateResponse(
         model_name=request.model_name,
-        schema_json=schema_json,
+        schema_definition=schema_json,  # Field alias maps to "schema_json" in JSON
         message=f"Model '{request.model_name}' generated successfully",
     )
 

api/routes/v1/settings.py

@@ -2,16 +2,32 @@
 Route handlers for settings and configuration testing.
 """
 
+import os
+from pathlib import Path
 from typing import Optional
-from fastapi import APIRouter, HTTPException, status
+from fastapi import APIRouter, Depends, HTTPException, status
 from pydantic import BaseModel
 import sqlalchemy
 from sqlalchemy import create_engine, text
 from sqlalchemy.exc import SQLAlchemyError
+from sqlalchemy.orm import Session
+
+from pycharter.config import get_database_url
+from api.dependencies.database import get_db_session
 
 router = APIRouter()
 
 
+class DatabaseConfigResponse(BaseModel):
+    """Response model for database configuration info."""
+    configured_url: Optional[str]
+    actual_url: str
+    database_type: str
+    is_default: bool
+    contract_count: int
+    message: str
+
+
 class DatabaseTestRequest(BaseModel):
     connection_string: Optional[str] = None
     host: Optional[str] = None
@@ -58,6 +74,77 @@ class DlqStatsResponse(BaseModel):
     by_status: dict[str, int]
 
 
+@router.get(
+    "/settings/database-config",
+    response_model=DatabaseConfigResponse,
+    status_code=status.HTTP_200_OK,
+    summary="Get current database configuration",
+    description="Get information about the currently configured database connection",
+)
+async def get_database_config(
+    db: Session = Depends(get_db_session),
+) -> DatabaseConfigResponse:
+    """
+    Get current database configuration and connection info.
+    
+    Shows which database is actually being used, which helps diagnose
+    issues where SQLite might be used instead of PostgreSQL.
+    """
+    from pycharter.db.models import DataContractModel
+    
+    configured_url = get_database_url()
+    
+    # Get actual URL from the session
+    actual_url = str(db.bind.url) if hasattr(db, 'bind') and db.bind else "unknown"
+    
+    # Determine database type
+    if actual_url.startswith("sqlite"):
+        database_type = "SQLite"
+        is_default = configured_url is None
+    elif actual_url.startswith(("postgresql", "postgres")):
+        database_type = "PostgreSQL"
+        is_default = False
+    else:
+        database_type = "Unknown"
+        is_default = False
+    
+    # Count contracts in current database
+    try:
+        contract_count = db.query(DataContractModel).count()
+    except Exception:
+        contract_count = -1
+    
+    # Build message
+    if is_default:
+        message = (
+            f"⚠️ No database URL configured. Using default SQLite database.\n"
+            f"To use PostgreSQL, set the PYCHARTER_DATABASE_URL environment variable:\n"
+            f"  export PYCHARTER_DATABASE_URL='postgresql://user:password@localhost:5432/pycharter'"
+        )
+    else:
+        # Mask password in configured URL
+        masked_configured = configured_url
+        if configured_url and "@" in configured_url:
+            parts = configured_url.split("@", 1)
+            if ":" in parts[0] and "://" in parts[0]:
+                scheme_user = parts[0].split("://", 1)[0]
+                user_pass = parts[0].split("://", 1)[1]
+                if ":" in user_pass:
+                    user, _ = user_pass.split(":", 1)
+                    masked_configured = f"{scheme_user}://{user}:****@{parts[1]}"
+        
+        message = f"✓ Using {database_type} database"
+    
+    return DatabaseConfigResponse(
+        configured_url=masked_configured if 'masked_configured' in locals() else configured_url,
+        actual_url=actual_url.split("@")[-1] if "@" in actual_url else actual_url,  # Show only host/db part
+        database_type=database_type,
+        is_default=is_default,
+        contract_count=contract_count,
+        message=message,
+    )
+
+
 def _build_connection_string(
     connection_string: Optional[str] = None,
     host: Optional[str] = None,