sum-cli 3.0.0__py3-none-any.whl

sum/setup/auth.py

@@ -0,0 +1,184 @@
+"""Superuser management for CLI setup."""
+
+from __future__ import annotations
+
+import json
+import logging
+from dataclasses import dataclass
+from datetime import datetime
+from pathlib import Path
+
+from sum.exceptions import SuperuserError
+from sum.utils.django import DjangoCommandExecutor
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class SuperuserResult:
+    """Result of a superuser creation operation.
+
+    Note:
+        credentials_path points to .env.local regardless of the created flag.
+        When created=False (user already existed), the file may not exist or
+        may contain different credentials. Only trust credentials_path when
+        created=True.
+    """
+
+    success: bool
+    username: str
+    credentials_path: Path
+    created: bool  # True if newly created, False if already existed
+
+
+def _escape_env_value(value: str) -> str:
+    """Escape value for .env file (wrap in quotes if needed).
+
+    Args:
+        value: The raw value to escape.
+
+    Returns:
+        The value wrapped in quotes with proper escaping.
+    """
+    # Always quote to handle spaces, #, etc.
+    escaped = value.replace("\\", "\\\\").replace('"', '\\"')
+    return f'"{escaped}"'
+
+
+class SuperuserManager:
+    """Manages Django superuser creation."""
+
+    def __init__(
+        self, django_executor: DjangoCommandExecutor, project_path: Path
+    ) -> None:
+        self.django = django_executor
+        self.project_path = project_path
+
+    def user_exists(self, username: str) -> bool:
+        """Check if a specific username already exists.
+
+        Args:
+            username: The username to check.
+
+        Returns:
+            True if the user exists, False otherwise.
+
+        Raises:
+            SuperuserError: If the Django shell command fails or returns unexpected output.
+        """
+        # Use JSON serialization to safely pass username and prevent injection
+        username_json = json.dumps(username)
+        result = self.django.run_command(
+            [
+                "shell",
+                "-v",
+                "0",
+                "-c",
+                f"import json; "
+                f"from django.contrib.auth import get_user_model; "
+                f"username = json.loads({username_json!r}); "
+                f"print(get_user_model().objects.filter(username=username).exists())",
+            ],
+            check=False,
+        )
+
+        # Check return code before parsing output
+        if result.returncode != 0:
+            raise SuperuserError(
+                f"Failed to check if user '{username}' exists: {result.stderr}"
+            )
+
+        # Validate output before returning
+        output = result.stdout.strip().lower()
+        if output not in {"true", "false"}:
+            raise SuperuserError(
+                f"Unexpected output when checking if user '{username}' exists: "
+                f"{result.stdout!r}"
+            )
+
+        return output == "true"
+
+    def create(
+        self,
+        username: str = "admin",
+        email: str = "admin@example.com",
+        password: str = "admin",
+    ) -> SuperuserResult:
+        """Create superuser and store credentials.
+
+        Idempotency: If user already exists, skips both creation and .env.local
+        writing to avoid creating a credentials file that doesn't match reality.
+
+        Args:
+            username: The username for the superuser (default: "admin").
+            email: The email for the superuser (default: "admin@example.com").
+            password: The password for the superuser (default: "admin").
+
+        Raises:
+            SuperuserError: If superuser creation fails.
+
+        Returns:
+            SuperuserResult with success=True, username, credentials path,
+            and created flag indicating if the user was newly created.
+        """
+        # Check FIRST - don't attempt creation if user exists
+        if self.user_exists(username):
+            logger.info(f"User '{username}' already exists, skipping creation")
+            return SuperuserResult(
+                success=True,
+                username=username,
+                credentials_path=self.project_path / ".env.local",
+                created=False,
+            )
+
+        # User doesn't exist - create it
+        result = self.django.run_command(
+            [
+                "createsuperuser",
+                "--noinput",
+                "--username",
+                username,
+                "--email",
+                email,
+            ],
+            env={"DJANGO_SUPERUSER_PASSWORD": password},
+            check=False,
+        )
+
+        if result.returncode != 0:
+            details = result.stderr or result.stdout or "Unknown error"
+            raise SuperuserError(f"Creation failed: {details}")
+
+        # Only write .env.local if we actually created the user
+        self._save_credentials(username, email, password)
+
+        return SuperuserResult(
+            success=True,
+            username=username,
+            credentials_path=self.project_path / ".env.local",
+            created=True,
+        )
+
+    def _save_credentials(self, username: str, email: str, password: str) -> None:
+        """Save credentials to .env.local with proper escaping.
+
+        Args:
+            username: The superuser username.
+            email: The superuser email.
+            password: The superuser password.
+        """
+        env_local = self.project_path / ".env.local"
+        date_str = datetime.now().strftime("%Y-%m-%d")
+
+        content = f"""# .env.local
+# Auto-generated by sum init on {date_str}
+# DO NOT COMMIT THIS FILE
+DJANGO_SUPERUSER_USERNAME={_escape_env_value(username)}
+DJANGO_SUPERUSER_EMAIL={_escape_env_value(email)}
+DJANGO_SUPERUSER_PASSWORD={_escape_env_value(password)}
+"""
+        # Write the file
+        env_local.write_text(content)
+
+        # Set restrictive permissions (owner read/write only) for security
+        env_local.chmod(0o600)

