starspring 0.1.0__py3-none-any.whl

starspring/data/schema_generator.py

@@ -0,0 +1,151 @@
+"""
+Schema generator for automatic table creation
+
+Generates database schema from entity metadata, similar to Spring Boot's ddl-auto feature.
+"""
+
+from typing import Type, List
+from sqlalchemy import text
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+class SchemaGenerator:
+    """
+    Generates database schema from entity metadata
+    
+    Similar to Spring Boot's Hibernate ddl-auto feature.
+    """
+    
+    def __init__(self, session):
+        """
+        Initialize schema generator
+        
+        Args:
+            session: SQLAlchemy session
+        """
+        self.session = session
+    
+    def create_tables_from_entities(self, entity_classes: List[Type]) -> None:
+        """
+        Create database tables from entity classes
+        
+        Args:
+            entity_classes: List of entity classes with @Entity decorator
+        """
+        logger.info("Creating database tables from entities...")
+        
+        for entity_class in entity_classes:
+            if not hasattr(entity_class, '_entity_metadata'):
+                logger.warning(f"Skipping {entity_class.__name__} - not an entity")
+                continue
+            
+            try:
+                self._create_table_for_entity(entity_class)
+            except Exception as e:
+                logger.error(f"Failed to create table for {entity_class.__name__}: {e}")
+                raise
+        
+        self.session.commit()
+        logger.info(f"Successfully created {len(entity_classes)} tables")
+    
+    def _create_table_for_entity(self, entity_class: Type) -> None:
+        """
+        Create a single table from entity metadata
+        
+        Args:
+            entity_class: Entity class with metadata
+        """
+        metadata = entity_class._entity_metadata
+        table_name = metadata.table_name
+        
+        # Check if table already exists
+        check_sql = f"""
+        SELECT name FROM sqlite_master 
+        WHERE type='table' AND name='{table_name}'
+        """
+        result = self.session.execute(text(check_sql))
+        if result.fetchone():
+            logger.debug(f"Table '{table_name}' already exists, skipping")
+            return
+        
+        # Build CREATE TABLE statement
+        columns = []
+        
+        for field_name, col_meta in metadata.columns.items():
+            col_def = self._build_column_definition(field_name, col_meta)
+            columns.append(col_def)
+        
+        columns_sql = ",\n    ".join(columns)
+        create_sql = f"""
+        CREATE TABLE IF NOT EXISTS {table_name} (
+    {columns_sql}
+        )
+        """
+        
+        logger.info(f"Creating table: {table_name}")
+        self.session.execute(text(create_sql))
+    
+    def _build_column_definition(self, field_name: str, col_meta) -> str:
+        """
+        Build column definition SQL
+        
+        Args:
+            field_name: Field name
+            col_meta: Column metadata
+            
+        Returns:
+            Column definition SQL
+        """
+        from datetime import datetime
+        
+        # Determine SQL type
+        col_type = col_meta.type
+        if col_type == int:
+            sql_type = "INTEGER"
+        elif col_type == str:
+            length = col_meta.length or 255
+            sql_type = f"TEXT"  # SQLite uses TEXT for all strings
+        elif col_type == bool:
+            sql_type = "BOOLEAN"
+        elif col_type == datetime:
+            sql_type = "DATETIME"
+        elif col_type == float:
+            sql_type = "REAL"
+        else:
+            sql_type = "TEXT"  # Default fallback
+        
+        # Build column definition
+        parts = [field_name, sql_type]
+        
+        # Primary key
+        if col_meta.primary_key:
+            parts.append("PRIMARY KEY")
+        
+        # Auto increment
+        if col_meta.auto_increment:
+            parts.append("AUTOINCREMENT")
+        
+        # Nullable
+        if not col_meta.nullable:
+            parts.append("NOT NULL")
+        
+        # Unique
+        if col_meta.unique:
+            parts.append("UNIQUE")
+        
+        # Default value
+        if col_meta.default is not None and not callable(col_meta.default):
+            if isinstance(col_meta.default, bool):
+                default_val = "1" if col_meta.default else "0"
+            elif isinstance(col_meta.default, str):
+                default_val = f"'{col_meta.default}'"
+            elif isinstance(col_meta.default, (int, float)):
+                default_val = str(col_meta.default)
+            else:
+                # Skip complex defaults
+                return " ".join(parts)
+            parts.append(f"DEFAULT {default_val}")
+        
+        return " ".join(parts)

starspring/data/transaction.py

