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

api/dependencies/__init__.py

@@ -4,6 +4,7 @@ Dependencies for API routes.
 This module provides FastAPI dependency injection for shared resources.
 """
 
+from api.dependencies.database import get_db_session
 from api.dependencies.store import get_metadata_store
 
-__all__ = ["get_metadata_store"]
+__all__ = ["get_db_session", "get_metadata_store"]

api/dependencies/database.py

@@ -4,7 +4,7 @@ Database session dependency for API routes.
 
 import os
 from pathlib import Path
-from typing import Optional
+from typing import Generator, Optional
 
 from fastapi import Depends, HTTPException, status
 from sqlalchemy import create_engine, inspect
@@ -99,36 +99,102 @@ def _ensure_sqlite_initialized(db_url: str) -> None:
         logger.warning(f"Could not auto-initialize SQLite database: {e}")
 
 
-def get_db_session() -> Session:
+def get_db_session() -> Generator[Session, None, None]:
     """
     FastAPI dependency to get database session.
     
     Defaults to SQLite (sqlite:///pycharter.db) if no database URL is configured.
     Automatically initializes SQLite database if it doesn't exist or is uninitialized.
     
-    Returns:
+    **Important**: This dependency properly manages session lifecycle using yield,
+    ensuring sessions are closed after request completion.
+    
+    Yields:
         SQLAlchemy session
         
     Raises:
         HTTPException: If database connection fails
     """
+    import logging
+    
+    logger = logging.getLogger(__name__)
+    
     db_url = get_database_url()
     
     # Default to SQLite if no database URL is configured
     if not db_url:
         default_db_path = Path.cwd() / "pycharter.db"
         db_url = f"sqlite:///{default_db_path}"
+        logger.warning(
+            f"No database URL configured. Using default SQLite: {db_url}\n"
+            f"To use PostgreSQL, set PYCHARTER_DATABASE_URL environment variable:\n"
+            f"  export PYCHARTER_DATABASE_URL='postgresql://user:password@localhost:5432/pycharter'"
+        )
+    else:
+        # Mask password in logs
+        masked_url = db_url
+        if "@" in db_url and "://" in db_url:
+            parts = db_url.split("@", 1)
+            if ":" in parts[0]:
+                user_pass = parts[0].split("://", 1)[1]
+                if ":" in user_pass:
+                    user, _ = user_pass.split(":", 1)
+                    masked_url = db_url.split(":", 2)[0] + "://" + user + ":****@" + parts[1]
+        logger.info(f"Using database: {masked_url}")
     
     # Auto-initialize SQLite if needed
     _ensure_sqlite_initialized(db_url)
     
+    session = None
     try:
         session = get_session(db_url)
-        return session
+        # Test the connection by executing a simple query
+        from sqlalchemy import text
+        session.execute(text("SELECT 1"))
+        yield session
     except Exception as e:
+        if session:
+            try:
+                session.rollback()
+            except Exception:
+                pass
+        logger.error(f"Database session error: {e}", exc_info=True)
+        
+        # Provide more helpful error messages
+        error_detail = "Failed to connect to database"
+        error_msg = str(e).lower()
+        
+        # Check for common issues
+        if "no such table" in error_msg or "table" in error_msg and "doesn't exist" in error_msg:
+            error_detail = (
+                "Database tables not found. Please initialize the database:\n"
+                f"  pycharter db init {db_url}"
+            )
+        elif "database is locked" in error_msg:
+            error_detail = (
+                "Database is locked. Another process may be using it.\n"
+                "Close other connections or wait a moment and try again."
+            )
+        elif "permission denied" in error_msg or "access denied" in error_msg:
+            error_detail = (
+                "Database permission denied. Check file permissions:\n"
+                f"  chmod 644 {db_url.split(':///')[-1] if 'sqlite' in db_url else 'database file'}"
+            )
+        else:
+            # Show detailed error in development mode
+            is_development = os.getenv("ENVIRONMENT") == "development" or not os.getenv("ENVIRONMENT")
+            if is_development:
+                error_detail = f"Failed to connect to database: {str(e)}"
+        
         raise HTTPException(
             status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-            detail=f"Failed to connect to database: {str(e)}",
+            detail=error_detail,
         )
+    finally:
+        if session:
+            try:
+                session.close()
+            except Exception:
+                pass
 
 

api/main.py

@@ -59,11 +59,35 @@ def create_application() -> FastAPI:
     )
     
     # Add CORS middleware
+    import os
+    # Get CORS origins from environment variable
+    cors_origins_env = os.getenv("CORS_ORIGINS", "").strip()
+    cors_origins = [origin.strip() for origin in cors_origins_env.split(",") if origin.strip()] if cors_origins_env else []
+    
+    # Default behavior: In development (or when ENVIRONMENT not set), allow localhost origins
+    # This makes development easier without requiring environment variables
+    is_development = os.getenv("ENVIRONMENT") == "development"
+    is_production = os.getenv("ENVIRONMENT") == "production"
+    
+    # If no explicit CORS origins set and not in production, allow localhost for development
+    if not cors_origins and not is_production:
+        cors_origins = [
+            "http://localhost:3000",
+            "http://localhost:3001",
+            "http://127.0.0.1:3000",
+            "http://127.0.0.1:3001",
+        ]
+    
+    # Configure CORS middleware
+    # Note: Can't use allow_credentials=True with allow_origins=["*"]
+    # So we use specific origins for development, or "*" without credentials for production
+    use_credentials = bool(cors_origins and "*" not in cors_origins)
+    
     app.add_middleware(
         CORSMiddleware,
-        allow_origins=["*"],  # Configure appropriately for production
-        allow_credentials=True,
-        allow_methods=["*"],
+        allow_origins=cors_origins if cors_origins else ["*"],  # Fallback to "*" if explicitly empty
+        allow_credentials=use_credentials,
+        allow_methods=["GET", "POST", "PUT", "DELETE", "PATCH", "OPTIONS"],
         allow_headers=["*"],
     )
     
@@ -179,13 +203,28 @@ def create_application() -> FastAPI:
     @app.exception_handler(Exception)
     async def global_exception_handler(request: Request, exc: Exception) -> JSONResponse:
         """Global exception handler for unhandled errors."""
-        return JSONResponse(
-            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-            content={
-                "error": "Internal server error",
+        import logging
+        import os
+        
+        logger = logging.getLogger(__name__)
+        logger.error(f"Unhandled exception: {exc}", exc_info=True)
+        
+        # In production, don't expose internal error details
+        is_development = os.getenv("ENVIRONMENT") == "development"
+        
+        error_detail = {
+            "error": "Internal server error",
+        }
+        
+        if is_development:
+            error_detail.update({
                 "message": str(exc),
                 "type": type(exc).__name__,
-            },
+            })
+        
+        return JSONResponse(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            content=error_detail,
         )
     
     # Override openapi() method to handle schema generation errors gracefully

api/models/contracts.py

@@ -4,7 +4,7 @@ Request/Response models for contract endpoints.
 
 from typing import Any, Dict, List, Optional
 
-from pydantic import BaseModel, Field, field_validator, model_validator
+from pydantic import BaseModel, ConfigDict, Field, field_validator, model_validator
 
 from pycharter.shared.name_validator import validate_name
 
@@ -37,7 +37,7 @@ class ContractParseRequest(BaseModel):
 class ContractParseResponse(BaseModel):
     """Response model for parsed contract."""
     
-    schema: Dict[str, Any] = Field(..., description="JSON Schema definition")
+    schema: Dict[str, Any] = Field(..., description="JSON Schema definition", alias="schema")
     metadata: Optional[Dict[str, Any]] = Field(None, description="Metadata information")
     ownership: Optional[Dict[str, Any]] = Field(None, description="Ownership information")
     governance_rules: Optional[Dict[str, Any]] = Field(None, description="Governance rules")
@@ -45,8 +45,9 @@ class ContractParseResponse(BaseModel):
     validation_rules: Optional[Dict[str, Any]] = Field(None, description="Validation rules")
     versions: Optional[Dict[str, str]] = Field(None, description="Component versions")
     
-    class Config:
-        json_schema_extra = {
+    model_config = ConfigDict(
+        populate_by_name=True,
+        json_schema_extra={
             "example": {
                 "schema": {
                     "type": "object",
@@ -65,6 +66,7 @@ class ContractParseResponse(BaseModel):
                 }
             }
         }
+    )
 
 
 class ContractBuildRequest(BaseModel):

api/models/metadata.py

@@ -4,7 +4,7 @@ Request/Response models for metadata store endpoints.
 
 from typing import Any, Dict, List, Optional
 
-from pydantic import BaseModel, Field, field_validator
+from pydantic import BaseModel, ConfigDict, Field, field_validator
 
 from pycharter.shared.name_validator import validate_name
 
@@ -13,7 +13,7 @@ class SchemaStoreRequest(BaseModel):
     """Request model for storing a schema."""
     
     schema_name: str = Field(..., description="Schema name/identifier")
-    schema: Dict[str, Any] = Field(..., description="JSON Schema definition")
+    schema: Dict[str, Any] = Field(..., description="JSON Schema definition", alias="schema")
     version: str = Field(..., description="Schema version")
     
     @field_validator('schema_name')
@@ -30,8 +30,9 @@ class SchemaStoreRequest(BaseModel):
             v['title'] = validate_name(str(v['title']), field_name="schema.title")
         return v
     
-    class Config:
-        json_schema_extra = {
+    model_config = ConfigDict(
+        populate_by_name=True,
+        json_schema_extra={
             "example": {
                 "schema_name": "user_schema",
                 "schema": {
@@ -44,6 +45,7 @@ class SchemaStoreRequest(BaseModel):
                 "version": "1.0.0"
             }
         }
+    )
 
 
 class SchemaStoreResponse(BaseModel):
@@ -81,11 +83,12 @@ class SchemaGetRequest(BaseModel):
 class SchemaGetResponse(BaseModel):
     """Response model for retrieved schema."""
     
-    schema: Dict[str, Any] = Field(..., description="JSON Schema definition")
+    schema: Dict[str, Any] = Field(..., description="JSON Schema definition", alias="schema")
     version: Optional[str] = Field(None, description="Schema version")
     
-    class Config:
-        json_schema_extra = {
+    model_config = ConfigDict(
+        populate_by_name=True,
+        json_schema_extra={
             "example": {
                 "schema": {
                     "type": "object",
@@ -97,6 +100,7 @@ class SchemaGetResponse(BaseModel):
                 "version": "1.0.0"
             }
         }
+    )
 
 
 class MetadataStoreRequest(BaseModel):

api/models/schemas.py

@@ -4,17 +4,18 @@ Request/Response models for schema generation and conversion endpoints.
 
 from typing import Any, Dict, Optional
 
-from pydantic import BaseModel, Field
+from pydantic import BaseModel, ConfigDict, Field
 
 
 class SchemaGenerateRequest(BaseModel):
     """Request model for generating a Pydantic model from JSON Schema."""
     
-    schema: Dict[str, Any] = Field(..., description="JSON Schema definition")
+    schema: Dict[str, Any] = Field(..., description="JSON Schema definition", alias="schema")
     model_name: Optional[str] = Field("DynamicModel", description="Name for the generated model")
     
-    class Config:
-        json_schema_extra = {
+    model_config = ConfigDict(
+        populate_by_name=True,
+        json_schema_extra={
             "example": {
                 "schema": {
                     "type": "object",
@@ -27,17 +28,19 @@ class SchemaGenerateRequest(BaseModel):
                 "model_name": "User"
             }
         }
+    )
 
 
 class SchemaGenerateResponse(BaseModel):
     """Response model for generated schema."""
     
     model_name: str = Field(..., description="Name of the generated model")
-    schema_json: Dict[str, Any] = Field(..., description="JSON Schema representation of the model")
+    schema_definition: Dict[str, Any] = Field(..., description="JSON Schema representation of the model", alias="schema_json")
     message: str = Field(..., description="Success message")
     
-    class Config:
-        json_schema_extra = {
+    model_config = ConfigDict(
+        populate_by_name=True,
+        json_schema_extra={
             "example": {
                 "model_name": "User",
                 "schema_json": {
@@ -51,6 +54,7 @@ class SchemaGenerateResponse(BaseModel):
                 "message": "Model generated successfully"
             }
         }
+    )
 
 
 class SchemaConvertRequest(BaseModel):
@@ -71,12 +75,13 @@ class SchemaConvertRequest(BaseModel):
 class SchemaConvertResponse(BaseModel):
     """Response model for converted schema."""
     
-    schema: Dict[str, Any] = Field(..., description="JSON Schema definition")
+    schema: Dict[str, Any] = Field(..., description="JSON Schema definition", alias="schema")
     title: Optional[str] = Field(None, description="Schema title")
     version: Optional[str] = Field(None, description="Schema version")
     
-    class Config:
-        json_schema_extra = {
+    model_config = ConfigDict(
+        populate_by_name=True,
+        json_schema_extra={
             "example": {
                 "schema": {
                     "type": "object",
@@ -89,4 +94,5 @@ class SchemaConvertResponse(BaseModel):
                 "version": "1.0.0"
             }
         }
+    )