nextpy-framework 1.0.0__py3-none-any.whl

nextpy/server/app.py

@@ -0,0 +1,325 @@
+"""
+NextPy Server Application - FastAPI-based server
+Handles routing, SSR, API routes, and static file serving
+"""
+
+import os
+import sys
+import asyncio
+import importlib.util
+from pathlib import Path
+from typing import Any, Callable, Dict, Optional
+
+from fastapi import FastAPI, Request, Response, HTTPException
+from fastapi.responses import HTMLResponse, RedirectResponse, JSONResponse
+from fastapi.staticfiles import StaticFiles
+from starlette.middleware.cors import CORSMiddleware
+
+from nextpy.core.router import Router
+from nextpy.core.renderer import Renderer
+from nextpy.core.data_fetching import (
+    PageContext,
+    execute_data_fetching,
+    PageNotFoundError,
+    RedirectError,
+)
+from nextpy.server.middleware import NextPyMiddleware
+
+
+class NextPyApp:
+    """
+    Main NextPy application class
+    Wraps FastAPI and provides Next.js-like functionality
+    """
+    
+    def __init__(
+        self,
+        pages_dir: str = "pages",
+        templates_dir: str = "templates",
+        public_dir: str = "public",
+        out_dir: str = "out",
+        debug: bool = False,
+    ):
+        self.pages_dir = Path(pages_dir)
+        self.templates_dir = Path(templates_dir)
+        self.public_dir = Path(public_dir)
+        self.out_dir = Path(out_dir)
+        self.debug = debug
+        self._modules_cache: Dict[str, Any] = {}
+        
+        self.router = Router(str(self.pages_dir), str(self.templates_dir))
+        self.renderer = Renderer(
+            str(self.templates_dir),
+            str(self.pages_dir),
+            str(self.public_dir),
+        )
+        
+        self.app = FastAPI(
+            title="NextPy Application",
+            debug=debug,
+        )
+        
+        self._setup_middleware()
+        self._setup_static_files()
+        self._setup_routes()
+        
+    def _setup_middleware(self) -> None:
+        """Configure middleware"""
+        self.app.add_middleware(
+            CORSMiddleware,
+            allow_origins=["*"],
+            allow_credentials=True,
+            allow_methods=["*"],
+            allow_headers=["*"],
+        )
+        
+        self.app.add_middleware(NextPyMiddleware)
+        
+    def _setup_static_files(self) -> None:
+        """Mount static file directories"""
+        if self.public_dir.exists():
+            self.app.mount(
+                "/static",
+                StaticFiles(directory=str(self.public_dir)),
+                name="static",
+            )
+            
+        nextpy_static = self.out_dir / "_nextpy" / "static"
+        if nextpy_static.exists():
+            self.app.mount(
+                "/_nextpy/static",
+                StaticFiles(directory=str(nextpy_static)),
+                name="nextpy_static",
+            )
+            
+    def _setup_routes(self) -> None:
+        """Set up the catch-all route handler"""
+        self.router.scan_pages()
+        
+        @self.app.get("/")
+        async def index(request: Request) -> Response:
+            return await self._handle_request(request, "/")
+            
+        @self.app.api_route("/{path:path}", methods=["GET", "POST", "PUT", "DELETE", "PATCH"])
+        async def catch_all(request: Request, path: str = "") -> Response:
+            return await self._handle_request(request, f"/{path}")
+        
+    def _load_module_from_file(self, file_path: Path) -> Optional[Any]:
+        """Load a Python module from a file path"""
+        try:
+            module_name = f"nextpy_page_{file_path.stem}_{hash(str(file_path))}"
+            
+            spec = importlib.util.spec_from_file_location(module_name, file_path)
+            if spec and spec.loader:
+                module = importlib.util.module_from_spec(spec)
+                sys.modules[module_name] = module
+                spec.loader.exec_module(module)
+                return module
+        except Exception as e:
+            if self.debug:
+                print(f"Error loading module from {file_path}: {e}")
+        return None
+        
+    async def _handle_request(self, request: Request, path: str) -> Response:
+        """Handle a page request"""
+        match = self.router.match(path)
+        
+        if not match:
+            return await self._render_404(request)
+            
+        route, params = match
+        
+        if route.is_api:
+            return await self._handle_api_request(request, route, params)
+            
+        context = PageContext(
+            params=params,
+            query=dict(request.query_params),
+            req=request,
+        )
+        
+        try:
+            props = {}
+            module = self._load_module_from_file(route.file_path)
+            
+            if module:
+                props = await execute_data_fetching(module, context)
+                    
+            template_name = self._get_template_name(route, module)
+            
+            html = await self.renderer.render_async(
+                template_name,
+                context={
+                    **props,
+                    "params": params,
+                    "query": dict(request.query_params),
+                    "request": request,
+                },
+            )
+            
+            return HTMLResponse(
+                content=html,
+                headers={
+                    "Cache-Control": "no-cache, no-store, must-revalidate",
+                    "Pragma": "no-cache",
+                    "Expires": "0",
+                },
+            )
+            
+        except PageNotFoundError:
+            return await self._render_404(request)
+            
+        except RedirectError as e:
+            status_code = 308 if e.permanent else 307
+            return RedirectResponse(url=e.destination, status_code=status_code)
+            
+        except Exception as e:
+            if self.debug:
+                import traceback
+                traceback.print_exc()
+            return await self._render_error(request, e)
+            
+    async def _handle_api_request(
+        self, 
+        request: Request, 
+        route,
+        params: Optional[Dict[str, str]] = None
+    ) -> Response:
+        """Handle an API route request"""
+        params = params or {}
+        
+        module = self._load_module_from_file(route.file_path)
+        if not module:
+            return JSONResponse(
+                {"error": "Module not found"},
+                status_code=500,
+            )
+            
+        method = request.method.lower()
+        handler = getattr(module, method, None) or getattr(module, method.upper(), None)
+        
+        if not handler:
+            handler = getattr(module, "handler", None) or getattr(module, "default", None)
+            
+        if not handler:
+            return JSONResponse(
+                {"error": f"No handler for {request.method}"},
+                status_code=405,
+            )
+            
+        try:
+            if asyncio.iscoroutinefunction(handler):
+                result = await handler(request, params)
+            else:
+                result = handler(request, params)
+                
+            if isinstance(result, Response):
+                return result
+            elif isinstance(result, dict):
+                return JSONResponse(result)
+            else:
+                return JSONResponse({"data": result})
+                
+        except Exception as e:
+            if self.debug:
+                import traceback
+                traceback.print_exc()
+            return JSONResponse(
+                {"error": str(e)},
+                status_code=500,
+            )
+        
+    def _get_template_name(self, route, module: Optional[Any] = None) -> str:
+        """Get the template name for a route"""
+        if module and hasattr(module, "get_template"):
+            return module.get_template()
+            
+        relative = route.file_path.relative_to(self.pages_dir)
+        template_name = str(relative).replace(".py", ".html")
+        
+        template_path = self.templates_dir / template_name
+        if template_path.exists():
+            return template_name
+            
+        if route.file_path.stem == "index":
+            parent_template = self.templates_dir / route.file_path.parent.name / "index.html"
+            if parent_template.exists():
+                return str(parent_template.relative_to(self.templates_dir))
+                
+        return "_page.html"
+        
+    async def _render_404(self, request: Request) -> HTMLResponse:
+        """Render the 404 page"""
+        try:
+            html = await self.renderer.render_async(
+                "_404.html",
+                context={"request": request},
+            )
+        except Exception:
+            html = """
+            <!DOCTYPE html>
+            <html>
+            <head><title>404 - Not Found</title></head>
+            <body>
+                <h1>404 - Page Not Found</h1>
+                <p>The page you're looking for doesn't exist.</p>
+            </body>
+            </html>
+            """
+        return HTMLResponse(content=html, status_code=404)
+        
+    async def _render_error(self, request: Request, error: Exception) -> HTMLResponse:
+        """Render the error page"""
+        try:
+            html = await self.renderer.render_async(
+                "_error.html",
+                context={"request": request, "error": str(error)},
+            )
+        except Exception:
+            html = f"""
+            <!DOCTYPE html>
+            <html>
+            <head><title>500 - Server Error</title></head>
+            <body>
+                <h1>500 - Server Error</h1>
+                <p>An error occurred while processing your request.</p>
+            </body>
+            </html>
+            """
+        return HTMLResponse(content=html, status_code=500)
+        
+    def reload_routes(self) -> None:
+        """Reload all routes (for hot reload)"""
+        self._modules_cache.clear()
+        self.router = Router(str(self.pages_dir), str(self.templates_dir))
+        self.router.scan_pages()
+
+
+def create_app(
+    pages_dir: str = "pages",
+    templates_dir: str = "templates",
+    public_dir: str = "public",
+    out_dir: str = "out",
+    debug: bool = False,
+) -> FastAPI:
+    """
+    Factory function to create a NextPy application
+    
+    Args:
+        pages_dir: Directory containing page files
+        templates_dir: Directory containing Jinja2 templates
+        public_dir: Directory containing static files
+        out_dir: Directory for SSG output
+        debug: Enable debug mode
+        
+    Returns:
+        FastAPI application instance
+    """
+    nextpy_app = NextPyApp(
+        pages_dir=pages_dir,
+        templates_dir=templates_dir,
+        public_dir=public_dir,
+        out_dir=out_dir,
+        debug=debug,
+    )
+    return nextpy_app.app

