mitsuki 0.1.0__py3-none-any.whl

mitsuki/__init__.py

@@ -0,0 +1,156 @@
+"""
+Mitsuki - Spring-inspired Python web framework.
+Enterprise-grade annotation-driven development for Python.
+"""
+
+# Core
+# Config
+from mitsuki.config import Profile, Value
+from mitsuki.core.application import Application, ApplicationContext
+from mitsuki.core.container import DIContainer, get_container
+from mitsuki.core.decorators import (
+    Component,
+    Configuration,
+    Provider,
+    Repository,
+    Scheduled,
+    Service,
+)
+from mitsuki.core.enums import (
+    ASGIMessageType,
+    ASGIScopeType,
+    DatabaseAdapter,
+    DatabaseDialect,
+    ParameterKind,
+    Scope,
+    ServerType,
+    SQLOperation,
+)
+
+# Logging
+from mitsuki.core.logging import get_logger
+from mitsuki.core.utils import get_active_profile
+
+# Data
+from mitsuki.data import (
+    UUID,
+    Column,
+    CrudRepository,
+    Entity,
+    Field,
+    Id,
+    Modifying,
+    Query,
+    UUIDv1,
+    UUIDv4,
+    UUIDv5,
+    UUIDv7,
+)
+
+# Web
+from mitsuki.web.controllers import Controller, RestController, RestRouter, Router
+from mitsuki.web.mappings import (
+    Consumes,
+    Delete,
+    DeleteMapping,
+    Get,
+    GetMapping,
+    Patch,
+    PatchMapping,
+    Post,
+    PostMapping,
+    Produces,
+    Put,
+    PutMapping,
+    RequestMapping,
+)
+from mitsuki.web.params import (
+    FormFile,
+    FormParam,
+    PathVariable,
+    QueryParam,
+    RequestBody,
+    RequestHeader,
+    RequestParam,
+)
+from mitsuki.web.response import JSONResponse, JsonResponse, ResponseEntity
+from mitsuki.web.serialization import (
+    serialize_json,
+    serialize_json_safe,
+)
+from mitsuki.web.upload import UploadFile
+
+__version__ = "0.1.0"
+__all__ = [
+    # Core
+    "Application",
+    "ApplicationContext",
+    "Component",
+    "Service",
+    "Repository",
+    "Configuration",
+    "Provider",
+    "Scheduled",
+    "DIContainer",
+    "get_container",
+    "get_active_profile",
+    # Enums
+    "ServerType",
+    "DatabaseAdapter",
+    "DatabaseDialect",
+    "SQLOperation",
+    "ASGIMessageType",
+    "ASGIScopeType",
+    "ParameterKind",
+    "Scope",
+    # Logging
+    "get_logger",
+    # Web
+    "Controller",
+    "RestController",
+    "Router",
+    "RestRouter",
+    "GetMapping",
+    "PostMapping",
+    "PutMapping",
+    "DeleteMapping",
+    "PatchMapping",
+    "RequestMapping",
+    "Produces",
+    "Consumes",
+    "Get",
+    "Post",
+    "Put",
+    "Delete",
+    "Patch",
+    "PathVariable",
+    "QueryParam",
+    "RequestParam",
+    "RequestBody",
+    "RequestHeader",
+    "FormFile",
+    "FormParam",
+    "UploadFile",
+    "ResponseEntity",
+    "JsonResponse",
+    "JSONResponse",
+    # Data
+    "Entity",
+    "CrudRepository",
+    "Id",
+    "Column",
+    "Field",
+    "UUID",
+    "UUIDv1",
+    "UUIDv4",
+    "UUIDv5",
+    "UUIDv7",
+    "Query",
+    "Modifying",
+    # Config
+    "Value",
+    "Profile",
+    # Serialization
+    "serialize_json",
+    "serialize_json_safe",
+]

mitsuki/cli/__init__.py

@@ -0,0 +1,3 @@
+from mitsuki.cli.bootstrap import main
+
+__all__ = ["main"]

mitsuki/cli/bootstrap.py