@@ -0,0 +1,58 @@
+"""
+Transaction management
+
+Provides declarative transaction support.
+"""
+
+from typing import Callable
+from functools import wraps
+from starspring.data.orm_gateway import get_orm_gateway
+
+
+def Transactional(func: Callable) -> Callable:
+    """
+    Mark a method as transactional
+    
+    Similar to Spring Boot's @Transactional annotation.
+    Automatically commits on success and rolls back on exception.
+    
+    Example:
+        @Service
+        class UserService:
+            @Transactional
+            async def create_user(self, user: User):
+                # Operations here are wrapped in a transaction
+                return await self.user_repository.save(user)
+    """
+    @wraps(func)
+    async def async_wrapper(*args, **kwargs):
+        gateway = get_orm_gateway()
+        
+        try:
+            gateway.begin_transaction()
+            result = await func(*args, **kwargs)
+            gateway.commit()
+            return result
+        except Exception as e:
+            gateway.rollback()
+            raise e
+    
+    @wraps(func)
+    def sync_wrapper(*args, **kwargs):
+        gateway = get_orm_gateway()
+        
+        try:
+            gateway.begin_transaction()
+            result = func(*args, **kwargs)
+            gateway.commit()
+            return result
+        except Exception as e:
+            gateway.rollback()
+            raise e
+    
+    # Return appropriate wrapper based on function type
+    import inspect
+    if inspect.iscoroutinefunction(func):
+        return async_wrapper
+    else:
+        return sync_wrapper

starspring/decorators/__init__.py

@@ -0,0 +1 @@
+"""Decorator components for routing, DI, and configuration"""

starspring/decorators/components.py

@@ -0,0 +1,179 @@
+"""
+Component decorators for dependency injection
+
+Provides Spring Boot-style component annotations like @Controller, @Service, etc.
+"""
+
+from typing import Optional, Type, TypeVar, Callable
+from functools import wraps
+from starspring.core.context import get_application_context, BeanScope
+
+
+T = TypeVar('T')
+
+
+def Controller(prefix: str = "") -> Callable[[Type[T]], Type[T]]:
+    """
+    Mark a class as a REST controller
+    
+    Similar to Spring Boot's @RestController annotation.
+    
+    Args:
+        prefix: URL prefix for all routes in this controller
+        
+    Example:
+        @Controller("/api/users")
+        class UserController:
+            pass
+    """
+    def decorator(cls: Type[T]) -> Type[T]:
+        # Store metadata on the class
+        cls._is_controller = True  # type: ignore
+        cls._controller_prefix = prefix  # type: ignore
+        cls._routes = []  # type: ignore
+        
+        # Register in application context
+        context = get_application_context()
+        context.register_bean(cls, scope=BeanScope.SINGLETON)
+        
+        return cls
+    
+    return decorator
+
+
+def Service(cls: Optional[Type[T]] = None, *, name: Optional[str] = None) -> Type[T]:
+    """
+    Mark a class as a service component
+    
+    Similar to Spring Boot's @Service annotation.
+    
+    Example:
+        @Service
+        class UserService:
+            pass
+    """
+    def decorator(target_cls: Type[T]) -> Type[T]:
+        # Store metadata
+        target_cls._is_service = True  # type: ignore
+        
+        # Register in application context
+        context = get_application_context()
+        context.register_bean(target_cls, scope=BeanScope.SINGLETON, name=name)
+        
+        return target_cls
+    
+    # Handle both @Service and @Service() syntax
+    if cls is None:
+        return decorator  # type: ignore
+    else:
+        return decorator(cls)
+
+
+def Component(cls: Optional[Type[T]] = None, *, name: Optional[str] = None) -> Type[T]:
+    """
+    Mark a class as a generic component
+    
+    Similar to Spring Boot's @Component annotation.
+    
+    Example:
+        @Component
+        class EmailSender:
+            pass
+    """
+    def decorator(target_cls: Type[T]) -> Type[T]:
+        # Store metadata
+        target_cls._is_component = True  # type: ignore
+        
+        # Register in application context
+        context = get_application_context()
+        context.register_bean(target_cls, scope=BeanScope.SINGLETON, name=name)
+        
+        return target_cls
+    
+    # Handle both @Component and @Component() syntax
+    if cls is None:
+        return decorator  # type: ignore
+    else:
+        return decorator(cls)
+
+
+def Repository(cls: Optional[Type[T]] = None, *, name: Optional[str] = None) -> Type[T]:
+    """
+    Mark a class as a repository component
+    
+    Similar to Spring Boot's @Repository annotation.
+    
+    Example:
+        @Repository
+        class UserRepository:
+            pass
+    """
+    def decorator(target_cls: Type[T]) -> Type[T]:
+        # Store metadata
+        target_cls._is_repository = True  # type: ignore
+        
+        # Register in application context
+        context = get_application_context()
+        context.register_bean(target_cls, scope=BeanScope.SINGLETON, name=name)
+        
+        return target_cls
+    
+    # Handle both @Repository and @Repository() syntax
+    if cls is None:
+        return decorator  # type: ignore
+    else:
+        return decorator(cls)
+
+
+def TemplateController(prefix: str = "") -> Callable[[Type[T]], Type[T]]:
+    """
+    Mark a class as a template controller
+    
+    Similar to Spring MVC's @Controller annotation.
+    Template controllers return ModelAndView objects for HTML responses.
+    
+    Args:
+        prefix: URL prefix for all routes in this controller
+        
+    Example:
+        @TemplateController("/")
+        class HomeController:
+            @GetMapping("/")
+            def index(self) -> ModelAndView:
+                return ModelAndView("index.html", {"title": "Home"})
+    """
+    def decorator(cls: Type[T]) -> Type[T]:
+        # Store metadata on the class
+        cls._is_controller = True  # type: ignore
+        cls._is_template_controller = True  # type: ignore
+        cls._controller_prefix = prefix  # type: ignore
+        cls._routes = []  # type: ignore
+        
+        # Register in application context
+        context = get_application_context()
+        context.register_bean(cls, scope=BeanScope.SINGLETON)
+        
+        return cls
+    
+    return decorator
+
+
+def Autowired(func: Callable) -> Callable:
+    """
+    Mark a method for dependency injection
+    
+    Similar to Spring Boot's @Autowired annotation.
+    This is mainly for documentation purposes as dependency injection
+    happens automatically in the constructor.
+    
+    Example:
+        @Autowired
+        def __init__(self, user_service: UserService):
+            self.user_service = user_service
+    """
+    @wraps(func)
+    def wrapper(*args, **kwargs):
+        return func(*args, **kwargs)
+    
+    wrapper._is_autowired = True  # type: ignore
+    return wrapper