nextpy/server/debug.py

@@ -0,0 +1,93 @@
+"""
+Debug utilities for NextPy development
+Provides error tracking, logging, and debug panel support
+"""
+
+import traceback
+import sys
+from typing import Optional, Dict, Any
+from fastapi import Request
+from starlette.responses import HTMLResponse
+
+
+class ErrorTracker:
+    """Track and format errors for debug panel"""
+    
+    def __init__(self):
+        self.last_error: Optional[Dict[str, Any]] = None
+    
+    def capture_error(self, exc: Exception, request: Optional[Request] = None) -> Dict[str, Any]:
+        """Capture error details"""
+        tb = traceback.format_exc()
+        exc_type, exc_value, exc_tb = sys.exc_info()
+        
+        # Get file and line number
+        tb_list = traceback.extract_tb(exc_tb)
+        last_frame = tb_list[-1] if tb_list else None
+        
+        error_data = {
+            "type": exc.__class__.__name__,
+            "message": str(exc),
+            "traceback": tb,
+            "file": last_frame.filename if last_frame else None,
+            "line": last_frame.lineno if last_frame else None,
+            "path": request.url.path if request else None,
+        }
+        
+        self.last_error = error_data
+        return error_data
+    
+    def get_last_error(self) -> Optional[Dict[str, Any]]:
+        """Get last captured error"""
+        return self.last_error
+    
+    def clear_error(self):
+        """Clear last error"""
+        self.last_error = None
+
+
+error_tracker = ErrorTracker()
+
+
+async def render_error_page(error: Dict[str, Any]) -> HTMLResponse:
+    """Render error page with debug info"""
+    html = f"""
+    <!DOCTYPE html>
+    <html>
+    <head>
+        <title>NextPy Error</title>
+        <script src="https://cdn.tailwindcss.com"></script>
+        <style>
+            .animate-pulse {{ animation: pulse 2s cubic-bezier(0.4, 0, 0.6, 1) infinite; }}
+            @keyframes pulse {{
+                0%, 100% {{ opacity: 1; }}
+                50% {{ opacity: .5; }}
+            }}
+        </style>
+    </head>
+    <body class="bg-gray-900">
+        <div class="fixed bottom-0 left-0 right-0 z-50 bg-red-950 text-red-100 border-t-4 border-red-600 shadow-2xl">
+            <div class="max-w-full">
+                <div class="flex items-center justify-between p-4 bg-red-900">
+                    <div class="flex items-center gap-3">
+                        <span class="text-2xl">⚠️</span>
+                        <div>
+                            <h3 class="font-bold text-lg">{error.get('type', 'Error')}</h3>
+                            <p class="text-sm text-red-200">{error.get('message', 'An error occurred')}</p>
+                        </div>
+                    </div>
+                </div>
+                <div class="p-4">
+                    <h4 class="font-mono font-bold text-sm mb-2">Traceback:</h4>
+                    <pre class="font-mono text-xs bg-black bg-opacity-30 p-3 rounded overflow-x-auto text-red-100">{error.get('traceback', '')}</pre>
+                </div>
+                <div class="p-4 border-t border-red-800">
+                    <h4 class="font-mono font-bold text-sm mb-2">Location:</h4>
+                    <p class="text-sm"><span class="text-red-300">{error.get('file', 'unknown')}</span> line <span class="font-bold">{error.get('line', '?')}</span></p>
+                </div>
+            </div>
+        </div>
+    </body>
+    </html>
+    """
+    return HTMLResponse(html, status_code=500)