@@ -0,0 +1,215 @@
+from pathlib import Path
+
+import click
+
+from mitsuki.core.enums import DatabaseDialect
+from mitsuki.core.logging import get_logger
+
+logger = get_logger()
+
+
+def read_template(template_name: str) -> str:
+    """Read a template file from the templates directory."""
+    template_dir = Path(__file__).parent / "templates"
+    template_path = template_dir / template_name
+    return template_path.read_text()
+
+
+def create_directory(path: Path) -> None:
+    """Create a directory if it doesn't exist."""
+    path.mkdir(parents=True, exist_ok=True)
+    logger.info(f"Created directory: {path}")
+
+
+def write_file(path: Path, content: str) -> None:
+    """Write content to a file."""
+    path.write_text(content)
+    logger.info(f"Created file: {path}")
+
+
+def create_domain_files(app_dir: Path, app_name: str, domain_name: str) -> None:
+    """Create entity, repository, service, and controller for a domain."""
+    domain_lower = domain_name.lower()
+
+    # Entity
+    entity_content = read_template("entity.py.tpl").replace(
+        "{{DOMAIN_NAME}}", domain_name
+    )
+    write_file(app_dir / "domain" / f"{domain_lower}.py", entity_content)
+
+    # Repository
+    repo_content = (
+        read_template("repository.py.tpl")
+        .replace("{{DOMAIN_NAME}}", domain_name)
+        .replace("{{domain_name}}", domain_lower)
+    )
+    write_file(app_dir / "repository" / f"{domain_lower}_repository.py", repo_content)
+
+    # Service
+    service_content = (
+        read_template("service.py.tpl")
+        .replace("{{DOMAIN_NAME}}", domain_name)
+        .replace("{{domain_name}}", domain_lower)
+    )
+    write_file(app_dir / "service" / f"{domain_lower}_service.py", service_content)
+
+    # Controller
+    controller_content = (
+        read_template("controller.py.tpl")
+        .replace("{{DOMAIN_NAME}}", domain_name)
+        .replace("{{domain_name}}", domain_lower)
+    )
+    write_file(
+        app_dir / "controller" / f"{domain_lower}_controller.py", controller_content
+    )
+
+
+@click.group()
+def cli():
+    pass
+
+
+@cli.command()
+def init():
+    """Bootstrap a new Mitsuki application."""
+
+    # Application name
+    app_name = click.prompt("Application name")
+    app_name = app_name.lower().replace("-", "_").replace(" ", "_")
+
+    # Description
+    description = click.prompt("Description (optional)", default="", show_default=False)
+
+    # Database type
+    db_type = click.prompt(
+        "Database type",
+        type=click.Choice(["sqlite", "postgresql", "mysql"], case_sensitive=False),
+        default="sqlite",
+    )
+
+    # Starter domain
+    create_domain = click.confirm(
+        "Create starter domain (i.e. models/object definitions)?", default=True
+    )
+
+    domains = []
+    if create_domain:
+        domain_name = click.prompt("Domain name (e.g., User, Product)")
+        domains.append(domain_name)
+
+        # Additional domains
+        while click.confirm("Add another domain object?", default=False):
+            domain_name = click.prompt("Domain name")
+            domains.append(domain_name)
+
+    # Create project structure
+    project_root = Path.cwd() / app_name
+    src_dir = project_root / "src"
+    app_dir = src_dir / app_name
+
+    if project_root.exists():
+        click.echo(f"Error: Directory {app_name} already exists")
+        return
+
+    # Create directories
+    create_directory(project_root)
+    create_directory(src_dir)
+    create_directory(app_dir)
+
+    subdirs = ["domain", "repository", "service", "controller"]
+    init_content = read_template("__init__.py.tpl").replace(
+        "{{MODULE_DESCRIPTION}}", description or f"{app_name} module"
+    )
+
+    for subdir in subdirs:
+        create_directory(app_dir / subdir)
+        write_file(app_dir / subdir / "__init__.py", init_content)
+
+    write_file(app_dir / "__init__.py", init_content)
+
+    # Create app.py with controller imports
+    controller_imports = ""
+    if domains:
+        imports = []
+        for domain_name in domains:
+            domain_lower = domain_name.lower()
+            imports.append(
+                f"from {app_name}.controller.{domain_lower}_controller import {domain_name}Controller"
+            )
+        controller_imports = "\n" + "\n".join(imports)
+
+    app_content = read_template("app.py.tpl").replace(
+        "{{CONTROLLER_IMPORT}}", controller_imports
+    )
+    write_file(src_dir / "app.py", app_content)
+
+    # Create domain files
+    for domain_name in domains:
+        create_domain_files(app_dir, app_name, domain_name)
+
+    # Create configuration files
+    db_url_map = {
+        "sqlite": f"sqlite:///{app_name}.db",
+        "postgresql": f"postgresql://localhost/{app_name}",
+        "mysql": f"mysql://localhost/{app_name}",
+    }
+    db_url = db_url_map[db_type]
+
+    app_yml = read_template("application.yml.tpl").replace("{{app_name}}", app_name)
+    app_yml = app_yml.replace("sqlite:///{{app_name}}.db", db_url)
+    write_file(project_root / "application.yml", app_yml)
+
+    for env in ["dev", "stg", "prod"]:
+        env_yml = read_template(f"application-{env}.yml.tpl").replace(
+            "{{app_name}}", app_name
+        )
+        if db_type == DatabaseDialect.SQLITE:
+            env_yml = env_yml.replace(
+                "postgresql://localhost/{{app_name}}", f"sqlite:///{app_name}.db"
+            )
+        elif db_type == DatabaseDialect.MYSQL:
+            env_yml = env_yml.replace("postgresql://localhost/", "mysql://localhost/")
+        write_file(project_root / f"application-{env}.yml", env_yml)
+
+    # Create README
+    app_title = app_name.replace("_", " ").title()
+    domain_section = ""
+
+    if domains:
+        endpoints = []
+        for domain_name in domains:
+            domain_lower = domain_name.lower()
+            endpoints.append(f"""
+- `GET /api/{domain_lower}` - List all {domain_lower}s
+- `GET /api/{domain_lower}/{{id}}` - Get {domain_lower} by ID
+- `POST /api/{domain_lower}` - Create new {domain_lower}
+- `PUT /api/{domain_lower}/{{id}}` - Update {domain_lower}
+- `DELETE /api/{domain_lower}/{{id}}` - Delete {domain_lower}""")
+
+        domain_section = "\n## API Endpoints\n" + "\n".join(endpoints) + "\n"
+
+    readme = (
+        read_template("README.md.tpl")
+        .replace("{{APP_TITLE}}", app_title)
+        .replace("{{app_name}}", app_name)
+        .replace("{{DOMAIN_SECTION}}", domain_section)
+    )
+    write_file(project_root / "README.md", readme)
+
+    # Create .gitignore
+    gitignore = read_template("gitignore.tpl")
+    write_file(project_root / ".gitignore", gitignore)
+
+    logger.info(f"\nSuccessfully created Mitsuki application: {app_name}")
+    logger.info("\nTo get started:")
+    logger.info(f"  cd {app_name}")
+    logger.info("  MITSUKI_PROFILE=development python src/app.py")
+
+
+def main():
+    cli()
+
+
+if __name__ == "__main__":
+    # For running the bootstrap script as a script
+    cli()

