starspring 0.1.0__tar.gz → 0.1.1__tar.gz

{starspring-0.1.0 → starspring-0.1.1}/PKG-INFO

@@ -1,12 +1,12 @@
 Metadata-Version: 2.4
 Name: starspring
-Version: 0.1.0
+Version: 0.1.1
 Summary: A Spring Boot-inspired Python web framework built on Starlette
-Author: StarSpring Contributors
+Author: Dasun Nethsara
 License: MIT
-Project-URL: Homepage, https://github.com/yourusername/starspring
-Project-URL: Documentation, https://github.com/yourusername/starspring#readme
-Project-URL: Repository, https://github.com/yourusername/starspring
+Project-URL: Homepage, https://github.com/DasunNethsara-04/starspring
+Project-URL: Documentation, https://github.com/DasunNethsara-04/starspring#readme
+Project-URL: Repository, https://github.com/DasunNethsara-04/starspring
 Keywords: web,framework,starlette,spring-boot,dependency-injection
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
@@ -118,7 +118,7 @@ database:
 Define your database models using standard Python classes. StarSpring maps them automatically.
 
 ```python
-from starspring import Entity, BaseEntity, Column, Id, GeneratedValue
+from starspring import Entity, BaseEntity, Column
 from datetime import datetime
 
 @Entity(table_name="users")
@@ -133,13 +133,14 @@ class User(BaseEntity):
 
 ### 4. Repositories (`repositories.py`)
 Create an interface for data access. Inherit from `StarRepository`.
+Note: Identify the Entity type in the generic (e.g., `[User]`).
 
 ```python
 from starspring import Repository, StarRepository
 from my_app.entities import User
 
 @Repository
-class UserRepository(StarRepository[User, int]):
+class UserRepository(StarRepository[User]):
     # StarSpring automatically implements standard CRUD (save, find_by_id, delete, etc.)
     
     # Define custom finders just by naming them!
@@ -180,11 +181,12 @@ class UserService:
 Expose your logic as a REST API.
 
 ```python
-from starspring import RestController, GetMapping, PostMapping
-from starspring.web.response import ResponseEntity
+# Note: Use @Controller for REST endpoints too. 
+# StarSpring automatically serializes dict/list responses to JSON.
+from starspring import Controller, GetMapping, PostMapping, ResponseEntity
 from my_app.services import UserService
 
-@RestController("/api/users")
+@Controller("/api/users")
 class UserController:
     
     def __init__(self, user_service: UserService):
@@ -194,6 +196,7 @@ class UserController:
     async def get_user(self, username: str) -> dict:
         # You can return dicts, lists, or Entities directly
         user = await self.user_service.user_repo.find_by_username(username)
+        # Assuming BaseEntity has .to_dict() or Pydantic serialization
         return user.to_dict() if user else ResponseEntity.not_found()
 
     @PostMapping("/register")

{starspring-0.1.0 → starspring-0.1.1}/README.md

@@ -81,7 +81,7 @@ database:
 Define your database models using standard Python classes. StarSpring maps them automatically.
 
 ```python
-from starspring import Entity, BaseEntity, Column, Id, GeneratedValue
+from starspring import Entity, BaseEntity, Column
 from datetime import datetime
 
 @Entity(table_name="users")
@@ -96,13 +96,14 @@ class User(BaseEntity):
 
 ### 4. Repositories (`repositories.py`)
 Create an interface for data access. Inherit from `StarRepository`.
+Note: Identify the Entity type in the generic (e.g., `[User]`).
 
 ```python
 from starspring import Repository, StarRepository
 from my_app.entities import User
 
 @Repository
-class UserRepository(StarRepository[User, int]):
+class UserRepository(StarRepository[User]):
     # StarSpring automatically implements standard CRUD (save, find_by_id, delete, etc.)
     
     # Define custom finders just by naming them!
@@ -143,11 +144,12 @@ class UserService:
 Expose your logic as a REST API.
 
 ```python
-from starspring import RestController, GetMapping, PostMapping
-from starspring.web.response import ResponseEntity
+# Note: Use @Controller for REST endpoints too. 
+# StarSpring automatically serializes dict/list responses to JSON.
+from starspring import Controller, GetMapping, PostMapping, ResponseEntity
 from my_app.services import UserService
 
-@RestController("/api/users")
+@Controller("/api/users")
 class UserController:
     
     def __init__(self, user_service: UserService):
@@ -157,6 +159,7 @@ class UserController:
     async def get_user(self, username: str) -> dict:
         # You can return dicts, lists, or Entities directly
         user = await self.user_service.user_repo.find_by_username(username)
+        # Assuming BaseEntity has .to_dict() or Pydantic serialization
         return user.to_dict() if user else ResponseEntity.not_found()
 
     @PostMapping("/register")

{starspring-0.1.0 → starspring-0.1.1}/pyproject.toml