nextpy/server/middleware.py

@@ -0,0 +1,88 @@
+"""
+NextPy Middleware - Request/Response middleware for the server
+"""
+
+import time
+from typing import Callable
+from starlette.middleware.base import BaseHTTPMiddleware
+from starlette.requests import Request
+from starlette.responses import Response
+
+
+class NextPyMiddleware(BaseHTTPMiddleware):
+    """
+    Core middleware for NextPy applications
+    Handles:
+    - Request timing
+    - Cache headers
+    - Security headers
+    - HTMX detection
+    """
+    
+    async def dispatch(self, request: Request, call_next: Callable) -> Response:
+        start_time = time.time()
+        
+        request.state.is_htmx = request.headers.get("HX-Request") == "true"
+        request.state.htmx_target = request.headers.get("HX-Target")
+        request.state.htmx_trigger = request.headers.get("HX-Trigger")
+        
+        response = await call_next(request)
+        
+        process_time = time.time() - start_time
+        response.headers["X-Process-Time"] = str(process_time)
+        
+        response.headers["X-Content-Type-Options"] = "nosniff"
+        response.headers["X-Frame-Options"] = "SAMEORIGIN"
+        response.headers["X-XSS-Protection"] = "1; mode=block"
+        
+        if request.state.is_htmx:
+            response.headers["HX-Push-Url"] = str(request.url.path)
+            
+        return response
+
+
+class AuthMiddleware(BaseHTTPMiddleware):
+    """
+    Optional authentication middleware
+    Can be added to protect routes
+    """
+    
+    def __init__(self, app, protected_paths: list = None, login_path: str = "/login"):
+        super().__init__(app)
+        self.protected_paths = protected_paths or []
+        self.login_path = login_path
+        
+    async def dispatch(self, request: Request, call_next: Callable) -> Response:
+        path = request.url.path
+        
+        for protected in self.protected_paths:
+            if path.startswith(protected):
+                session = request.cookies.get("session")
+                if not session:
+                    from starlette.responses import RedirectResponse
+                    return RedirectResponse(
+                        url=f"{self.login_path}?next={path}",
+                        status_code=302,
+                    )
+                    
+        return await call_next(request)
+
+
+class CacheMiddleware(BaseHTTPMiddleware):
+    """
+    Caching middleware for static content
+    """
+    
+    CACHE_EXTENSIONS = {".js", ".css", ".png", ".jpg", ".jpeg", ".gif", ".svg", ".ico", ".woff", ".woff2"}
+    
+    async def dispatch(self, request: Request, call_next: Callable) -> Response:
+        response = await call_next(request)
+        
+        path = request.url.path
+        
+        if any(path.endswith(ext) for ext in self.CACHE_EXTENSIONS):
+            response.headers["Cache-Control"] = "public, max-age=31536000, immutable"
+        elif path.startswith("/_nextpy/"):
+            response.headers["Cache-Control"] = "public, max-age=31536000, immutable"
+            
+        return response