mitsuki/cli/templates/README.md.tpl

@@ -0,0 +1,28 @@
+# {{APP_TITLE}}
+
+Mitsuki application generated with the Mitsuki CLI.
+{{DOMAIN_SECTION}}
+## Getting Started
+
+```bash
+pip install mitsuki
+MITSUKI_PROFILE=development python src/app.py
+```
+
+The server will start on http://127.0.0.1:8000
+
+## Project Structure
+
+```
+src/
+  {{app_name}}/
+    domain/        # @Entity classes
+    repository/    # @CrudRepository classes
+    service/       # @Service classes
+    controller/    # @RestController classes
+  app.py
+application.yml
+application-dev.yml
+application-stg.yml
+application-prod.yml
+```

mitsuki/cli/templates/__init__.py.tpl

@@ -0,0 +1 @@
+"""{{MODULE_DESCRIPTION}}"""

mitsuki/cli/templates/app.py.tpl

@@ -0,0 +1,26 @@
+"""
+Main application entry point.
+"""
+import os
+from mitsuki import Application, Value, get_logger{{CONTROLLER_IMPORT}}
+
+
+@Application
+class App:
+    """
+    Mitsuki application.
+
+    Configuration is loaded from application.yml and can be overridden
+    with environment variables (MITSUKI_SERVER_PORT, etc.)
+    """
+    port: int = Value("${server.port:8000}")
+    host: str = Value("${server.host:127.0.0.1}")
+
+
+if __name__ == "__main__":
+    # Get active profile from environment
+    profile = os.getenv("MITSUKI_PROFILE", "development")
+    logger = get_logger()
+    logger.info(f"Starting Mitsuki application with profile: {profile}")
+
+    App.run()

mitsuki/cli/templates/application-dev.yml.tpl

@@ -0,0 +1,12 @@
+# Development Configuration
+
+database:
+  url: sqlite:///dev.db
+  echo: true
+
+logging:
+  level: DEBUG
+  sqlalchemy: true
+
+app:
+  debug: true

mitsuki/cli/templates/application-prod.yml.tpl