starspring/decorators/configuration.py

@@ -0,0 +1,102 @@
+"""
+Configuration decorators
+
+Provides Spring Boot-style configuration annotations.
+"""
+
+from typing import Callable, Optional, Type, TypeVar, Any
+from functools import wraps
+from starspring.core.context import get_application_context
+
+
+T = TypeVar('T')
+
+
+def Configuration(cls: Type[T]) -> Type[T]:
+    """
+    Mark a class as a configuration class
+    
+    Similar to Spring Boot's @Configuration annotation.
+    Configuration classes can contain @Bean methods.
+    
+    Example:
+        @Configuration
+        class AppConfig:
+            @Bean
+            def database(self):
+                return Database()
+    """
+    cls._is_configuration = True  # type: ignore
+    
+    # Process @Bean methods
+    context = get_application_context()
+    instance = cls()
+    
+    for attr_name in dir(cls):
+        attr = getattr(cls, attr_name)
+        if callable(attr) and hasattr(attr, '_is_bean'):
+            # Call the bean factory method
+            bean_instance = attr(instance)
+            bean_type = type(bean_instance)
+            bean_name = getattr(attr, '_bean_name', None)
+            
+            # Register the bean
+            context.register_bean(
+                bean_type,
+                factory=lambda: attr(instance),
+                name=bean_name
+            )
+    
+    return cls
+
+
+def Bean(func: Optional[Callable] = None, *, name: Optional[str] = None) -> Callable:
+    """
+    Mark a method as a bean factory method
+    
+    Similar to Spring Boot's @Bean annotation.
+    Must be used within a @Configuration class.
+    
+    Args:
+        name: Optional custom name for the bean
+        
+    Example:
+        @Configuration
+        class AppConfig:
+            @Bean
+            def user_service(self):
+                return UserService()
+    """
+    def decorator(target_func: Callable) -> Callable:
+        target_func._is_bean = True  # type: ignore
+        target_func._bean_name = name  # type: ignore
+        return target_func
+    
+    # Handle both @Bean and @Bean() syntax
+    if func is None:
+        return decorator
+    else:
+        return decorator(func)
+
+
+def Value(key: str, default: Any = None) -> Any:
+    """
+    Inject a configuration value
+    
+    Similar to Spring Boot's @Value annotation.
+    
+    Args:
+        key: Configuration key to inject
+        default: Default value if key not found
+        
+    Example:
+        class MyService:
+            def __init__(self):
+                self.api_key = Value("api.key", "default-key")
+    
+    Note: This is a simplified implementation. In a real application,
+    this would integrate with the configuration system.
+    """
+    # This is a placeholder - actual implementation would read from config
+    from starspring.config.properties import get_property
+    return get_property(key, default)