@@ -4,13 +4,13 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "starspring"
-version = "0.1.0"
+version = "0.1.1"
 description = "A Spring Boot-inspired Python web framework built on Starlette"
 readme = "README.md"
 requires-python = ">=3.10"
 license = {text = "MIT"}
 authors = [
-    {name = "StarSpring Contributors"}
+    {name = "Dasun Nethsara"}
 ]
 keywords = ["web", "framework", "starlette", "spring-boot", "dependency-injection"]
 classifiers = [
@@ -48,9 +48,9 @@ sqlalchemy = [
 ]
 
 [project.urls]
-Homepage = "https://github.com/yourusername/starspring"
-Documentation = "https://github.com/yourusername/starspring#readme"
-Repository = "https://github.com/yourusername/starspring"
+Homepage = "https://github.com/DasunNethsara-04/starspring"
+Documentation = "https://github.com/DasunNethsara-04/starspring#readme"
+Repository = "https://github.com/DasunNethsara-04/starspring"
 
 [tool.setuptools.packages.find]
 where = ["."]

{starspring-0.1.0 → starspring-0.1.1}/starspring/application.py

@@ -181,9 +181,17 @@ class StarSpringApplication:
             # This uses the imperative mappings we set up in the @Entity decorator
             # We get the engine from the gateway's session
             engine = gateway.session.get_bind()
+            
+            # Debug: Log what tables are registered
+            table_names = list(mapper_registry.metadata.tables.keys())
+            logger.info(f"Tables registered in mapper_registry: {table_names}")
+            
+            if not table_names:
+                logger.warning("No tables found in mapper_registry.metadata! Entities may not be imported yet.")
+            
             mapper_registry.metadata.create_all(engine)
             
-            logger.info("Auto-created tables using SQLAlchemy metadata")
+            logger.info(f"Auto-created tables: {table_names}")
             
         except Exception as e:
             logger.error(f"Failed to auto-create tables: {e}")

{starspring-0.1.0 → starspring-0.1.1}/starspring/data/repository.py

@@ -216,33 +216,53 @@ class StarRepository(Repository[T]):
             
             # If it's a method and it's defined (not just 'pass'), return it
             if callable(attr) and hasattr(attr, '__func__'):
-                # Check if method has actual implementation (more than just 'pass')
+                # Check if method has actual implementation (more than just 'pass' or '...')
                 source = inspect.getsource(attr.__func__)
-                if 'pass' not in source or len(source.strip().split('\n')) > 3:
+                # If it's just a stub (contains 'pass' or '...' and is short), treat as unimplemented
+                is_stub = ('pass' in source or '...' in source) and len(source.strip().split('\n')) <= 3
+                if not is_stub:
                     return attr
         except AttributeError:
             pass
         
         # Check if this is a query method that should be auto-implemented
+        # Support both camelCase (findByUsername) and snake_case (find_by_username)
         if name.startswith(('findBy', 'countBy', 'deleteBy', 'existsBy')):
             logger.debug(f"Auto-implementing query method: {name}")
-            return self._create_query_method(name)
+            return self._create_query_method(name, original_name=name)
+        elif name.startswith(('find_by_', 'count_by_', 'delete_by_', 'exists_by_')):
+            # Convert snake_case to camelCase for the parser
+            logger.debug(f"Auto-implementing query method (snake_case): {name}")
+            camel_name = self._snake_to_camel_method(name)
+            # Pass BOTH the camelCase name (for parsing) and original name (for type hints)
+            return self._create_query_method(camel_name, original_name=name)
         
         # Default behavior for everything else
         return object.__getattribute__(self, name)
     
-    def _create_query_method(self, method_name: str):
+    def _snake_to_camel_method(self, snake_name: str) -> str:
+        """Convert snake_case method name to camelCase for parser"""
+        parts = snake_name.split('_')
+        # First part stays lowercase, capitalize rest
+        return parts[0] + ''.join(word.capitalize() for word in parts[1:])
+    
+    
+    def _create_query_method(self, method_name: str, original_name: str = None):
         """
         Create a query method dynamically
         
         Args:
-            method_name: Name of the method (e.g., 'findByEmail')
+            method_name: Name of the method in camelCase for parsing (e.g., 'findByUsername')
+            original_name: Original method name as defined in class (e.g., 'find_by_username')
             
         Returns:
             Async function that executes the query
         """
         from starspring.data.query_builder import QueryMethodParser, SQLQueryGenerator, QueryOperation
         
+        # Use original_name if provided, otherwise use method_name
+        type_hint_name = original_name if original_name else method_name
+        
         # Parse the method name
         try:
             parser = QueryMethodParser()
@@ -265,6 +285,26 @@ class StarRepository(Repository[T]):
         sql, param_names = generator.generate(parsed_query)
         
         # Create the async function
+        # Helper to check return type
+        import typing  # Import typing for type hint checking
+        is_list_return = True # Default to list if ambiguous
+        try:
+            # Try to get type hints from the stub method if it exists on the class
+            if hasattr(self.__class__, type_hint_name):
+                 method = getattr(self.__class__, type_hint_name)
+                 hints = typing.get_type_hints(method)
+                 if 'return' in hints:
+                     ret_type = hints['return']
+                     # Check if it's a List
+                     origin = getattr(ret_type, '__origin__', None)
+                     if origin is list or origin is typing.List:
+                         is_list_return = True
+                     else:
+                         # Assume single entity if not List
+                         is_list_return = False
+        except Exception:
+            pass
+
         async def query_executor(*args, **kwargs):
             """Auto-generated query executor"""
             # Build parameter dictionary
@@ -283,6 +323,13 @@ class StarRepository(Repository[T]):
                 parsed_query.operation
             )
             