@@ -0,0 +1,16 @@
+# Production Configuration
+
+database:
+  url: postgresql://localhost/{{app_name}}_production
+  echo: false
+  pool:
+    enabled: true
+    size: 50
+    max_overflow: 100
+
+logging:
+  level: WARNING
+  sqlalchemy: false
+
+app:
+  debug: false

mitsuki/cli/templates/application-stg.yml.tpl

@@ -0,0 +1,16 @@
+# Staging Configuration
+
+database:
+  url: postgresql://localhost/{{app_name}}_staging
+  echo: false
+  pool:
+    enabled: true
+    size: 10
+    max_overflow: 20
+
+logging:
+  level: INFO
+  sqlalchemy: false
+
+app:
+  debug: false

mitsuki/cli/templates/application.yml.tpl

@@ -0,0 +1,35 @@
+# Mitsuki Application Configuration
+
+server:
+  host: 0.0.0.0
+  port: 8000
+  type: granian  # Options: uvicorn, granian
+  workers: 1     # Number of worker processes (Currently supported on Granian only)
+  access_log: true  # Enable/disable access logging
+  ignore_trailing_slash: true
+  # timeout: 60  # Request timeout in seconds (optional, uses server defaults if not set)
+  # max_body_size: 10485760  # Max request body size in bytes (default: 10MB)
+  # cors:
+  #   enabled: false
+  #   allowed_origins:
+  #     - "*"
+
+database:
+  url: sqlite:///app.db
+  adapter: sqlalchemy
+  echo: false # SQLAlchemy logs
+  pool:
+    enabled: true
+    size: 10
+    max_overflow: 20
+    timeout: 30
+    recycle: 3600
+
+logging:
+  level: INFO
+  format: "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+  sqlalchemy: false
+
+app:
+  name: {{APP_NAME}}
+  debug: false

mitsuki/cli/templates/controller.py.tpl

@@ -0,0 +1,55 @@
+"""
+{{DOMAIN_NAME}}Controller - REST API endpoints for {{DOMAIN_NAME}}.
+"""
+import uuid
+from typing import List
+from mitsuki import RestController, GetMapping, PostMapping, DeleteMapping, QueryParam
+from ..service.{{domain_name}}_service import {{DOMAIN_NAME}}Service
+
+
+@RestController("/api/{{domain_name}}s")
+class {{DOMAIN_NAME}}Controller:
+    """REST API controller for {{DOMAIN_NAME}} resources."""
+
+    def __init__(self, service: {{DOMAIN_NAME}}Service):
+        self.service = service
+
+    @GetMapping("")
+    async def list_all(
+        self,
+        page: int = QueryParam(default=0),
+        size: int = QueryParam(default=100)
+    ) -> List[dict]:
+        """GET /api/{{domain_name}}s?page=0&size=100"""
+        entities = await self.service.get_all(page=page, size=size)
+        return [self._to_dict(e) for e in entities]
+
+    @GetMapping("/{id}")
+    async def get_by_id(self, id: str) -> dict:
+        """GET /api/{{domain_name}}s/123e4567-e89b-12d3-a456-426614174000"""
+        entity = await self.service.get_by_id(uuid.UUID(id))
+        if not entity:
+            return {"error": "Not found"}, 404
+        return self._to_dict(entity)
+
+    @PostMapping("")
+    async def create(self, body: dict) -> dict:
+        """POST /api/{{domain_name}}s"""
+        entity = await self.service.create()
+        return self._to_dict(entity), 201
+
+    @DeleteMapping("/{id}")
+    async def delete(self, id: str) -> dict:
+        """DELETE /api/{{domain_name}}s/123e4567-e89b-12d3-a456-426614174000"""
+        deleted = await self.service.delete(uuid.UUID(id))
+        if not deleted:
+            return {"error": "Not found"}, 404
+        return {"success": True}
+
+    def _to_dict(self, entity) -> dict:
+        """Convert entity to dict for JSON response"""
+        return {
+            "id": str(entity.id),
+            "created_at": entity.created_at.isoformat() if entity.created_at else None,
+            "updated_at": entity.updated_at.isoformat() if entity.updated_at else None,
+        }

mitsuki/cli/templates/entity.py.tpl

@@ -0,0 +1,16 @@
+"""
+{{DOMAIN_NAME}} entity definition.
+"""
+import uuid
+from dataclasses import dataclass
+from datetime import datetime
+from mitsuki import Entity, UUIDv7, Field
+
+
+@Entity()
+@dataclass
+class {{DOMAIN_NAME}}:
+    """{{DOMAIN_NAME}} domain object."""
+    id: uuid.UUID = UUIDv7()
+    created_at: datetime = Field(update_on_create=True)
+    updated_at: datetime = Field(update_on_save=True)

