starspring 0.1.0__py3-none-any.whl

starspring/core/exceptions.py

@@ -0,0 +1,82 @@
+"""
+Exception hierarchy for StarSpring framework
+
+Provides Spring Boot-style exception classes with automatic HTTP status mapping.
+"""
+
+from typing import Optional, Dict, Any
+
+
+class StarSpringException(Exception):
+    """Base exception for all StarSpring framework exceptions"""
+    
+    def __init__(
+        self,
+        message: str,
+        status_code: int = 500,
+        details: Optional[Dict[str, Any]] = None
+    ):
+        super().__init__(message)
+        self.message = message
+        self.status_code = status_code
+        self.details = details or {}
+    
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert exception to dictionary for JSON response"""
+        result = {
+            "error": self.__class__.__name__,
+            "message": self.message,
+            "status": self.status_code,
+        }
+        if self.details:
+            result["details"] = self.details
+        return result
+
+
+class BadRequestException(StarSpringException):
+    """Exception for 400 Bad Request errors"""
+    
+    def __init__(self, message: str = "Bad Request", details: Optional[Dict[str, Any]] = None):
+        super().__init__(message, status_code=400, details=details)
+
+
+class UnauthorizedException(StarSpringException):
+    """Exception for 401 Unauthorized errors"""
+    
+    def __init__(self, message: str = "Unauthorized", details: Optional[Dict[str, Any]] = None):
+        super().__init__(message, status_code=401, details=details)
+
+
+class ForbiddenException(StarSpringException):
+    """Exception for 403 Forbidden errors"""
+    
+    def __init__(self, message: str = "Forbidden", details: Optional[Dict[str, Any]] = None):
+        super().__init__(message, status_code=403, details=details)
+
+
+class NotFoundException(StarSpringException):
+    """Exception for 404 Not Found errors"""
+    
+    def __init__(self, message: str = "Resource Not Found", details: Optional[Dict[str, Any]] = None):
+        super().__init__(message, status_code=404, details=details)
+
+
+class ConflictException(StarSpringException):
+    """Exception for 409 Conflict errors"""
+    
+    def __init__(self, message: str = "Conflict", details: Optional[Dict[str, Any]] = None):
+        super().__init__(message, status_code=409, details=details)
+
+
+class ValidationException(StarSpringException):
+    """Exception for validation errors"""
+    
+    def __init__(self, message: str = "Validation Failed", details: Optional[Dict[str, Any]] = None):
+        super().__init__(message, status_code=422, details=details)
+
+
+class InternalServerException(StarSpringException):
+    """Exception for 500 Internal Server errors"""
+    
+    def __init__(self, message: str = "Internal Server Error", details: Optional[Dict[str, Any]] = None):
+        super().__init__(message, status_code=500, details=details)

starspring/core/response.py

@@ -0,0 +1,147 @@
+"""
+Response utilities similar to Spring Boot's ResponseEntity
+
+Provides structured response classes for API endpoints.
+"""
+
+from typing import Optional, Dict, Any, Generic, TypeVar
+from enum import Enum
+from pydantic import BaseModel
+
+
+T = TypeVar('T')
+
+
+class HttpStatus(Enum):
+    """HTTP status codes"""
+    OK = 200
+    CREATED = 201
+    ACCEPTED = 202
+    NO_CONTENT = 204
+    BAD_REQUEST = 400
+    UNAUTHORIZED = 401
+    FORBIDDEN = 403
+    NOT_FOUND = 404
+    CONFLICT = 409
+    UNPROCESSABLE_ENTITY = 422
+    INTERNAL_SERVER_ERROR = 500
+
+
+class ApiResponse(BaseModel, Generic[T]):
+    """
+    Generic API response wrapper
+    
+    Example:
+        return ApiResponse(
+            success=True,
+            data=user,
+            message="User created successfully"
+        )
+    """
+    success: bool
+    data: Optional[T] = None
+    message: Optional[str] = None
+    errors: Optional[Dict[str, Any]] = None
+    
+    class Config:
+        arbitrary_types_allowed = True
+
+
+class ResponseEntity(Generic[T]):
+    """
+    Response entity similar to Spring Boot's ResponseEntity
+    
+    Provides fluent API for building HTTP responses with status codes and headers.
+    
+    Example:
+        return ResponseEntity.ok(user)
+        return ResponseEntity.created(user).header("Location", "/api/users/1")
+        return ResponseEntity.not_found().body({"error": "User not found"})
+    """
+    
+    def __init__(
+        self,
+        body: Optional[T] = None,
+        status: int = 200,
+        headers: Optional[Dict[str, str]] = None
+    ):
+        self.body = body
+        self.status = status
+        self.headers = headers or {}
+    
+    def header(self, key: str, value: str) -> 'ResponseEntity[T]':
+        """Add a header to the response"""
+        self.headers[key] = value
+        return self
+    
+    def to_starlette_response(self):
+        """Convert to Starlette JSONResponse"""
+        from starlette.responses import JSONResponse
+        
+        # Handle Pydantic models
+        if hasattr(self.body, 'model_dump'):
+            content = self.body.model_dump()
+        elif hasattr(self.body, 'dict'):
+            content = self.body.dict()
+        elif isinstance(self.body, list):
+            content = [
+                item.model_dump() if hasattr(item, 'model_dump') 
+                else item.dict() if hasattr(item, 'dict')
+                else item
+                for item in self.body
+            ]
+        else:
+            content = self.body
+        
+        return JSONResponse(
+            content=content,
+            status_code=self.status,
+            headers=self.headers
+        )
+    
+    # Static factory methods for common responses
+    
+    @staticmethod
+    def ok(body: Optional[T] = None) -> 'ResponseEntity[T]':
+        """Create a 200 OK response"""
+        return ResponseEntity(body=body, status=HttpStatus.OK.value)
+    
+    @staticmethod
+    def created(body: Optional[T] = None) -> 'ResponseEntity[T]':
+        """Create a 201 Created response"""
+        return ResponseEntity(body=body, status=HttpStatus.CREATED.value)
+    
+    @staticmethod
+    def accepted(body: Optional[T] = None) -> 'ResponseEntity[T]':
+        """Create a 202 Accepted response"""
+        return ResponseEntity(body=body, status=HttpStatus.ACCEPTED.value)
+    
+    @staticmethod
+    def no_content() -> 'ResponseEntity[None]':
+        """Create a 204 No Content response"""
+        return ResponseEntity(body=None, status=HttpStatus.NO_CONTENT.value)
+    
+    @staticmethod
+    def bad_request(body: Optional[T] = None) -> 'ResponseEntity[T]':
+        """Create a 400 Bad Request response"""
+        return ResponseEntity(body=body, status=HttpStatus.BAD_REQUEST.value)
+    
+    @staticmethod
+    def unauthorized(body: Optional[T] = None) -> 'ResponseEntity[T]':
+        """Create a 401 Unauthorized response"""
+        return ResponseEntity(body=body, status=HttpStatus.UNAUTHORIZED.value)
+    
+    @staticmethod
+    def forbidden(body: Optional[T] = None) -> 'ResponseEntity[T]':
+        """Create a 403 Forbidden response"""
+        return ResponseEntity(body=body, status=HttpStatus.FORBIDDEN.value)
+    
+    @staticmethod
+    def not_found(body: Optional[T] = None) -> 'ResponseEntity[T]':
+        """Create a 404 Not Found response"""
+        return ResponseEntity(body=body, status=HttpStatus.NOT_FOUND.value)
+    
+    @staticmethod
+    def status(status_code: int, body: Optional[T] = None) -> 'ResponseEntity[T]':
+        """Create a response with custom status code"""
+        return ResponseEntity(body=body, status=status_code)

starspring/data/__init__.py

@@ -0,0 +1,47 @@
+"""
+Data package initialization
+"""
+
+from starspring.data.repository import Repository, CrudRepository, StarRepository
+from starspring.data.entity import (
+    Entity,
+    Column,
+    Id,
+    GeneratedValue,
+    ManyToOne,
+    OneToMany,
+    ManyToMany,
+    BaseEntity,
+    GenerationType,
+    ColumnMetadata,
+    RelationshipMetadata,
+    EntityMetadata
+)
+from starspring.data.orm_gateway import ORMGateway, SQLAlchemyGateway, get_orm_gateway, set_orm_gateway
+from starspring.data.transaction import Transactional
+from starspring.data.query_builder import QueryMethodParser, SQLQueryGenerator
+
+__all__ = [
+    'Repository',
+    'CrudRepository',
+    'StarRepository',
+    'Entity',
+    'Column',
+    'Id',
+    'GeneratedValue',
+    'ManyToOne',
+    'OneToMany',
+    'ManyToMany',
+    'BaseEntity',
+    'GenerationType',
+    'ColumnMetadata',
+    'RelationshipMetadata',
+    'EntityMetadata',
+    'ORMGateway',
+    'SQLAlchemyGateway',
+    'get_orm_gateway',
+    'set_orm_gateway',
+    'Transactional',
+    'QueryMethodParser',
+    'SQLQueryGenerator',
+]

starspring/data/database_config.py

@@ -0,0 +1,113 @@
+"""
+Database configuration module
+
+Provides database connection configuration for MySQL, PostgreSQL, and SQLite.
+"""
+
+from typing import Optional
+from starspring.config.properties import get_properties
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+class DatabaseConfig:
+    """
+    Database configuration
+    
+    Loads database settings from application properties and creates
+    SQLAlchemy engine and session factory.
+    """
+    
+    def __init__(self):
+        """Initialize database configuration from properties"""
+        try:
+            from sqlalchemy import create_engine
+            from sqlalchemy.orm import sessionmaker
+        except ImportError:
+            raise ImportError(
+                "SQLAlchemy is required for database support. "
+                "Install it with: pip install sqlalchemy"
+            )
+        
+        # Load configuration
+        props = get_properties()
+        
+        self.url = props.get("database.url")
+        if not self.url:
+            raise ValueError(
+                "Database URL not configured. "
+                "Add 'database.url' to application.yaml"
+            )
+        
+        self.pool_size = props.get_int("database.pool_size", 10)
+        self.max_overflow = props.get_int("database.max_overflow", 20)
+        self.echo = props.get_bool("database.echo", False)
+        self.pool_pre_ping = props.get_bool("database.pool_pre_ping", True)
+        
+        # Create engine
+        logger.info(f"Initializing database: {self._mask_password(self.url)}")
+        
+        self.engine = create_engine(
+            self.url,
+            pool_size=self.pool_size,
+            max_overflow=self.max_overflow,
+            echo=self.echo,
+            pool_pre_ping=self.pool_pre_ping
+        )
+        
+        # Create session factory
+        self.SessionFactory = sessionmaker(bind=self.engine)
+        
+        logger.info("Database initialized successfully")
+    
+    def _mask_password(self, url: str) -> str:
+        """Mask password in database URL for logging"""
+        if '@' in url and '://' in url:
+            protocol, rest = url.split('://', 1)
+            if '@' in rest:
+                credentials, host = rest.split('@', 1)
+                if ':' in credentials:
+                    user, _ = credentials.split(':', 1)
+                    return f"{protocol}://{user}:****@{host}"
+        return url
+    
+    def create_tables(self, base):
+        """
+        Create all tables defined in the Base metadata
+        
+        Args:
+            base: SQLAlchemy declarative base
+        """
+        logger.info("Creating database tables...")
+        base.metadata.create_all(self.engine)
+        logger.info("Database tables created")
+    
+    def drop_tables(self, base):
+        """
+        Drop all tables defined in the Base metadata
+        
+        Args:
+            base: SQLAlchemy declarative base
+        """
+        logger.warning("Dropping all database tables...")
+        base.metadata.drop_all(self.engine)
+        logger.info("Database tables dropped")
+
+
+# Global database config instance
+_database_config: Optional[DatabaseConfig] = None
+
+
+def get_database_config() -> DatabaseConfig:
+    """Get the global database configuration instance"""
+    global _database_config
+    if _database_config is None:
+        _database_config = DatabaseConfig()
+    return _database_config
+
+
+def set_database_config(config: DatabaseConfig):
+    """Set the global database configuration instance"""
+    global _database_config
+    _database_config = config