nextpy/utils/cache.py

@@ -0,0 +1,89 @@
+"""
+NextPy Caching Utilities
+Simple in-memory cache with TTL support
+"""
+
+import time
+from typing import Any, Optional, Dict, Callable
+import functools
+
+
+class Cache:
+    """Simple in-memory cache with TTL"""
+    
+    def __init__(self):
+        self._store: Dict[str, tuple] = {}
+    
+    def set(self, key: str, value: Any, ttl: int = 3600):
+        """Set cache value with TTL in seconds"""
+        self._store[key] = (value, time.time() + ttl)
+    
+    def get(self, key: str) -> Optional[Any]:
+        """Get cache value if not expired"""
+        if key not in self._store:
+            return None
+        
+        value, expiry = self._store[key]
+        if time.time() > expiry:
+            del self._store[key]
+            return None
+        
+        return value
+    
+    def delete(self, key: str):
+        """Delete cache value"""
+        if key in self._store:
+            del self._store[key]
+    
+    def clear(self):
+        """Clear all cache"""
+        self._store.clear()
+    
+    def cleanup_expired(self):
+        """Remove expired entries"""
+        now = time.time()
+        expired = [k for k, (_, expiry) in self._store.items() if now > expiry]
+        for k in expired:
+            del self._store[k]
+
+
+# Global cache instance
+_cache = Cache()
+
+
+def get_cache() -> Cache:
+    """Get global cache instance"""
+    return _cache
+
+
+def cache_result(ttl: int = 3600):
+    """Decorator to cache function results"""
+    def decorator(func: Callable) -> Callable:
+        @functools.wraps(func)
+        async def async_wrapper(*args, **kwargs):
+            key = f"{func.__name__}:{str(args)}:{str(kwargs)}"
+            cached = _cache.get(key)
+            if cached is not None:
+                return cached
+            result = await func(*args, **kwargs)
+            _cache.set(key, result, ttl)
+            return result
+        
+        @functools.wraps(func)
+        def sync_wrapper(*args, **kwargs):
+            key = f"{func.__name__}:{str(args)}:{str(kwargs)}"
+            cached = _cache.get(key)
+            if cached is not None:
+                return cached
+            result = func(*args, **kwargs)
+            _cache.set(key, result, ttl)
+            return result
+        
+        if hasattr(func, '__call__'):
+            import inspect
+            if inspect.iscoroutinefunction(func):
+                return async_wrapper
+        
+        return sync_wrapper
+    
+    return decorator