+            # Unwrap list if expecting single result (for find operations)
+            if parsed_query.operation == QueryOperation.FIND and not is_list_return:
+                 if isinstance(result, list):
+                     if len(result) > 0:
+                         return result[0]
+                     return None
+            
             return result
         
         return query_executor

{starspring-0.1.0 → starspring-0.1.1}/starspring/decorators/routing.py

@@ -148,7 +148,22 @@ def create_route_handler(bound_method: Callable) -> Callable:
             elif not request_injected:
                 # Don't inject into typed primitives (int, str, bool, float)
                 is_primitive = param_type in (int, str, bool, float)
-                if not is_primitive:
+                
+                # Try to extract from JSON body for primitives if not found yet
+                json_body = None
+                if is_primitive or param_type is None:
+                    try:
+                        # Only attempt to read body for methods that support it
+                        if request.method in ["POST", "PUT", "PATCH"]:
+                            # Use a cached property or similar to avoid re-reading stream if possible? 
+                            # Starlette requests cache .json() result automatically after first await.
+                            json_body = await request.json()
+                    except Exception:
+                        pass
+                
+                if json_body and isinstance(json_body, dict) and param_name in json_body:
+                     kwargs[param_name] = json_body[param_name]
+                elif not is_primitive:
                     kwargs[param_name] = request
                     request_injected = True
         

{starspring-0.1.0 → starspring-0.1.1}/starspring.egg-info/PKG-INFO

@@ -1,12 +1,12 @@
 Metadata-Version: 2.4
 Name: starspring
-Version: 0.1.0
+Version: 0.1.1
 Summary: A Spring Boot-inspired Python web framework built on Starlette
-Author: StarSpring Contributors
+Author: Dasun Nethsara
 License: MIT
-Project-URL: Homepage, https://github.com/yourusername/starspring
-Project-URL: Documentation, https://github.com/yourusername/starspring#readme
-Project-URL: Repository, https://github.com/yourusername/starspring
+Project-URL: Homepage, https://github.com/DasunNethsara-04/starspring
+Project-URL: Documentation, https://github.com/DasunNethsara-04/starspring#readme
+Project-URL: Repository, https://github.com/DasunNethsara-04/starspring
 Keywords: web,framework,starlette,spring-boot,dependency-injection
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
@@ -118,7 +118,7 @@ database:
 Define your database models using standard Python classes. StarSpring maps them automatically.
 
 ```python
-from starspring import Entity, BaseEntity, Column, Id, GeneratedValue
+from starspring import Entity, BaseEntity, Column
 from datetime import datetime
 
 @Entity(table_name="users")
@@ -133,13 +133,14 @@ class User(BaseEntity):
 
 ### 4. Repositories (`repositories.py`)
 Create an interface for data access. Inherit from `StarRepository`.
+Note: Identify the Entity type in the generic (e.g., `[User]`).
 
 ```python
 from starspring import Repository, StarRepository
 from my_app.entities import User
 
 @Repository
-class UserRepository(StarRepository[User, int]):
+class UserRepository(StarRepository[User]):
     # StarSpring automatically implements standard CRUD (save, find_by_id, delete, etc.)
     
     # Define custom finders just by naming them!
@@ -180,11 +181,12 @@ class UserService:
 Expose your logic as a REST API.
 
 ```python
-from starspring import RestController, GetMapping, PostMapping
-from starspring.web.response import ResponseEntity
+# Note: Use @Controller for REST endpoints too. 
+# StarSpring automatically serializes dict/list responses to JSON.
+from starspring import Controller, GetMapping, PostMapping, ResponseEntity
 from my_app.services import UserService
 
-@RestController("/api/users")
+@Controller("/api/users")
 class UserController:
     
     def __init__(self, user_service: UserService):
@@ -194,6 +196,7 @@ class UserController:
     async def get_user(self, username: str) -> dict:
         # You can return dicts, lists, or Entities directly
         user = await self.user_service.user_repo.find_by_username(username)
+        # Assuming BaseEntity has .to_dict() or Pydantic serialization
         return user.to_dict() if user else ResponseEntity.not_found()
 
     @PostMapping("/register")