mitsuki/cli/templates/gitignore.tpl

@@ -0,0 +1,22 @@
+# Python
+__pycache__/
+*.py[cod]
+*.so
+.Python
+env/
+venv/
+*.egg-info/
+
+# Mitsuki
+*.db
+*.sqlite
+
+# IDE
+.vscode/
+.idea/
+
+# OS
+.DS_Store
+
+# Environment
+.env

mitsuki/cli/templates/repository.py.tpl

@@ -0,0 +1,46 @@
+"""
+{{DOMAIN_NAME}}Repository - Data access layer for {{DOMAIN_NAME}}.
+"""
+from typing import Optional, List
+from mitsuki import CrudRepository, Query, Modifying
+from ..domain.{{domain_name}} import {{DOMAIN_NAME}}
+
+
+@CrudRepository(entity={{DOMAIN_NAME}})
+class {{DOMAIN_NAME}}Repository:
+    """
+    Repository for {{DOMAIN_NAME}} entities.
+
+    Auto-implemented CRUD methods (you can just call these as-is):
+    - save(entity) - Create or update
+    - find_by_id(id) - Find by primary key
+    - find_all(page, size, sort_by, sort_desc) - Paginated query
+    - delete(entity) - Delete entity
+    - delete_by_id(id) - Delete by ID
+    - count() - Count all entities
+    - exists_by_id(id) - Check existence
+
+    Auto-generated query methods (define signature only):
+    Examples:
+        async def find_by_name(self, name: str) -> Optional[{{DOMAIN_NAME}}]: ...
+        async def find_by_status(self, status: str) -> List[{{DOMAIN_NAME}}]: ...
+        async def find_by_created_at_greater_than(self, created_at) -> List[{{DOMAIN_NAME}}]: ...
+
+    Custom @Query methods:
+        @Query("SELECT e FROM {{DOMAIN_NAME}} e WHERE e.status = :status ORDER BY e.created_at DESC")
+        async def find_active_sorted(self, status: str) -> List[{{DOMAIN_NAME}}]: ...
+
+    Custom @Modifying queries (UPDATE/DELETE):
+        @Modifying
+        @Query("UPDATE {{DOMAIN_NAME}} SET status = :status WHERE id = :id")
+        async def update_status(self, id: int, status: str) -> int: ...
+
+    Custom methods with direct database access:
+        async def custom_complex_query(self, param: str) -> List[dict]:
+            async with self.connection as conn:
+                result = await conn.execute("SELECT * FROM table WHERE field = :param", {"param": param})
+                return [dict(row) for row in result]
+    """
+
+    # Add your custom query methods here
+    pass

mitsuki/cli/templates/service.py.tpl

@@ -0,0 +1,37 @@
+"""
+{{DOMAIN_NAME}}Service - Business logic for {{DOMAIN_NAME}}.
+"""
+import uuid
+from typing import List, Optional
+from mitsuki import Service
+from ..domain.{{domain_name}} import {{DOMAIN_NAME}}
+from ..repository.{{domain_name}}_repository import {{DOMAIN_NAME}}Repository
+
+
+@Service()
+class {{DOMAIN_NAME}}Service:
+    """Service layer for {{DOMAIN_NAME}} business logic."""
+
+    def __init__(self, repo: {{DOMAIN_NAME}}Repository):
+        self.repo = repo
+
+    async def get_all(self, page: int = 0, size: int = 100) -> List[{{DOMAIN_NAME}}]:
+        """Get all {{domain_name}}s with pagination"""
+        return await self.repo.find_all(page=page, size=size)
+
+    async def get_by_id(self, id: uuid.UUID) -> Optional[{{DOMAIN_NAME}}]:
+        """Get {{domain_name}} by ID"""
+        return await self.repo.find_by_id(id)
+
+    async def create(self) -> {{DOMAIN_NAME}}:
+        """Create new {{domain_name}}"""
+        entity = {{DOMAIN_NAME}}(id=None)
+        return await self.repo.save(entity)
+
+    async def delete(self, id: uuid.UUID) -> bool:
+        """Delete {{domain_name}} by ID"""
+        exists = await self.repo.exists_by_id(id)
+        if not exists:
+            return False
+        await self.repo.delete_by_id(id)
+        return True