nextpy/utils/email.py

@@ -0,0 +1,59 @@
+"""
+NextPy Email Utilities
+Send emails via SMTP
+"""
+
+import smtplib
+from email.mime.text import MIMEText
+from email.mime.multipart import MIMEMultipart
+from typing import List, Optional
+from nextpy.config import settings
+
+
+async def send_email(
+    to: List[str],
+    subject: str,
+    html_content: str,
+    text_content: Optional[str] = None,
+) -> bool:
+    """Send email via SMTP"""
+    try:
+        msg = MIMEMultipart("alternative")
+        msg["Subject"] = subject
+        msg["From"] = settings.mail_username
+        msg["To"] = ", ".join(to)
+        
+        if text_content:
+            msg.attach(MIMEText(text_content, "plain"))
+        msg.attach(MIMEText(html_content, "html"))
+        
+        with smtplib.SMTP(settings.mail_server, settings.mail_port) as server:
+            server.starttls()
+            server.login(settings.mail_username, settings.mail_password)
+            server.sendmail(settings.mail_username, to, msg.as_string())
+        
+        return True
+    except Exception as e:
+        print(f"Email failed: {e}")
+        return False
+
+
+async def send_welcome_email(email: str, name: str) -> bool:
+    """Send welcome email"""
+    html = f"""
+    <h2>Welcome {name}!</h2>
+    <p>Thanks for joining NextPy.</p>
+    <p>Start building amazing apps today.</p>
+    """
+    return await send_email([email], "Welcome to NextPy", html)
+
+
+async def send_reset_password_email(email: str, reset_link: str) -> bool:
+    """Send password reset email"""
+    html = f"""
+    <h2>Reset Your Password</h2>
+    <p>Click the link below to reset your password:</p>
+    <a href="{reset_link}">Reset Password</a>
+    <p>This link expires in 24 hours.</p>
+    """
+    return await send_email([email], "Reset Your Password", html)