sum/setup/database.py

@@ -0,0 +1,58 @@
+"""Database management for CLI setup."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from sum.exceptions import MigrationError
+from sum.utils.django import DjangoCommandExecutor
+
+
+@dataclass
+class MigrationResult:
+    """Result of a migration operation."""
+
+    success: bool
+    output: str
+
+
+class DatabaseManager:
+    """Manages database operations."""
+
+    def __init__(self, django_executor: DjangoCommandExecutor) -> None:
+        self.django = django_executor
+
+    def migrate(self) -> MigrationResult:
+        """Run database migrations.
+
+        Raises:
+            MigrationError: If migration fails.
+
+        Returns:
+            MigrationResult with success=True and output.
+        """
+        result = self.django.run_command(["migrate", "--noinput"], check=False)
+
+        if result.returncode != 0:
+            message = result.stderr or result.stdout or "Unknown error"
+            raise MigrationError(f"Migration failed: {message}")
+
+        return MigrationResult(success=True, output=result.stdout)
+
+    def check_migrations(self) -> bool:
+        """Check if migrations are up to date.
+
+        Returns:
+            True if migrations are up to date, False otherwise.
+        """
+        result = self.django.run_command(["migrate", "--check"], check=False)
+        return result.returncode == 0
+
+    def get_migration_status(self) -> str:
+        """Get detailed migration status.
+
+        Returns:
+            Output from showmigrations --plan command.
+        """
+        result = self.django.run_command(["showmigrations", "--plan"], check=False)
+        return result.stdout

sum/setup/deps.py

@@ -0,0 +1,73 @@
+from __future__ import annotations
+
+import subprocess
+from pathlib import Path
+
+from sum.exceptions import DependencyError
+from sum.setup.venv import VenvManager
+from sum.utils.output import OutputFormatter
+
+
+class DependencyManager:
+    """Manage dependency installation for CLI projects."""
+
+    def __init__(self, venv_manager: VenvManager | None = None) -> None:
+        self.venv_manager = venv_manager or VenvManager()
+
+    def install(self, project_path: Path) -> None:
+        """Install dependencies from requirements.txt using the venv pip."""
+        requirements = project_path / "requirements.txt"
+        OutputFormatter.progress(1, 1, f"Installing dependencies for {project_path}")
+
+        if not requirements.exists():
+            OutputFormatter.error(f"requirements.txt not found at {requirements}")
+            raise DependencyError(f"requirements.txt not found at {requirements}")
+
+        if not self.venv_manager.exists(project_path):
+            OutputFormatter.error("Virtualenv not found for dependency install")
+            raise DependencyError("Virtualenv not found for dependency installation")
+
+        python = self.venv_manager.get_python_executable(project_path)
+        try:
+            subprocess.run(
+                [str(python), "-m", "pip", "install", "-r", str(requirements)],
+                check=True,
+                capture_output=True,
+                text=True,
+            )
+        except FileNotFoundError as exc:
+            OutputFormatter.error("Virtualenv python not found for pip install")
+            raise DependencyError(f"Virtualenv python not found at {python}") from exc
+        except subprocess.CalledProcessError as exc:
+            OutputFormatter.error("pip install failed")
+            details = exc.stderr or exc.stdout or "Unknown error"
+            raise DependencyError(f"pip install failed: {details}") from exc
+
+        OutputFormatter.success("Dependencies installed")
+
+    def verify(self, project_path: Path) -> bool:
+        """Verify key dependencies are installed in the virtualenv."""
+        OutputFormatter.progress(1, 1, f"Verifying dependencies for {project_path}")
+
+        if not self.venv_manager.exists(project_path):
+            OutputFormatter.error("Virtualenv not found for dependency verification")
+            raise DependencyError("Virtualenv not found for dependency verification")
+
+        python = self.venv_manager.get_python_executable(project_path)
+        required = ["django", "wagtail"]
+        missing: list[str] = []
+        for package in required:
+            result = subprocess.run(
+                [str(python), "-c", f"import {package}"],
+                capture_output=True,
+                text=True,
+            )
+            if result.returncode != 0:
+                missing.append(package)
+
+        if missing:
+            OutputFormatter.error(f"Missing packages: {', '.join(sorted(missing))}")
+            return False
+
+        OutputFormatter.success("Dependencies verified")
+        return True